feat(tower): interrupt tower wake turns on user input and harden tower operations

- tower mode: a message sent while the agent is running aborts the in-progress inbox-wake turn and runs as its own turn; notification-seeded turn waiters now settle launched/completion
- TowerTeardown: keeps worktrees of live agents (not overridable with force), supports exclude and dry_run, and treats large gitignored data as dirty
- tower roster: died/revived store writes are guarded to the active tower session and attributed with session+pid; agents stopped by the user are marked dead by intent with no revival nag
- tests: pin background panel registration for resumed background agents

Author: konghuanjun

.changeset/steer-into-notification-seeded-turn.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+Tower mode: a message sent while the agent is running now aborts the in-progress turn and runs as its own turn; TowerTeardown now protects running agents' worktrees and accepts exclude and dry_run parameters; user-stopped workers are no longer suggested for revival.

apps/kimi-code/test/tui/controllers/subagent-event-handler.test.ts

@@ -29,6 +29,8 @@ function makeSwarmHandler() {
       getTurnContext: vi.fn(() => ({ turnId: 1, step: 0 })),
       removeToolComponentIfInactive: vi.fn(),
       finalizeLiveTextBuffers: vi.fn(),
+      applyBackgroundTaskTerminalStatus: vi.fn(),
+      markSubagentBackgrounded: vi.fn(),
     },
     appendTranscriptEntry: vi.fn(),
     btwPanelController: { routeEvent: vi.fn(() => false) },
@@ -181,3 +183,81 @@ describe('SubAgentEventHandler — swarm grid height measurement', () => {
     handler.clearAgentSwarmProgress();
   });
 });
+
+describe('SubAgentEventHandler — background agent resume', () => {
+  function backgroundLifecycleEvent(
+    type: 'subagent.spawned' | 'subagent.completed' | 'subagent.cancelled',
+    subagentId: string,
+    parentToolCallId: string,
+  ): SubagentLifecycleEvent {
+    return {
+      sessionId: 's1',
+      agentId: 'main',
+      type,
+      subagentId,
+      subagentName: 'explore',
+      parentToolCallId,
+      description: `task ${subagentId}`,
+      runInBackground: true,
+      resultSummary: type === 'subagent.completed' ? 'done' : undefined,
+    } as unknown as SubagentLifecycleEvent;
+  }
+
+  function backgroundChildDelta(subagentId: string): Event {
+    return {
+      sessionId: 's1',
+      agentId: subagentId,
+      type: 'assistant.delta',
+      delta: 'progress',
+    } as unknown as Event;
+  }
+
+  it('re-registers a resumed background agent and flips its activity record back to running', () => {
+    const { handler, host } = makeSwarmHandler();
+    handler.handleLifecycleEvent(backgroundLifecycleEvent('subagent.spawned', 'agent-2', 'tc-first'));
+    handler.routeChildAgentEvent(backgroundChildDelta('agent-2'));
+    handler.handleLifecycleEvent(
+      backgroundLifecycleEvent('subagent.cancelled', 'agent-2', 'tc-first'),
+    );
+    expect(handler.backgroundAgentMetadata.has('agent-2')).toBe(false);
+    expect(handler.activityStore.get('agent-2')?.status).toBe('failed');
+
+    handler.handleLifecycleEvent(
+      backgroundLifecycleEvent('subagent.spawned', 'agent-2', 'tc-resume'),
+    );
+
+    expect(handler.backgroundAgentMetadata.get('agent-2')).toMatchObject({
+      agentId: 'agent-2',
+      parentToolCallId: 'tc-resume',
+      agentName: 'explore',
+    });
+    expect(handler.activityStore.get('agent-2')?.status).toBe('running');
+    const startedEntries = host.appendTranscriptEntry.mock.calls.filter(
+      ([entry]) => entry.backgroundAgentStatus?.phase === 'started',
+    );
+    expect(startedEntries).toHaveLength(2);
+
+    handler.routeChildAgentEvent(backgroundChildDelta('agent-2'));
+    expect(handler.activityStore.get('agent-2')?.steps.length).toBeGreaterThan(0);
+  });
+
+  it('transitions the resumed background agent to its terminal state', () => {
+    const { handler, host } = makeSwarmHandler();
+    handler.handleLifecycleEvent(
+      backgroundLifecycleEvent('subagent.spawned', 'agent-2', 'tc-resume'),
+    );
+    handler.routeChildAgentEvent(backgroundChildDelta('agent-2'));
+
+    handler.handleLifecycleEvent(
+      backgroundLifecycleEvent('subagent.completed', 'agent-2', 'tc-resume'),
+    );
+
+    expect(handler.backgroundAgentMetadata.has('agent-2')).toBe(false);
+    expect(handler.activityStore.get('agent-2')?.status).toBe('completed');
+    expect(host.appendTranscriptEntry).toHaveBeenCalledWith(
+      expect.objectContaining({
+        backgroundAgentStatus: expect.objectContaining({ phase: 'completed' }),
+      }),
+    );
+  });
+});

