feat(kiro): group subagent activity into Work-log entries

Kiro multiplexes `session/update` for the main session and every
spawned subagent crew over one ACP channel, each tagged with its
originating sessionId. Previously every subagent tool call, assistant
message, and content delta landed on the main chat as flat inline
rows — the "chaotic" UX relative to Claude Code's native Work-log
grouping.

Match Claude Code's behavior: subagent work appears as a collapsible
Work-log group with live per-tool activity inside, and the main
thread stays clean.

- Thread `sessionId` through every `AcpParsedSessionEvent` variant and
  through `AcpAssistantSegmentState` in `AcpSessionRuntime`, so
  KiroAdapter can tell main-session events apart from subagent events.
- Track in-flight subagents in `KiroSessionContext.subagentTasks`,
  keyed by ACP sessionId, and translate `_kiro.dev/subagent/list_update`
  roster transitions into `task.started` / `task.completed` envelopes.
  On session teardown, flush dangling tasks as `status: "stopped"` so
  the Work-log spinner doesn't hang.
- Emit one `task.progress` per distinct subagent `toolCallId` (tracked
  per-subagent in `seenToolCallIds`) so the Work-log shows live
  activity inside the group while the crew is running, instead of
  sitting silent between start and end markers.
- Format each progress row as `"{title}: {detail}"` via a new exported
  `formatSubagentToolLabel` helper so rows read "Read file: src/foo.ts"
  or "Ran command: bun test" instead of the bare category.
- Drop subagent ContentDelta / AssistantItem / PlanUpdated / ModeChanged
  events from the main thread — they're subagent internals the user
  shouldn't see.

The UI needs no changes — `deriveWorkLogEntries` already groups
task.progress/task.completed under a collapsible Work-log widget.

PATCH.md updated: new integration-points row for AcpRuntimeModel,
bumped AcpSessionRuntime row, added a user-facing feature bullet, new
row in the conflict-zones table, and a session-reflection entry.

Tests: 18 new cases — 10 around roster parsing + diff semantics
(missing sessionId, unknown status, started/completed emission,
idempotence on re-sends, implicit termination on disappearance) and
8 on `formatSubagentToolLabel` (title+detail combining, command
fallback, title-only, detail-only, identical dedup, kind fallback,
empty "Working" fallback, whitespace trimming).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: hrishi mane

PATCH.md

@@ -123,6 +123,7 @@ Kiro as a first-class ACP provider, layered on top of upstream's shared ACP infr
 - Dynamic slash commands from `_kiro.dev/commands/available` notifications
 - Context window usage from `_kiro.dev/metadata` notifications
 - Agent selection is persisted per-thread in the composer draft store
+- Subagent crews fan out into collapsible Work-log groups: `_kiro.dev/subagent/list_update` roster transitions become `task.started` / `task.completed` envelopes keyed by the crew's ACP sessionId; per-tool activity inside each crew is pulsed as `task.progress` rows (one per distinct `toolCallId`) with labels formatted as `"{title}: {detail}"` (e.g. `Read file: src/foo.ts`, `Ran command: bun test`). Subagent ContentDelta / AssistantItem / PlanUpdated / ModeChanged events are dropped from the main thread — matching Claude Code's SDK behavior of hiding subagent internals behind task notifications.
 
 ### Server-only additions (new files)
 
