@copilotkit/channels-core 0.5.0 → 0.5.1-canary.1785633429

package/dist/create-channel.test.js

@@ -13,7 +13,10 @@ const tick = () => new Promise((r) => setTimeout(r, 0));
  * `ctx.action.value`.
  */
 const __handlerTypeGuards = () => {
-    const channel = createChannel({ adapters: [new FakeAdapter()] });
+    const channel = createChannel({
+        identifyUser: "platform",
+        adapters: [new FakeAdapter()],
+    });
     channel.onInterrupt("ask", ({ payload }) => {
         payload.question.toUpperCase();
         // @ts-expect-error 'missing' is not on the payload type
@@ -112,13 +115,20 @@ function captureSessionAgents(fake) {
 describe("createChannel", () => {
     it("rejects activation when a message-capable adapter has no eligible handler", async () => {
         const fake = new FakeAdapter({ messageEvents: true });
-        const channel = createChannel({ name: "support", adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            name: "support",
+            adapters: [fake],
+        });
         await expect(channel.ɵruntime.start()).rejects.toThrow('channel "support" must register onMention or onMessage');
         expect(fake.started).toBe(false);
     });
     it("routes an explicit mention only to onMention", async () => {
         const fake = new FakeAdapter();
-        const channel = createChannel({ adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+        });
         const mentions = vi.fn();
         const messages = vi.fn();
         channel.onMention(mentions);
@@ -141,7 +151,10 @@ describe("createChannel", () => {
     });
     it("falls an explicit mention back to onMessage", async () => {
         const fake = new FakeAdapter();
-        const channel = createChannel({ adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+        });
         const messages = vi.fn();
         channel.onMessage(messages);
         await channel.ɵruntime.start();
@@ -172,7 +185,10 @@ describe("createChannel", () => {
     });
     it("routes an ordinary message only to onMessage", async () => {
         const fake = new FakeAdapter();
-        const channel = createChannel({ adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+        });
         const mentions = vi.fn();
         const messages = vi.fn();
         channel.onMention(mentions);
@@ -196,7 +212,11 @@ describe("createChannel", () => {
     it("routes a mention to a handler that posts UI", async () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         channel.onMention(async ({ thread }) => {
             await thread.post(Section({ children: "hi" }));
         });
@@ -211,7 +231,11 @@ describe("createChannel", () => {
     it("calls renderer.finish() once after a turn's run-loop resolves", async () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         channel.onMention(async ({ thread }) => {
             await thread.runAgent();
         });
@@ -225,7 +249,11 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const added = captureAddedMessages(agent);
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         channel.onMention(async ({ thread }) => {
             await thread.runAgent();
         });
@@ -248,7 +276,11 @@ describe("createChannel", () => {
         const agent = new FakeAgent();
         const added = captureAddedMessages(agent);
         const runs = trackRunAgentCalls(agent);
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         channel.onMention(async ({ thread }) => {
             await thread.runAgent();
             await thread.runAgent();
@@ -295,6 +327,7 @@ describe("createChannel", () => {
         ]);
         const sessionAgents = captureSessionAgents(fake);
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             tools: [
@@ -342,7 +375,11 @@ describe("createChannel", () => {
             });
             return session;
         };
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         channel.onMention(async ({ thread }) => {
             await thread.runAgent();
         });
@@ -377,7 +414,11 @@ describe("createChannel", () => {
             });
             return session;
         };
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         channel.onMention(async ({ thread, message }) => {
             await thread.runAgent({ prompt: message.text });
         });
@@ -395,7 +436,11 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const added = captureAddedMessages(agent);
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         const parts = [
             { type: "text", text: "look" },
             {
@@ -424,7 +469,11 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const added = captureAddedMessages(agent);
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         const explicitParts = [
             { type: "text", text: "use this instead" },
             {
@@ -453,7 +502,11 @@ describe("createChannel", () => {
     it("dispatches a bound onClick handler on interaction", async () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         let clicked = false;
         channel.onMention(async ({ thread }) => {
             await thread.post(Actions({
@@ -481,7 +534,11 @@ describe("createChannel", () => {
     it("resolves a HITL awaitChoice with the element value when the event carries none (Telegram)", async () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         let chosen;
         channel.onMention(async ({ thread }) => {
             chosen = await thread.awaitChoice(Actions({
@@ -525,6 +582,7 @@ describe("createChannel", () => {
             };
         });
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             context: [{ description: "channel-level", value: "always here" }],
@@ -546,7 +604,11 @@ describe("createChannel", () => {
     it("thread.postFile returns a capability-gated error when the adapter can't upload", async () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         let result;
         channel.onMention(async ({ thread }) => {
             result = await thread.postFile({
@@ -565,11 +627,20 @@ describe("createChannel", () => {
     it("thread.getMessages and thread.lookupUser surface the adapter's data", async () => {
         const fake = new FakeAdapter();
         fake.messages = [
-            { user: { id: "u1", name: "Ada" }, text: "hi", ts: "1", isBot: false },
+            {
+                user: { id: "u1", kind: "human", name: "Ada" },
+                text: "hi",
+                ts: "1",
+                isBot: false,
+            },
         ];
-        fake.user = { id: "u1", name: "Ada" };
+        fake.user = { id: "u1", kind: "human", name: "Ada" };
         const agent = new FakeAgent();
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         let history;
         let resolved;
         channel.onMention(async ({ thread }) => {
@@ -580,14 +651,23 @@ describe("createChannel", () => {
         fake.emitTurn({ userText: "hi", conversationKey: "c1" });
         await tick();
         expect(history).toEqual([
-            { user: { id: "u1", name: "Ada" }, text: "hi", ts: "1", isBot: false },
+            {
+                user: { id: "u1", kind: "human", name: "Ada" },
+                text: "hi",
+                ts: "1",
+                isBot: false,
+            },
         ]);
-        expect(resolved).toEqual({ id: "u1", name: "Ada" });
+        expect(resolved).toEqual({ id: "u1", kind: "human", name: "Ada" });
     });
     it("resolves awaitChoice when a matching interaction arrives", async () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
-        const channel = createChannel({ adapters: [fake], agent: () => agent });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+            agent: () => agent,
+        });
         let choicePromise;
         channel.onMention(async ({ thread }) => {
             choicePromise = thread.awaitChoice(Actions({
@@ -622,6 +702,7 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             store: { adapter: state, onLockConflict: "drop" },
@@ -654,6 +735,7 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             store: { adapter: state, onLockConflict: "force" },
@@ -685,6 +767,7 @@ describe("createChannel", () => {
         const gate = new Promise((r) => (release = r));
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => new FakeAgent(),
             store: { adapter: state },
@@ -716,6 +799,7 @@ describe("createChannel", () => {
         const gate1 = new Promise((r) => (release1 = r));
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => new FakeAgent(),
             store: { adapter: state, concurrency: "serial" },
@@ -750,6 +834,7 @@ describe("createChannel", () => {
         const gate = new Promise((r) => (release = r));
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => new FakeAgent(),
             store: { adapter: state, concurrency: "drop" },
@@ -778,6 +863,7 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const { agents: seen } = captureSessionAgents(fake);
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: prototype, // singleton, not factory
             store: { adapter: state },
@@ -814,6 +900,7 @@ describe("createChannel", () => {
         bad.clone = () => bad;
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: bad,
             store: { adapter: state },
@@ -840,6 +927,7 @@ describe("createChannel", () => {
         // every call. Turn concurrency is parallel by default, so without isolation
         // both turns would run on `shared` and append into its one `messages` array.
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: (threadId) => {
                 shared.threadId = threadId;
@@ -908,6 +996,7 @@ describe("createChannel", () => {
         const agent = new StatefulAgent();
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             store: { adapter: state },
@@ -934,6 +1023,7 @@ describe("createChannel", () => {
         agent.runAgent = async (parameters, subscriber) => FakeAgent.prototype.runAgent.call(agent, parameters, subscriber);
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             store: { adapter: state },
@@ -956,6 +1046,7 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             store: { adapter: state },
@@ -980,36 +1071,32 @@ describe("createChannel", () => {
         await sink.onTurn({ ...base, eventId: "E2" });
         expect(runs).toBe(2);
     });
-    it("throws when identity is set without transcripts", () => {
+    it("configures transcripts without a second identity callback", async () => {
         const fake = new FakeAdapter();
-        expect(() => createChannel({
-            adapters: [fake],
-            store: { identity: () => "key" },
-        })).toThrow("createChannel: `identity` and `transcripts` must be configured together.");
-    });
-    it("throws when transcripts is set without identity", () => {
-        const fake = new FakeAdapter();
-        expect(() => createChannel({
+        const channel = createChannel({
             adapters: [fake],
+            identifyUser: "platform",
             store: { transcripts: { maxPerUser: 100 } },
-        })).toThrow("createChannel: `identity` and `transcripts` must be configured together.");
+        });
+        await channel.ɵruntime.start();
+        expect(channel.transcripts).toBeDefined();
     });
-    it("stamps message.userKey when identity resolves a key", async () => {
+    it("stamps message.user when identifyUser resolves an application user", async () => {
         const state = new MemoryStore();
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const channel = createChannel({
             adapters: [fake],
             agent: () => agent,
+            identifyUser: () => ({ id: "user@example.com", name: "Alice" }),
             store: {
                 adapter: state,
-                identity: () => "user@example.com",
                 transcripts: {},
             },
         });
         let capturedKey;
         channel.onMention(async ({ message }) => {
-            capturedKey = message.userKey;
+            capturedKey = message.user?.id;
         });
         await channel.ɵruntime.start();
         const sink = fake.getSink();
@@ -1018,7 +1105,7 @@ describe("createChannel", () => {
             replyTarget: {},
             userText: "hello",
             platform: "fake",
-            user: { id: "u1" },
+            actor: { id: "u1", kind: "human" },
         });
         expect(capturedKey).toBe("user@example.com");
     });
@@ -1027,11 +1114,11 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             store: {
                 adapter: state,
-                identity: () => "alice@example.com",
                 transcripts: { maxPerUser: 50 },
             },
         });
@@ -1041,11 +1128,11 @@ describe("createChannel", () => {
         const thread = { platform: "fake", conversationKey: "c1" };
         // Directly append via channel.transcripts
         await channel.transcripts.append(thread, { role: "user", text: "hi there" }, {
-            userKey: "alice@example.com",
+            userId: "alice@example.com",
         });
-        await channel.transcripts.append(thread, { role: "assistant", text: "hello!" }, { userKey: "alice@example.com" });
+        await channel.transcripts.append(thread, { role: "assistant", text: "hello!" }, { userId: "alice@example.com" });
         const entries = await channel.transcripts.list({
-            userKey: "alice@example.com",
+            userId: "alice@example.com",
         });
         expect(entries).toHaveLength(2);
         expect(entries[0].role).toBe("user");
@@ -1060,9 +1147,9 @@ describe("createChannel", () => {
         const channel = createChannel({
             adapters: [fake],
             agent: () => agent,
+            identifyUser: () => ({ id: "u@x.com", name: "User" }),
             store: {
                 adapter: state,
-                identity: () => "u@x.com",
                 transcripts: {},
             },
         });
@@ -1094,18 +1181,18 @@ describe("createChannel", () => {
         // Seed one prior cross-platform entry (different platform label) so we can
         // assert it shows up in the injected context. Seeded post-start: transcripts
         // are only available once the backend is resolved in start().
-        await channel.transcripts.append({ platform: "discord", conversationKey: "other" }, { role: "user", text: "remembered from discord" }, { userKey: "u@x.com" });
+        await channel.transcripts.append({ platform: "discord", conversationKey: "other" }, { role: "user", text: "remembered from discord" }, { userId: "u@x.com" });
         const sink = fake.getSink();
         await sink.onTurn({
             conversationKey: "c1",
             replyTarget: {},
             userText: "hello from fake",
             platform: "fake",
-            user: { id: "u1" },
+            actor: { id: "u1", kind: "human" },
         });
         // Append side: both the user turn and the assistant reply are recorded,
         // oldest-first (after the seeded discord entry).
-        const entries = await channel.transcripts.list({ userKey: "u@x.com" });
+        const entries = await channel.transcripts.list({ userId: "u@x.com" });
         const fakeEntries = entries.filter((e) => e.platform === "fake");
         expect(fakeEntries).toHaveLength(2);
         expect(fakeEntries[0].role).toBe("user");
@@ -1123,6 +1210,7 @@ describe("createChannel", () => {
         const fake = new FakeAdapter();
         const agent = new FakeAgent();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             agent: () => agent,
             store: {
@@ -1159,6 +1247,7 @@ describe("createChannel lock and dedup edge cases", () => {
         const fake = new FakeAdapter();
         // Use a separate channel so the throwing handler is isolated.
         const bot1 = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             store: { adapter: state, onLockConflict: "drop", lockTtl: 5000 },
         });
@@ -1196,6 +1285,7 @@ describe("createChannel lock and dedup edge cases", () => {
         let callbackMessageText;
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             store: {
                 adapter: state,
@@ -1233,6 +1323,7 @@ describe("createChannel lock and dedup edge cases", () => {
         const gate = new Promise((r) => (release = r));
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             store: {
                 adapter: state,
@@ -1257,43 +1348,48 @@ describe("createChannel lock and dedup edge cases", () => {
         await Promise.all([p1, p2]);
         expect(runs).toBe(2);
     });
-    it("identity throws: handler still runs and userKey is undefined", async () => {
+    it("identifyUser errors fail the trigger before its handler runs", async () => {
         const state = new MemoryStore();
         const fake = new FakeAdapter();
         const channel = createChannel({
             adapters: [fake],
+            identifyUser: () => {
+                throw new Error("identity failed");
+            },
             store: {
                 adapter: state,
-                identity: () => {
-                    throw new Error("x");
-                },
                 transcripts: {},
             },
         });
-        let capturedUserKey = "SENTINEL";
-        channel.onMention(async ({ message }) => {
-            capturedUserKey = message.userKey;
+        let handled = false;
+        channel.onMention(async () => {
+            handled = true;
         });
         await channel.ɵruntime.start();
         const sink = fake.getSink();
-        await sink.onTurn({
+        const delivery = sink.onTurn({
             conversationKey: "c1",
             replyTarget: {},
             userText: "hi",
             platform: "fake",
         });
-        expect(capturedUserKey).toBeUndefined();
+        await expect(delivery).rejects.toMatchObject({
+            code: "channel_identity_failed",
+            cause: expect.objectContaining({ message: "identity failed" }),
+        });
+        expect(handled).toBe(false);
     });
-    it("identity returns null: userKey is undefined", async () => {
+    it("identifyUser may return null without substituting the provider actor", async () => {
         const state = new MemoryStore();
         const fake = new FakeAdapter();
         const channel = createChannel({
             adapters: [fake],
-            store: { adapter: state, identity: () => null, transcripts: {} },
+            identifyUser: () => null,
+            store: { adapter: state, transcripts: {} },
         });
-        let capturedUserKey = "SENTINEL";
+        let capturedUser = "SENTINEL";
         channel.onMention(async ({ message }) => {
-            capturedUserKey = message.userKey;
+            capturedUser = message.user;
         });
         await channel.ɵruntime.start();
         const sink = fake.getSink();
@@ -1303,13 +1399,14 @@ describe("createChannel lock and dedup edge cases", () => {
             userText: "hi",
             platform: "fake",
         });
-        expect(capturedUserKey).toBeUndefined();
+        expect(capturedUser).toBeNull();
     });
     it("dedup+lock ordering: deduped turn never takes the lock", async () => {
         const state = new MemoryStore();
         let runs = 0;
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             store: { adapter: state, onLockConflict: "drop" },
         });
@@ -1349,6 +1446,7 @@ describe("createChannel lock and dedup edge cases", () => {
         let runs = 0;
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             store: { adapter: state },
         });
@@ -1374,6 +1472,7 @@ describe("createChannel lock and dedup edge cases", () => {
         const gate = new Promise((r) => (releaseGate = r));
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             store: { adapter: state, onLockConflict: "drop" },
         });
@@ -1416,6 +1515,7 @@ describe("createChannel lock and dedup edge cases", () => {
         let runs = 0;
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             store: { adapter: state },
         });
@@ -1442,7 +1542,10 @@ describe("createChannel lock and dedup edge cases", () => {
 describe("createChannel slash commands", () => {
     it("routes a command to its handler with the raw text", async () => {
         const fake = new FakeAdapter();
-        const channel = createChannel({ adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+        });
         let seen;
         channel.onCommand("triage", ({ command, text }) => {
             seen = { command, text };
@@ -1453,7 +1556,10 @@ describe("createChannel slash commands", () => {
     });
     it("ignores a command with no registered handler", async () => {
         const fake = new FakeAdapter();
-        const channel = createChannel({ adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+        });
         let fired = false;
         channel.onCommand("triage", () => {
             fired = true;
@@ -1466,6 +1572,7 @@ describe("createChannel slash commands", () => {
         let captured;
         const fake = new FakeAdapter();
         const channel = createChannel({
+            identifyUser: "platform",
             adapters: [fake],
             commands: [
                 defineChannelCommand({
@@ -1487,7 +1594,10 @@ describe("createChannel slash commands", () => {
     });
     it("hands declared commands to adapters that implement registerCommands", async () => {
         const fake = new FakeAdapter();
-        const channel = createChannel({ adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+        });
         channel.onCommand("triage", () => { });
         channel.onCommand("status", () => { });
         await channel.ɵruntime.start();
@@ -1500,16 +1610,124 @@ describe("createChannel slash commands", () => {
         const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
         try {
             const bad = new FakeAdapter({ platform: "telegram", failStart: true });
+            const badStop = vi.spyOn(bad, "stop");
             const good = new FakeAdapter({ platform: "slack" });
-            const channel = createChannel({ adapters: [bad, good] });
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [bad, good],
+            });
             await expect(channel.ɵruntime.start()).resolves.toBeUndefined();
             expect(good.started).toBe(true);
+            expect(badStop).toHaveBeenCalledTimes(1);
             expect(errSpy.mock.calls.some((c) => String(c[0]).includes("telegram"))).toBe(true);
         }
         finally {
             errSpy.mockRestore();
         }
     });
+    it("does not register commands on an adapter whose start failed", async () => {
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const failed = new FakeAdapter({ platform: "telegram", failStart: true });
+            const failedRegister = vi.spyOn(failed, "registerCommands");
+            const healthy = new FakeAdapter({ platform: "slack" });
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [failed, healthy],
+            });
+            channel.onCommand("triage", () => { });
+            await expect(channel.ɵruntime.start()).resolves.toBeUndefined();
+            expect(failedRegister).not.toHaveBeenCalled();
+            expect(healthy.registeredCommands?.map(({ name }) => name)).toEqual([
+                "triage",
+            ]);
+        }
+        finally {
+            errSpy.mockRestore();
+        }
+    });
+    it("start() rejects and rolls back direct adapters when the managed adapter fails", async () => {
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const direct = new FakeAdapter({ platform: "slack" });
+            const directStop = vi.spyOn(direct, "stop");
+            const managed = Object.assign(new FakeAdapter({ platform: "intelligence", failStart: true }), { __intelligenceChannel: true });
+            const managedStop = vi.spyOn(managed, "stop");
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [direct, managed],
+            });
+            await expect(channel.ɵruntime.start()).rejects.toThrow("failed to start its managed Intelligence adapter");
+            expect(direct.started).toBe(true);
+            expect(directStop).toHaveBeenCalledTimes(1);
+            expect(managedStop).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            errSpy.mockRestore();
+        }
+    });
+    it("managed-start rollback keeps stopping adapters after a synchronous stop throw", async () => {
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const throwing = new FakeAdapter({ platform: "slack" });
+            throwing.stop = vi.fn(() => {
+                throw new Error("synchronous stop failure");
+            });
+            const healthy = new FakeAdapter({ platform: "teams" });
+            const healthyStop = vi.spyOn(healthy, "stop");
+            const managed = Object.assign(new FakeAdapter({ platform: "intelligence", failStart: true }), { __intelligenceChannel: true });
+            const managedStop = vi.spyOn(managed, "stop");
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [throwing, healthy, managed],
+            });
+            await expect(channel.ɵruntime.start()).rejects.toThrow("failed to start its managed Intelligence adapter");
+            expect(throwing.stop).toHaveBeenCalledTimes(1);
+            expect(healthyStop).toHaveBeenCalledTimes(1);
+            expect(managedStop).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            errSpy.mockRestore();
+        }
+    });
+    it("managed-start rollback times out a stop that never settles", async () => {
+        vi.useFakeTimers();
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const stuck = new FakeAdapter({ platform: "slack" });
+            stuck.stop = vi.fn(() => new Promise(() => undefined));
+            const managed = Object.assign(new FakeAdapter({ platform: "intelligence", failStart: true }), { __intelligenceChannel: true });
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [stuck, managed],
+            });
+            const starting = expect(channel.ɵruntime.start()).rejects.toThrow("failed to start its managed Intelligence adapter");
+            await vi.advanceTimersByTimeAsync(5_000);
+            await starting;
+            expect(stuck.stop).toHaveBeenCalledOnce();
+            expect(errSpy.mock.calls.some((call) => call.some((part) => String(part).includes("stop timed out")))).toBe(true);
+        }
+        finally {
+            errSpy.mockRestore();
+            vi.useRealTimers();
+        }
+    });
+    it("start() stops a rejecting adapter when every adapter fails", async () => {
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const adapter = new FakeAdapter({ platform: "slack", failStart: true });
+            const stop = vi.spyOn(adapter, "stop");
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [adapter],
+            });
+            await expect(channel.ɵruntime.start()).rejects.toThrow("all 1 adapter(s) failed to connect");
+            expect(stop).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            errSpy.mockRestore();
+        }
+    });
     it("start() resolves and the healthy adapter still receives commands when another adapter's registerCommands() rejects", async () => {
         const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
         try {
@@ -1518,7 +1736,10 @@ describe("createChannel slash commands", () => {
                 failRegisterCommands: true,
             });
             const good = new FakeAdapter({ platform: "slack" });
-            const channel = createChannel({ adapters: [bad, good] });
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [bad, good],
+            });
             channel.onCommand("triage", () => { });
             await expect(channel.ɵruntime.start()).resolves.toBeUndefined();
             expect(good.started).toBe(true);
@@ -1535,7 +1756,10 @@ describe("createChannel slash commands", () => {
             const bad = new FakeAdapter({ platform: "telegram", failStop: true });
             const good = new FakeAdapter({ platform: "slack" });
             const stopSpy = vi.spyOn(good, "stop");
-            const channel = createChannel({ adapters: [bad, good] });
+            const channel = createChannel({
+                identifyUser: "platform",
+                adapters: [bad, good],
+            });
             await channel.ɵruntime.start();
             await expect(channel.ɵruntime.stop()).resolves.toBeUndefined();
             expect(stopSpy).toHaveBeenCalled();
@@ -1547,7 +1771,10 @@ describe("createChannel slash commands", () => {
     });
     it("exposes attached adapters through a read-only, non-mutable-through accessor", () => {
         const fake = new FakeAdapter();
-        const channel = createChannel({ adapters: [fake] });
+        const channel = createChannel({
+            identifyUser: "platform",
+            adapters: [fake],
+        });
         expect(channel.adapters).toContain(fake);
         expect(channel.adapters).toHaveLength(1);
         // The returned snapshot is a copy: mutating it must not affect the channel.
@@ -1555,7 +1782,7 @@ describe("createChannel slash commands", () => {
         expect(channel.adapters).toHaveLength(1);
     });
     it("reflects an adapter attached via addAdapter in the adapters accessor", () => {
-        const channel = createChannel({});
+        const channel = createChannel({ identifyUser: "platform" });
         expect(channel.adapters).toHaveLength(0);
         const fake = new FakeAdapter();
         channel.ɵruntime.addAdapter(fake);