packages/agent-core-v2/src/agent/loop/loopService.ts

@@ -1093,7 +1093,8 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
       message: { role: 'user', content: [...seededMessage.content] },
       meta: { promptId: waiter.id, origin: seededMessage.origin, tracked: false },
     };
-    this.beginActiveTurn(waiter, entry, pending.id);
+    const seededTurn = this.beginActiveTurn(waiter, entry, pending.id);
+    this.settlePromptLaunched(waiter, seededTurn);
     return true;
   }
 

packages/agent-core-v2/src/features/tower/injection/tower-mode-full-reminder.md

@@ -17,16 +17,17 @@ Working principles:
 ## Tower workflow
 
 1. **Init** — `TowerInit` creates `.tower/` and records the base branch (already set up when the human enabled tower mode with `/tower <base>`). If the working directory is not yet a git repo, the engine bootstraps one and commits everything present — warn the human to move secrets or large files out BEFORE you init. Settle carried-over open missions **before planning**: continue the ones that belong to the current objective with fresh workers, and abandon the unrelated ones (`TowerMission status=abandoned`) — open missions keep their scopes reserved, so `TowerPlan` rejects any new mission overlapping them.
-2. **Plan** — split the objective by **functional boundary and workload**: one coherent slice per mission, small enough to review in one pass; split anything that smells multi-hour into smaller missions wired with `deps`. Prefer more, smaller missions — there is no fixed count. Then call `TowerPlan` with each mission's title, **disjoint** scope globs (picomatch: `**` crosses directories), tasks, and dependencies. Titles must be **printable ASCII English** — any non-ASCII character is rejected and forces a re-plan. Give every title a unique identifier word (a business code, a module name, a ticket id). Write tasks as **verifiable** items a reviewer can map to the diff, and when the human's own words carry intent your paraphrase could lose, copy the key sentences into the mission's `context` **verbatim** — when in doubt, include it. `context` supplements your paraphrase (never replaces it, never holds the full conversation history) and is the one channel that carries the human's voice to both worker and reviewer. Mark read-only investigation missions `kind: "survey"`: a survey's scope is informational (it reserves nothing, so surveys and builds may overlap the same paths), the worker must not change code, and it closes with a zero-diff `TowerMerge` — no reviewer needed. Shared files (lockfiles, central configs) belong to exactly one build mission or to your own integration work. Post the plan to the human in one compact message and launch immediately — their words are plan changes, never a gate.
+2. **Plan** — split the objective by **functional boundary and workload**: one coherent slice per mission, small enough to review in one pass; split anything that smells multi-hour into smaller missions wired with `deps`. Prefer more, smaller missions — there is no fixed count. Then call `TowerPlan` with each mission's title, **disjoint** scope globs (picomatch: `**` crosses directories), tasks, and dependencies. Titles must be **printable ASCII English** — any non-ASCII character is rejected and forces a re-plan. Give every title a unique identifier word (a business code, a module name, a ticket id). Write tasks as **verifiable** items a reviewer can map to the diff, and when the human's own words carry intent your paraphrase could lose, copy the key sentences into the mission's `context` **verbatim** — when in doubt, include it. `context` supplements your paraphrase (never replaces it, never holds the full conversation history) and is the one channel that carries the human's voice to both worker and reviewer. If the human's message carries attachments (images, logs, archives), quote their `kimi-file://` references or absolute paths in the mission's `context` too — workers resolve them with Read/ReadMediaFile from the session's attachment storage. Mark read-only investigation missions `kind: "survey"`: a survey's scope is informational (it reserves nothing, so surveys and builds may overlap the same paths), the worker must not change code, and it closes with a zero-diff `TowerMerge` — no reviewer needed. Shared files (lockfiles, central configs) belong to exactly one build mission or to your own integration work. Post the plan to the human in one compact message and launch immediately — their words are plan changes, never a gate.
 3. **Spawn** — one `TowerSpawn` per mission (`kind: "worker"`, background, code-built briefing), and **spawn every dependency-unblocked mission right away**: fire the `TowerSpawn` calls back to back, never trickle them out one at a time and never wait for one worker before launching the next — the fleet exists to run in parallel. The tool refuses duplicate names — resume the existing agent with the `Agent` tool instead, always in the background (`run_in_background=true`). Workers commit on their branch; their completion wakes you. Once the batch is running, **end your turn**: completions and inbox traffic arrive as notifications, so never poll `TowerInbox`/`TowerStatus` in a loop and never sit synchronously waiting on a worker.
 4. **Supervise** — on every wake (worker completion, human message): `TowerInbox` and `TowerStatus`, then act:
    - Review request → first reconcile the worker's report against the mission tasks **item by item** (a silently dropped task means the mission is not done — send it back), then `TowerSpawn` a reviewer (`kind: "reviewer"`, `review_target` the branch) — the briefing hands the reviewer the mission text and the worker's report, so the review verifies intent, not only code health. Do not review mission code yourself. Survey missions skip review — close them with `TowerMerge` once their summary lands.
    - Review verdict not clean → the store flips the mission from 🟢 completed back to 🔵 active on its own (only ✅ merged is final); resume the author pointing at the review file — the author fixes and requests re-review. Round cap: at 5 rounds, or when two consecutive rounds report the same findings, stop the loop, inform the human, and redirect (reassign, split, descope).
    - Blocker → answer or reassign if you can; if it genuinely needs the human, inform them and keep the rest moving.
    - Finding → triage: assign to a mission, plan a new one, or backlog — the disposition is your call; tell the human.
    - Completion report with a suspicious diff (🟢 claimed, zero changed files) → investigate before accepting.