@@ -164,7 +165,8 @@ Every shared-file edit is a _pure addition_ (new case in a union, new entry in a
 | `provider/Layers/ProviderAdapterRegistry.ts` | Register `KiroAdapter`                                            |
 | `provider/providerStatusCache.ts`            | Add `"kiro"` to `PROVIDER_CACHE_IDS`                              |
 | `provider/makeManagedServerProvider.ts`      | Add `patchSnapshot` (additive, does not replace `enrichSnapshot`) |
-| `provider/acp/AcpSessionRuntime.ts`          | `authMethodId` made optional (Kiro uses OIDC, skips authenticate) |
+| `provider/acp/AcpSessionRuntime.ts`          | `authMethodId` optional (Kiro uses OIDC); thread `sessionId` through `AssistantSegmentState` + re-emitted `ToolCallUpdated` so subagent events can be filtered out of the main thread |
+| `provider/acp/AcpRuntimeModel.ts`            | `AcpParsedSessionEvent` union gains `sessionId` on every variant so downstream consumers can tell main-session vs subagent events apart |
 | `git/Services/TextGeneration.ts`             | Handle kiro provider kind                                         |
 
 **Web** (`apps/web/src/`):
@@ -247,7 +249,8 @@ Upstream's `makeManagedServerProvider` exposes `enrichSnapshot` for static provi
 | `apps/server/src/server.ts`                             | RuntimeServicesLive layer chain |
 | `apps/server/src/provider/Layers/ProviderRegistry.ts`   | Provider registration list      |
 | `apps/server/src/provider/providerStatusCache.ts`       | `PROVIDER_CACHE_IDS` array      |
-| `apps/server/src/provider/acp/AcpSessionRuntime.ts`     | Optional `authMethodId`         |
+| `apps/server/src/provider/acp/AcpSessionRuntime.ts`     | Optional `authMethodId`; `sessionId` plumbing for subagent filtering |
+| `apps/server/src/provider/acp/AcpRuntimeModel.ts`       | `sessionId` on `AcpParsedSessionEvent` variants  |
 | `apps/server/src/provider/makeManagedServerProvider.ts` | Added `patchSnapshot`           |
 | `apps/web/src/composerDraftStore.ts`                    | Three provider-kind lists       |
 | `apps/web/src/components/settings/SettingsPanels.tsx`   | Provider panel registration     |
@@ -311,6 +314,23 @@ Fork runs in lockstep with upstream (currently Effect v4 beta.45+). If you see t
 
 - Refactor to a single `PROVIDER_KINDS` const tuple exported from contracts to eliminate the three-list hazard permanently (also makes `normalizeProviderModelOptionsWithCapabilities` exhaustiveness-check at compile time).
 
+## Session Reflections (2026-04-20 — round 3: subagent grouping)
+
+### What broke and what fixed it
+
+**Bug: Kiro subagent crews flooded the main chat — one flat stream of "Read file" / "Ran command" / assistant-message rows per subagent, no grouping.**
+
+- Kiro's ACP transport multiplexes `session/update` for the main session *and* every spawned subagent crew over one channel, tagged with `sessionId`. Upstream's `AcpRuntimeModel.parseSessionUpdateEvent` dropped that `sessionId` before reaching the adapter, so everything looked like main-session activity.
+- Fix landed in three passes:
+  1. Thread `sessionId` through `AcpParsedSessionEvent` and `AcpSessionRuntime`, track a roster of in-flight subagents by their ACP sessionId, and translate `_kiro.dev/subagent/list_update` transitions into `task.started` / `task.completed` envelopes. Subagent session/update events are dropped on the main thread.
+  2. Dropping *everything* from subagents made the Work-log look stuck — the group sat silent until the crew terminated. Emit one `task.progress` per distinct subagent `toolCallId` (tracked per-subagent in `seenToolCallIds`) so the Work-log shows live per-tool activity inside the collapsible group, matching Claude Code's native SDK behavior.
+  3. Work-log rows initially rendered only the generic category ("Ran command", "Read file"). Kiro's typed tool-call presentation puts the action in `title` and the payload in `detail`; combine them as `"{title}: {detail}"` via a new `formatSubagentToolLabel` helper so rows show the actual command / path / query. 8 unit tests cover the helper.
+
+### Lessons worth keeping
+
+1. **Multiplexed channels need identity on every event.** Any time a transport fans in multiple logical streams, the parser must preserve the stream identity all the way to the consumer. Dropping it at the parser layer is irreversible downstream.
+2. **"Don't route" is not the same as "don't show".** The first pass filtered subagent events out of main-thread routing entirely; the fix was to keep a single summarized breadcrumb (task.progress per tool call) so the user sees progress without being drowned in subagent internals.
+
 ## Session Reflections (2026-04-20 — round 2)
 
 ### What broke and what fixed it

apps/server/src/provider/Layers/KiroAdapter.parsing.test.ts

@@ -1,6 +1,14 @@
 import { describe, expect, it } from "vitest";
 
-import { parseKiroPrompts, parseKiroSlashCommands } from "./KiroAdapter.ts";
+import { RuntimeTaskId } from "@t3tools/contracts";
+
+import {
+  diffKiroSubagentRoster,
+  formatSubagentToolLabel,
+  parseKiroPrompts,
+  parseKiroSlashCommands,
+  parseKiroSubagentList,
+} from "./KiroAdapter.ts";
 import { parseKiroAgentListOutput } from "./KiroProvider.ts";
 
 describe("parseKiroSlashCommands", () => {
@@ -164,3 +172,182 @@ describe("parseKiroAgentListOutput", () => {
     expect(agents[0]!.description).toBeUndefined();
   });
 });
+
+describe("parseKiroSubagentList", () => {
+  it("extracts sessionId, names, and status", () => {
+    const result = parseKiroSubagentList({
+      subagents: [
+        {
+          sessionId: "s1",
+          sessionName: "sdk-serialization",
+          agentName: "codebase-explorer",
+          status: { type: "working", message: "Running" },
+          group: "crew-1",
+          role: "codebase-explorer",
+          dependsOn: [],
+        },
+        {
+          sessionId: "s2",
+          sessionName: "cli-serialization",
+          agentName: "codebase-explorer",
+          status: { type: "terminated" },
+        },
+      ],
+      pendingStages: [],
+    });
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({
+      sessionId: "s1",
+      sessionName: "sdk-serialization",
+      agentName: "codebase-explorer",
+      statusType: "working",
+    });
+    expect(result[1]!.statusType).toBe("terminated");
+  });
+
+  it("falls back to sessionId when sessionName is missing", () => {
+    const result = parseKiroSubagentList({
+      subagents: [{ sessionId: "abc", status: { type: "working" } }],
+    });
+    expect(result[0]!.sessionName).toBe("abc");
+    expect(result[0]!.agentName).toBe("subagent");
+  });
+
+  it("treats unknown status shapes as 'unknown'", () => {
+    const result = parseKiroSubagentList({
+      subagents: [{ sessionId: "x", status: { type: "mystery" } }],
+    });
+    expect(result[0]!.statusType).toBe("unknown");
+  });
+
+  it("skips entries missing sessionId", () => {
+    const result = parseKiroSubagentList({
+      subagents: [{ sessionName: "no-id", status: { type: "working" } }, null, "string"],
+    });
+    expect(result).toHaveLength(0);
+  });
+
+  it("returns [] for non-object input", () => {
+    expect(parseKiroSubagentList(null)).toEqual([]);
+    expect(parseKiroSubagentList({ subagents: "nope" })).toEqual([]);
+  });
+});
+
+describe("diffKiroSubagentRoster", () => {
+  const trackedWorking = () =>
+    new Map([
+      [
+        "s1",
+        {
+          taskId: RuntimeTaskId.make("s1"),
+          sessionName: "sdk-serialization",
+          agentName: "codebase-explorer",
+          statusType: "working" as const,
+          seenToolCallIds: new Set<string>(),
+        },
+      ],
+    ]);
+
+  it("emits 'started' for a new working entry", () => {
+    const changes = diffKiroSubagentRoster(new Map(), [
+      {
+        sessionId: "s1",
+        sessionName: "sdk",
+        agentName: "codebase-explorer",
+        statusType: "working",
+      },
+    ]);
+    expect(changes).toHaveLength(1);
+    expect(changes[0]!.kind).toBe("started");
+  });
+
+  it("emits 'completed' when a tracked entry transitions to terminated", () => {
+    const changes = diffKiroSubagentRoster(trackedWorking(), [
+      { sessionId: "s1", sessionName: "sdk", agentName: "x", statusType: "terminated" },
+    ]);
+    expect(changes).toHaveLength(1);
+    expect(changes[0]!.kind).toBe("completed");
+  });
+
+  it("emits 'completed' when a tracked entry disappears from the roster", () => {
+    const changes = diffKiroSubagentRoster(trackedWorking(), []);
+    expect(changes).toHaveLength(1);
+    expect(changes[0]!.kind).toBe("completed");
+  });
+
+  it("does not re-emit 'started' for already-tracked entries", () => {
+    const changes = diffKiroSubagentRoster(trackedWorking(), [
+      { sessionId: "s1", sessionName: "sdk", agentName: "x", statusType: "working" },
+    ]);
+    expect(changes).toHaveLength(0);
+  });
+
+  it("does not re-emit 'completed' for already-terminated entries", () => {
+    const tracked = new Map([
+      [
+        "s1",
+        {
+          taskId: RuntimeTaskId.make("s1"),
+          sessionName: "sdk",
+          agentName: "x",
+          statusType: "terminated" as const,
+          seenToolCallIds: new Set<string>(),
+        },
+      ],
+    ]);
+    const changes = diffKiroSubagentRoster(tracked, [
+      { sessionId: "s1", sessionName: "sdk", agentName: "x", statusType: "terminated" },
+    ]);
+    expect(changes).toHaveLength(0);
+  });
+});
+
+describe("formatSubagentToolLabel", () => {
+  it("combines presentation title with its payload detail", () => {
+    expect(formatSubagentToolLabel({ title: "Ran command", detail: "bun test" })).toBe(
+      "Ran command: bun test",
+    );
+    expect(formatSubagentToolLabel({ title: "Read file", detail: "src/foo.ts" })).toBe(
+      "Read file: src/foo.ts",
+    );
+    expect(formatSubagentToolLabel({ title: "Searched files", detail: "useState" })).toBe(
+      "Searched files: useState",
+    );
+  });
+
+  it("falls back to command when detail is missing", () => {
+    expect(formatSubagentToolLabel({ title: "Ran command", command: "ls -la" })).toBe(
+      "Ran command: ls -la",
+    );
+  });
+
+  it("returns the title alone when no detail is available", () => {
+    expect(formatSubagentToolLabel({ title: "Summarizing" })).toBe("Summarizing");
+  });
+
+  it("returns the detail alone when no title is available", () => {
+    expect(formatSubagentToolLabel({ detail: "apps/server/foo.ts" })).toBe(
+      "apps/server/foo.ts",
+    );
+  });
+
+  it("does not duplicate when title and detail are identical", () => {
+    expect(formatSubagentToolLabel({ title: "Summarizing", detail: "Summarizing" })).toBe(
+      "Summarizing",
+    );
+  });
+
+  it("falls through to kind when everything else is empty", () => {
+    expect(formatSubagentToolLabel({ kind: "execute" })).toBe("execute");
+  });
+
+  it("returns 'Working' as a last-resort fallback", () => {
+    expect(formatSubagentToolLabel({})).toBe("Working");
+  });
+
+  it("trims whitespace on all inputs", () => {
+    expect(formatSubagentToolLabel({ title: "  Ran command  ", detail: "  ls  " })).toBe(
+      "Ran command: ls",
+    );
+  });
+});