fix(channel): survive agent restart — reconcile channels after S3 pull (#7)

Chat-configured Telegram bots died on every restart: channel configs were
resolved from local disk at construction time, BEFORE restoreState() pulled
data/channels/* from S3, so on a fresh container fs the file-sourced config
was invisible and polling never started (channel_list then showed
source: file, connected: false).

- ChannelModule.reconcileFromDisk(): re-resolves file/env configs after the
  S3 pull and diffs against the registered set — registers missing channels,
  replaces on token change, deregisters on tombstone. Wired into
  connectChannels() before service.start(); mock harnesses untouched.
- removeChannel() writes a tombstone ({removed: true}) instead of deleting
  the file — the pod env keeps the old token until the next redeploy, and a
  missing file would let the env fallback resurrect a removed channel.
  resolveBootConfigs()/listInfo() honor the tombstone; a groups-only file
  (env-configured bot) still falls through to env.
- Runtime now writes data/channels/status.json (connected/error/updatedAt
  per channel) on start results, channel set/replace, and removal — the
  platform merges it into GET /agents/:id/channels so the admin UI shows
  live state instead of guessing from config presence.
- ChannelService.start() returns per-channel outcomes (allSettled isolation
  kept) so failures carry a reason instead of stopping at logs.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: maksymhryzodub-prog

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleanslice/runtime",
-  "version": "0.27.1",
+  "version": "0.28.0",
   "license": "MIT",
   "type": "module",
   "bin": {

src/slices/runtime/runtime/runtime.module.ts

@@ -305,6 +305,16 @@ export class AgentRuntime {
     this.session.setActivityReporter({
       report: activity => this.channel.reportSessionActivity(activity),
     })
+    // Channel configs were resolved before restoreState() pulled S3 state —
+    // on a fresh container fs the per-channel files weren't on disk yet, so
+    // file-configured channels (chat-configured Telegram) resolved to nothing
+    // and stayed dead after every restart. Reconcile against the pulled state
+    // before starting; a reconcile failure degrades to the pre-pull set.
+    try {
+      await this.channel.reconcileFromDisk()
+    } catch (err) {
+      s3Log.warn(`channel reconcile after pull failed — starting with boot-time channel set. Error: ${(err as Error).message}`)
+    }
     await this.channel.start()
   }
 

src/slices/setup/channel/channel.module.spec.ts

@@ -0,0 +1,156 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, mkdirSync } from "fs"
+import { tmpdir } from "os"
+import { join } from "path"
+import { ChannelModule } from "./channel.module"
+import { saveTelegramFile } from "./data/repositories/telegram/telegramFile"
+import type { IChannelGateway } from "./domain/channel.gateway"
+
+function agentDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "channel-module-"))
+  mkdirSync(join(dir, "data"), { recursive: true })
+  return dir
+}
+
+function mockGateway(name = "mock"): IChannelGateway {
+  return {
+    name,
+    start: () => Promise.resolve(),
+    stop: () => Promise.resolve(),
+    send: () => Promise.resolve(),
+    onMessage: () => {},
+  }
+}
+
+// resolveBootConfigs / reconcileFromDisk mutate the env mirror — isolate it.
+const ENV_KEYS = [
+  "TELEGRAM_BOT_TOKEN", "TELEGRAM_BOT_NAME", "TELEGRAM_BOT_ADMIN_IDS",
+  "SLACK_BOT_TOKEN", "SLACK_APP_TOKEN", "BRIDLE_URL",
+] as const
+let envSnapshot: Record<string, string | undefined>
+
+beforeEach(() => {
+  envSnapshot = Object.fromEntries(ENV_KEYS.map(k => [k, process.env[k]]))
+  for (const k of ENV_KEYS) delete process.env[k]
+})
+
+afterEach(() => {
+  for (const k of ENV_KEYS) {
+    if (envSnapshot[k] === undefined) delete process.env[k]
+    else process.env[k] = envSnapshot[k]
+  }
+})
+
+describe("resolveBootConfigs", () => {
+  test("file with credentials wins over env", async () => {
+    const dir = agentDir()
+    await saveTelegramFile(dir, { botToken: "file:token" })
+    process.env.TELEGRAM_BOT_TOKEN = "env:token"
+
+    const configs = await ChannelModule.resolveBootConfigs(dir)
+
+    const telegram = configs.find(c => c.type === "telegram")
+    expect(telegram).toEqual({ type: "telegram", token: "file:token" })
+    expect(process.env.TELEGRAM_BOT_TOKEN).toBe("file:token")
+  })
+
+  test("tombstone (removed: true) suppresses the env fallback", async () => {
+    const dir = agentDir()
+    await saveTelegramFile(dir, { removed: true })
+    process.env.TELEGRAM_BOT_TOKEN = "env:token"
+
+    const configs = await ChannelModule.resolveBootConfigs(dir)
+
+    expect(configs.find(c => c.type === "telegram")).toBeUndefined()
+  })
+
+  test("groups-only file (env-configured bot) keeps the env fallback", async () => {
+    const dir = agentDir()
+    // The group tracker persists groups into telegram.json even when the bot
+    // config came from env — that file is NOT a tombstone.
+    await saveTelegramFile(dir, {
+      groups: { "-100": { id: "-100", type: "group", status: "member", addedAt: 1, lastSeenAt: 2 } },
+    })
+    process.env.TELEGRAM_BOT_TOKEN = "env:token"
+
+    const configs = await ChannelModule.resolveBootConfigs(dir)
+
+    expect(configs.find(c => c.type === "telegram")).toEqual({ type: "telegram", token: "env:token" })
+  })
+
+  test("no file and no env → no telegram config", async () => {
+    const dir = agentDir()
+    const configs = await ChannelModule.resolveBootConfigs(dir)
+    expect(configs.find(c => c.type === "telegram")).toBeUndefined()
+  })
+})
+
+describe("reconcileFromDisk", () => {
+  test("config file that appeared after construction registers the channel", async () => {
+    const dir = agentDir()
+    // Simulates the k8s boot race: empty disk at construction, S3 pull lands
+    // telegram.json before connectChannels().
+    const module = new ChannelModule([], dir)
+    await saveTelegramFile(dir, { botToken: "123:pulled" })
+
+    await module.reconcileFromDisk()
+
+    const info = await module.listInfo()
+    const telegram = info.find(i => i.type === "telegram")
+    expect(telegram?.source).toBe("file")
+    expect(telegram?.connected).toBe(true) // registered in the service (starts with service.start())
+  })
+
+  test("token change on disk replaces the registered gateway", async () => {
+    const dir = agentDir()
+    const module = new ChannelModule([{ type: "telegram", token: "env:old" }], dir)
+    await saveTelegramFile(dir, { botToken: "file:new" })
+
+    await module.reconcileFromDisk()
+
+    expect(process.env.TELEGRAM_BOT_TOKEN).toBe("file:new")
+    const telegram = (await module.listInfo()).find(i => i.type === "telegram")
+    expect(telegram?.connected).toBe(true)
+  })
+
+  test("unchanged config is left alone", async () => {
+    const dir = agentDir()
+    await saveTelegramFile(dir, { botToken: "123:same" })
+    const module = new ChannelModule(
+      await ChannelModule.resolveBootConfigs(dir),
+      dir,
+    )
+
+    await module.reconcileFromDisk()
+
+    const telegram = (await module.listInfo()).find(i => i.type === "telegram")
+    expect(telegram?.connected).toBe(true)
+  })
+
+  test("tombstone deregisters a previously registered channel", async () => {
+    const dir = agentDir()
+    const module = new ChannelModule([{ type: "telegram", token: "env:old" }], dir)
+    await saveTelegramFile(dir, { removed: true })
+    process.env.TELEGRAM_BOT_TOKEN = "env:old" // pod env survives until redeploy
+
+    await module.reconcileFromDisk()
+
+    expect((await module.listInfo()).find(i => i.type === "telegram")).toBeUndefined()
+    expect(module.send("telegram", "1", "hi")).rejects.toThrow("Channel not found")
+  })
+
+  test("mock-only setups are untouched (paddock/test harness)", async () => {
+    const dir = agentDir()
+    const module = new ChannelModule([{ type: "mock", instance: mockGateway() }], dir)
+    await saveTelegramFile(dir, { botToken: "123:abc" })
+
+    await module.reconcileFromDisk()
+
+    expect(module.send("telegram", "1", "hi")).rejects.toThrow("Channel not found")
+  })
+
+  test("no agentDir → no-op", async () => {
+    const module = new ChannelModule([])
+    await module.reconcileFromDisk() // must not throw
+  })
+})