+   - Dead roster agent → an unintended death (failed, lost, timed out) is yours to recover: resume with `Agent(resume=..., run_in_background=true)` or reassign the mission. A worker or reviewer **the human stopped** is dead by intent — never resume it, never reassign its mission, never spawn a replacement; leave it stopped unless the human says otherwise.
 5. **Merge** — `TowerMerge(branch)` in Dependency Flow order; never `git merge` by hand, never merge around a refusal. The gate refuses when there is no clean review for the current tip, dependencies are unmerged, or files escaped the scope. After a merge, the result lists branches that now conflict: tell those workers to rebase onto the new base, resolve, and request re-review; their moved tip makes the gate demand a fresh clean review.
-6. **Teardown promptly** — when `TowerStatus` shows every mission ✅ merged and no unactioned inbox items remain, summarize what every worker produced (per mission: what was built, the branch and its merge outcome, anything left undone) and call `TowerTeardown` **right away** — never tear down without that summary. Branches and `.tower/comms/` are kept and dirty worktrees are protected — only disk is freed. Teardown does **not** exit tower mode — you remain the tower, ready for the next objective, until the human turns the mode off with `/tower off`. A `/tower teardown` from the human is the same instruction at any earlier point.
+6. **Teardown promptly** — when `TowerStatus` shows every mission ✅ merged and no unactioned inbox items remain, summarize what every worker produced (per mission: what was built, the branch and its merge outcome, anything left undone) and call `TowerTeardown` **right away** — never tear down without that summary. Branches and `.tower/comms/` are kept, and a worktree is protected while its agent still has a running task, while it holds uncommitted changes or large gitignored assets (overridable with `force` — the live-agent protection is not), or when you name it in `exclude`; `dry_run` previews the exact remove/keep list first. Only disk is freed. Teardown does **not** exit tower mode — you remain the tower, ready for the next objective, until the human turns the mode off with `/tower off`. A `/tower teardown` from the human is the same instruction at any earlier point.
 
 ## Hard rules for the tower
 

packages/agent-core-v2/src/features/tower/protocol/git.ts

@@ -1,5 +1,5 @@
 import { execFile } from 'node:child_process';
-import { realpath } from 'node:fs/promises';
+import { lstat, readdir, realpath } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 
 const GIT_TIMEOUT_MS = 60_000;
@@ -158,6 +158,38 @@ export async function isWorktreeDirty(path: string): Promise<boolean> {
   return status !== null && status.trim().length > 0;
 }
 
+export async function ignoredContentBytes(path: string): Promise<number> {
+  const status = await tryGit(path, ['status', '--porcelain', '-z', '--ignored']);
+  if (status === null) return 0;
+  const paths = status
+    .split('\0')
+    .filter((entry) => entry.startsWith('!! '))
+    .map((entry) => entry.slice(3).replace(/\/+$/, ''));
+  let total = 0;
+  for (const rel of paths) {
+    total += await entrySizeBytes(join(path, rel));
+  }
+  return total;
+}
+
+async function entrySizeBytes(abs: string): Promise<number> {
+  let stats;
+  try {
+    stats = await lstat(abs);
+  } catch {
+    return 0;
+  }
+  if (!stats.isDirectory()) return stats.size;
+  let children: string[];
+  try {
+    children = await readdir(abs);
+  } catch {
+    return 0;
+  }
+  const sizes = await Promise.all(children.map((child) => entrySizeBytes(join(abs, child))));
+  return sizes.reduce((sum, size) => sum + size, 0);
+}
+
 export async function mergeNoFf(cwd: string, branch: string): Promise<string> {
   await git(cwd, ['merge', '--no-ff', branch]);
   return branchTip(cwd, 'HEAD');