@animalabs/connectome-host 0.3.10 → 0.5.0

package/src/web/protocol.ts

@@ -391,6 +391,41 @@ export interface McplListMessage {
   }>;
 }
 
+/**
+ * Runtime context-settings snapshot.
+ *
+ * BROADCAST to every welcomed client on change — unlike `mcpl-list`, these are
+ * live process state, not a config file, so two operators must not see
+ * divergent values.
+ */
+export interface SettingsStateMessage {
+  type: 'settings-state';
+  agent: string;
+  /** Live values. `transition` is 'converging' while a paced descent runs. */
+  settings: {
+    contextBudgetTokens: number;
+    tailTokens?: number;
+    transitionPaceTokens?: number;
+    sameRoundThinkTextPolicy?: string;
+    sameRoundThinkTextPolicySource?: string;
+    transition: 'stable' | 'converging' | 'blocked';
+    /** Why a descent is stuck: pace below floor, or protected context too big. */
+    transitionReason?: string;
+  };
+  /** Keys currently overridden away from the recipe (i.e. persisted). */
+  overrides: string[];
+  /** Which keys this build can apply live. Everything else needs a restart —
+   *  the UI must show that split rather than implying all knobs are hot. */
+  hotKeys: string[];
+  /** False when the strategy is not hot-configurable at all (e.g. passthrough):
+   *  the panel should go read-only rather than offer controls that will throw. */
+  hotConfigurable: boolean;
+  /** True when this build's context-manager exposes dry-run preview. Older
+   *  context-manager versions resolve without it, and the panel must say
+   *  "preview unavailable" rather than silently showing nothing. */
+  previewAvailable: boolean;
+}
+
 /** A page of older history — response to `request-history`, routed only to
  *  the requesting client and correlated by `corrId`. */
 export interface HistoryPageMessage {
@@ -474,6 +509,7 @@ export type WebUiServerMessage =
   | QuitConfirmRequiredMessage
   | LessonsListMessage
   | McplListMessage
+  | SettingsStateMessage
   | WorkspaceMountsMessage
   | WorkspaceTreeMessage
   | WorkspaceFileMessage
@@ -633,6 +669,58 @@ export interface McplSetEnvMessage {
   env: Record<string, string>;
 }
 
+/** Pull the current runtime context settings for an agent, plus which knobs are
+ *  live-appliable vs restart-only. Response is a `settings-state` envelope. */
+export interface RequestSettingsMessage {
+  type: 'request-settings';
+  /** Agent name; defaults to the recipe's primary agent. */
+  agent?: string;
+}
+
+/**
+ * Apply runtime context settings live.
+ *
+ * Semantics that the UI must not misrepresent:
+ *  - RAISING contextBudgetTokens applies immediately.
+ *  - LOWERING it starts a PACED convergence (`transition: 'converging'`)
+ *    rather than folding everything at once; it can be cancelled.
+ *  - Only these keys are hot. Chunk size, head window, merge threshold and
+ *    friends are recipe-and-restart only.
+ *
+ * `persist: false` makes the change ephemeral — live now, gone on restart —
+ * which is the mode for operator experiments. Default persists.
+ *
+ * `notify: true` pushes a notice into the agent's context. OFF by default and
+ * deliberately so: the notice is new text in the very context being tuned, so
+ * it invalidates the KV prefix and can itself trip a refusal classifier. The
+ * agent can always PULL current settings via its own `agent_settings` tool.
+ */
+export interface SettingsUpdateMessage {
+  type: 'settings-update';
+  agent?: string;
+  contextBudgetTokens?: number;
+  tailTokens?: number;
+  transitionPaceTokens?: number;
+  persist?: boolean;
+  notify?: boolean;
+}
+
+/** Revert named settings to their recipe values (all four when omitted). */
+export interface SettingsResetMessage {
+  type: 'settings-reset';
+  agent?: string;
+  keys?: string[];
+  persist?: boolean;
+  notify?: boolean;
+}
+
+/** Abandon an in-flight paced descent, holding the current frontier. */
+export interface SettingsCancelTransitionMessage {
+  type: 'settings-cancel-transition';
+  agent?: string;
+  persist?: boolean;
+}
+
 /** Pull the list of workspace mounts. Response is `workspace-mounts`.
  *  Optional `scope` selects a fleet child instead of the parent. */
 export interface RequestWorkspaceMountsMessage {
@@ -706,6 +794,10 @@ export type WebUiClientMessage =
   | McplAddMessage
   | McplRemoveMessage
   | McplSetEnvMessage
+  | RequestSettingsMessage
+  | SettingsUpdateMessage
+  | SettingsResetMessage
+  | SettingsCancelTransitionMessage
   | RequestWorkspaceMountsMessage
   | RequestWorkspaceTreeMessage
   | RequestWorkspaceFileMessage
@@ -768,6 +860,30 @@ export function isClientMessage(value: unknown): value is WebUiClientMessage {
       return isValidMcplId(v.id);
     case 'mcpl-set-env':
       return isValidMcplId(v.id) && isStringMap(v.env);
+    case 'request-settings':
+      return isOptionalNonEmptyString(v.agent);
+    case 'settings-update': {
+      if (!isOptionalNonEmptyString(v.agent)) return false;
+      if (!isOptionalBool(v.persist) || !isOptionalBool(v.notify)) return false;
+      // Positive-integer-or-absent for each knob. The semantic gate (budget must
+      // exceed max response tokens; tail/pace need a hot-configurable strategy)
+      // lives in Agent.validateRuntimeSettingsPatch — this only guarantees the
+      // shape so that gate gets numbers instead of strings.
+      for (const k of ['contextBudgetTokens', 'tailTokens', 'transitionPaceTokens']) {
+        if (!isOptionalPositiveInt(v[k])) return false;
+      }
+      // Require at least one actual knob: an empty patch would throw downstream.
+      return v.contextBudgetTokens !== undefined
+        || v.tailTokens !== undefined
+        || v.transitionPaceTokens !== undefined;
+    }
+    case 'settings-reset':
+      return isOptionalNonEmptyString(v.agent)
+        && isOptionalBool(v.persist)
+        && isOptionalBool(v.notify)
+        && isOptionalStringArray(v.keys);
+    case 'settings-cancel-transition':
+      return isOptionalNonEmptyString(v.agent) && isOptionalBool(v.persist);
     case 'request-workspace-mounts':
       return v.scope === undefined || typeof v.scope === 'string';
     case 'request-workspace-tree':
@@ -822,3 +938,17 @@ function isOptionalStringArray(v: unknown): v is string[] | undefined {
   if (!Array.isArray(v)) return false;
   return v.every((x) => typeof x === 'string');
 }
+
+function isOptionalNonEmptyString(v: unknown): v is string | undefined {
+  return v === undefined || isNonEmptyString(v);
+}
+
+function isOptionalBool(v: unknown): v is boolean | undefined {
+  return v === undefined || typeof v === 'boolean';
+}
+
+/** Token counts: safe positive integers only. Rejects strings, NaN, Infinity,
+ *  fractions and negatives before they reach the settings validator. */
+function isOptionalPositiveInt(v: unknown): v is number | undefined {
+  return v === undefined || (typeof v === 'number' && Number.isSafeInteger(v) && v > 0);
+}

package/test/commands-checkpoint-restore.test.ts

@@ -0,0 +1,118 @@
+import { describe, test, expect } from 'bun:test';
+import { handleCommand, createBranchState } from '../src/commands.js';
+
+// Regression tests for /checkpoint + /restore POSITION semantics. The
+// original bug: checkpoints stored only a branch name, so /restore switched
+// to the branch HEAD — including everything after the checkpoint — rolling
+// back nothing, silently. These tests run over a stub ContextManager that
+// mimics Chronicle's contract: branchAt resolves ids against the CURRENT
+// branch's view of the log and throws for unreachable ids.
+
+interface StubMessage { id: string; participant: string; content: unknown[] }
+
+function makeStubWorld() {
+  const messagesByBranch = new Map<string, StubMessage[]>([['main', []]]);
+  let currentName = 'main';
+  let msgCounter = 0;
+
+  const cm = {
+    currentBranch: () => ({ id: currentName, name: currentName, head: messagesByBranch.get(currentName)!.length }),
+    listBranches: () => [...messagesByBranch.keys()].map(name => ({ id: name, name, head: messagesByBranch.get(name)!.length })),
+    queryMessages: (_q: unknown) => ({ messages: messagesByBranch.get(currentName)! }),
+    branchAt: (messageId: string, newName: string): string => {
+      const msgs = messagesByBranch.get(currentName)!;
+      const idx = msgs.findIndex(m => m.id === messageId);
+      if (idx === -1) throw new Error(`Message not found: ${messageId}`);
+      messagesByBranch.set(newName, msgs.slice(0, idx + 1));
+      return newName;
+    },
+    switchBranch: async (name: string): Promise<void> => {
+      if (!messagesByBranch.has(name)) throw new Error(`No such branch: ${name}`);
+      currentName = name;
+    },
+  };
+
+  const addMessage = (participant = 'user'): StubMessage => {
+    const msg: StubMessage = { id: `m${++msgCounter}`, participant, content: [] };
+    messagesByBranch.get(currentName)!.push(msg);
+    return msg;
+  };
+
+  const app = {
+    framework: {
+      getAgent: () => undefined,
+      getAllAgents: () => [{ getContextManager: () => cm }],
+      getAllModules: () => [],
+    },
+    branchState: createBranchState(),
+    userMessageCount: 0,
+  } as any;
+
+  return { cm, app, addMessage, branchCount: () => messagesByBranch.size, currentName: () => currentName };
+}
+
+describe('/checkpoint + /restore position semantics', () => {
+  test('checkpoint records the last message id, not just the branch', () => {
+    const { app, addMessage } = makeStubWorld();
+    addMessage();
+    const last = addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+    const point = app.branchState.checkpoints.get('cp');
+    expect(point.branchName).toBe('main');
+    expect(point.messageId).toBe(last.id);
+  });
+
+  test('restore rolls back to the checkpoint position, not the branch head', async () => {
+    const { app, addMessage, currentName } = makeStubWorld();
+    addMessage();
+    const cpMsg = addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+    addMessage();
+    addMessage('agent'); // work after the checkpoint that must be rolled back
+
+    const result = handleCommand('/restore cp', app);
+    const outcome = await result.asyncWork!;
+    expect(outcome.branchChanged).toBe(true);
+    expect(currentName().startsWith('restore-cp-')).toBe(true);
+
+    const { messages } = (app.framework.getAllAgents()[0].getContextManager() as any).queryMessages({});
+    expect(messages[messages.length - 1].id).toBe(cpMsg.id);
+  });
+
+  test('restoring while already at the checkpoint is a no-op — no branch minted', async () => {
+    const { app, addMessage, branchCount } = makeStubWorld();
+    addMessage();
+    addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+    addMessage();
+
+    await handleCommand('/restore cp', app).asyncWork!;
+    const branchesAfterFirst = branchCount();
+
+    // Second restore at the same position: the guard must hold even though
+    // we're now on restore-cp-… rather than the original branch (the guard
+    // used to compare branch names and died after the first restore,
+    // minting a sibling branch per repeat).
+    const second = handleCommand('/restore cp', app);
+    expect(second.asyncWork).toBeUndefined();
+    expect(second.lines[0]!.text).toContain('Already at checkpoint');
+    expect(branchCount()).toBe(branchesAfterFirst);
+  });
+
+  test('unreachable checkpoint position degrades to the branch head with a note', async () => {
+    const { app, cm, addMessage, currentName } = makeStubWorld();
+    const early = addMessage();
+    addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+
+    // Simulate /undo: branch truncated BEFORE the checkpoint message, so the
+    // checkpoint id is unreachable from the current branch's view.
+    const undoBranch = cm.branchAt(early.id, 'undo-1');
+    await cm.switchBranch(undoBranch);
+
+    const result = handleCommand('/restore cp', app);
+    const outcome = await result.asyncWork!;
+    expect(currentName()).toBe('main');
+    expect(outcome.lines.some(l => l.text.includes('unreachable'))).toBe(true);
+  });
+});

package/test/settings-protocol.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Wire validation for the context-settings messages.
+ *
+ * These messages mutate a LIVE agent's context budget, so malformed payloads
+ * must be rejected at the protocol edge rather than reaching
+ * Agent.validateRuntimeSettingsPatch as strings/NaN/fractions.
+ */
+
+import { describe, it, expect } from 'bun:test';
+import { isClientMessage } from '../src/web/protocol.js';
+
+describe('settings messages — wire validation', () => {
+  it('accepts a minimal budget update', () => {
+    expect(isClientMessage({ type: 'settings-update', contextBudgetTokens: 120_000 })).toBe(true);
+  });
+
+  it('accepts tail-only and pace-only updates', () => {
+    expect(isClientMessage({ type: 'settings-update', tailTokens: 30_000 })).toBe(true);
+    expect(isClientMessage({ type: 'settings-update', transitionPaceTokens: 8_000 })).toBe(true);
+  });
+
+  it('accepts persist/notify flags and an agent name', () => {
+    expect(isClientMessage({
+      type: 'settings-update',
+      contextBudgetTokens: 100_000,
+      persist: false,
+      notify: true,
+      agent: 'mythos',
+    })).toBe(true);
+  });
+
+  it('rejects an empty patch — it would throw downstream', () => {
+    expect(isClientMessage({ type: 'settings-update' })).toBe(false);
+    expect(isClientMessage({ type: 'settings-update', persist: true })).toBe(false);
+  });
+
+  it('rejects non-integer / non-positive / stringly token counts', () => {
+    for (const bad of ['100000', 100.5, -1, 0, NaN, Infinity, null, {}]) {
+      expect(isClientMessage({ type: 'settings-update', contextBudgetTokens: bad }))
+        .toBe(false);
+    }
+  });
+
+  it('rejects non-boolean flags and empty agent names', () => {
+    expect(isClientMessage({ type: 'settings-update', contextBudgetTokens: 1, persist: 'yes' })).toBe(false);
+    expect(isClientMessage({ type: 'settings-update', contextBudgetTokens: 1, notify: 1 })).toBe(false);
+    expect(isClientMessage({ type: 'settings-update', contextBudgetTokens: 1, agent: '' })).toBe(false);
+  });
+
+  it('validates reset and cancel shapes', () => {
+    expect(isClientMessage({ type: 'settings-reset' })).toBe(true);
+    expect(isClientMessage({ type: 'settings-reset', keys: ['contextBudgetTokens'] })).toBe(true);
+    expect(isClientMessage({ type: 'settings-reset', keys: 'contextBudgetTokens' })).toBe(false);
+    expect(isClientMessage({ type: 'settings-cancel-transition' })).toBe(true);
+    expect(isClientMessage({ type: 'settings-cancel-transition', persist: false })).toBe(true);
+    expect(isClientMessage({ type: 'settings-cancel-transition', agent: 42 })).toBe(false);
+  });
+
+  it('validates request-settings', () => {
+    expect(isClientMessage({ type: 'request-settings' })).toBe(true);
+    expect(isClientMessage({ type: 'request-settings', agent: 'mythos' })).toBe(true);
+    expect(isClientMessage({ type: 'request-settings', agent: 7 })).toBe(false);
+  });
+});

package/test/subscription-gc-module.test.ts

@@ -94,7 +94,7 @@ describe('SubscriptionGcModule', () => {
     await m.stop();
   });
 
-  test('"off" override pins a channel; counters persist across restart', async () => {
+  test('"off" override disables auto-close; counters persist across restart', async () => {
     const m = new SubscriptionGcModule({ defaultLimitChars: 5 });
     const { ctx, toolCalls, getState } = mockCtx();
     await m.start(ctx);
@@ -136,3 +136,158 @@ describe('SubscriptionGcModule', () => {
     await m2.stop();
   });
 });
+
+describe('agent_settings extension (channel_idle_limits)', () => {
+  test('declares no standalone tools but keeps the old names routable', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    expect(mod.getTools()).toEqual([]);
+    // Undeclared ≠ dead: agent muscle memory routes via the old name.
+    const result = await mod.handleToolCall({
+      id: 't1',
+      name: 'set_channel_idle_limit',
+      input: { channelId: 'C1', limit: 'off' },
+    });
+    expect(result.success).toBe(true);
+    const ext = mod.getAgentSettingsExtension();
+    expect(ext.get('agent').channel_idle_limits).toEqual({ C1: 'off' });
+  });
+
+  test('get reports read-only status: default, counters, pins', async () => {
+    const mod = new SubscriptionGcModule({ defaultLimitChars: 10 });
+    const { ctx } = mockCtx();
+    await mod.start(ctx);
+    await mod.onProcess(ambient('c1', 'abc'), PS);
+    await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'C9', pinned: true },
+    });
+    const ext = mod.getAgentSettingsExtension();
+    expect(ext.get('agent')).toEqual({
+      channel_idle_limits: {},
+      channel_idle_default: 10,
+      channel_idle_counters: { 'discord:g1:c1': 3 },
+      channel_idle_pinned: ['C9'],
+    });
+    await mod.stop();
+  });
+
+  test('update merges per entry: number, off, default/null', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { A: 5000, B: 'off', C: '12000' } });
+    expect(ext.get('agent').channel_idle_limits).toEqual({ A: 5000, B: 'off', C: 12000 });
+    // merge: only mentioned entries change; default/null clear
+    ext.update('agent', { channel_idle_limits: { A: 'default', B: null } });
+    expect(ext.get('agent').channel_idle_limits).toEqual({ C: 12000 });
+  });
+
+  test('update rejects junk values with a clear error', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const ext = mod.getAgentSettingsExtension();
+    expect(() => ext.update('agent', { channel_idle_limits: { A: -3 } })).toThrow(/positive/);
+    expect(() => ext.update('agent', { channel_idle_limits: 'off' })).toThrow(/object/);
+    expect(() => ext.update('agent', { channel_idle_limits: ['A'] })).toThrow(/object/);
+  });
+
+  test('a partially-invalid patch applies nothing', async () => {
+    const mod = new SubscriptionGcModule();
+    const { ctx, getState } = mockCtx();
+    await mod.start(ctx);
+    const ext = mod.getAgentSettingsExtension();
+    // A is valid, B is junk: the whole patch must be rejected — per-entry
+    // application would leave A live (limitFor reads the map directly) and
+    // persisted by the next flush, after the agent was told the update failed.
+    expect(() => ext.update('agent', { channel_idle_limits: { A: 5000, B: -3 } })).toThrow(
+      /positive/,
+    );
+    expect(ext.get('agent').channel_idle_limits).toEqual({});
+    const persisted = getState() as { overrides: Record<string, unknown> } | null;
+    expect(persisted?.overrides ?? {}).toEqual({});
+  });
+
+  test('reset clears all overrides', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { A: 5000, B: 'off' } });
+    expect(ext.reset('agent').channel_idle_limits).toEqual({});
+    // keyed reset also clears
+    ext.update('agent', { channel_idle_limits: { A: 5000 } });
+    expect(ext.reset('agent', ['channel_idle_limits']).channel_idle_limits).toEqual({});
+    // reset for other keys leaves ours alone
+    ext.update('agent', { channel_idle_limits: { A: 5000 } });
+    expect(ext.reset('agent', ['reasoning_enabled']).channel_idle_limits).toEqual({ A: 5000 });
+  });
+});
+
+describe('system pins (pin_channel_idle_limit)', () => {
+  test('reset-all clears overrides but not pins; pinned channel stays open', async () => {
+    const mod = new SubscriptionGcModule({ defaultLimitChars: 5 });
+    const { ctx, toolCalls } = mockCtx();
+    await mod.start(ctx);
+    // ChannelMode's debounced-mode step 3.
+    await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', pinned: true },
+    });
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { A: 5000 } });
+    // Blanket `agent_settings reset` (e.g. to restore default reasoning).
+    const after = ext.reset('agent');
+    expect(after.channel_idle_limits).toEqual({});
+    expect(after.channel_idle_pinned).toEqual(['discord:g1:c1']);
+    // The pinned channel must NOT auto-close after the reset.
+    await mod.onProcess(ambient('c1', 'waytoolongambienttraffic'), PS);
+    expect(toolCalls.length).toBe(0);
+    await mod.stop();
+  });
+
+  test('pin/unpin round-trip preserves an agent override', async () => {
+    const mod = new SubscriptionGcModule({ defaultLimitChars: 5 });
+    const { ctx, toolCalls } = mockCtx();
+    await mod.start(ctx);
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { 'discord:g1:c1': 9 } });
+    await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', pinned: true },
+    });
+    await mod.onProcess(ambient('c1', 'longerthannine'), PS); // pinned → no close
+    expect(toolCalls.length).toBe(0);
+    await mod.handleToolCall({
+      id: 't2',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', pinned: false },
+    });
+    expect(ext.get('agent').channel_idle_limits).toEqual({ 'discord:g1:c1': 9 });
+    // Override (9) is live again: counter is at 14 from the pinned message,
+    // so the next ambient char crosses it.
+    await mod.onProcess(ambient('c1', 'x'), PS);
+    expect(toolCalls.length).toBe(1);
+    expect(toolCalls[0].name).toBe('channel_close');
+    await mod.stop();
+  });
+
+  test('pin tool validates its input', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const bad1 = await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { pinned: true },
+    });
+    expect(bad1.success).toBe(false);
+    const bad2 = await mod.handleToolCall({
+      id: 't2',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'C1', pinned: 'yes' },
+    });
+    expect(bad2.success).toBe(false);
+  });
+});

package/test/tui-quit-confirm.test.ts

@@ -0,0 +1,42 @@
+import { describe, test, expect } from 'bun:test';
+import { resolveQuitConfirm } from '../src/tui.js';
+
+// Pins the quit-prompt semantics. The pre-fix behavior — "anything that
+// isn't n/no/cancel → kill every fleet child and exit" — meant a user who
+// forgot the armed prompt and typed a normal chat message killed the fleet.
+// The default for arbitrary input MUST stay 'cancel-keep-input'; a refactor
+// that flips it back should fail here, loudly.
+describe('resolveQuitConfirm', () => {
+  test('only explicit consent kills', () => {
+    expect(resolveQuitConfirm('y')).toBe('kill');
+    expect(resolveQuitConfirm('yes')).toBe('kill');
+    expect(resolveQuitConfirm('YES')).toBe('kill');
+  });
+
+  test('re-typing the quit command confirms, not cancels', () => {
+    expect(resolveQuitConfirm('/quit')).toBe('kill');
+    expect(resolveQuitConfirm('/q')).toBe('kill');
+    expect(resolveQuitConfirm('quit')).toBe('kill');
+    expect(resolveQuitConfirm('q')).toBe('kill');
+  });
+
+  test('detach', () => {
+    expect(resolveQuitConfirm('d')).toBe('detach');
+    expect(resolveQuitConfirm('detach')).toBe('detach');
+  });
+
+  test('explicit and empty cancels (Enter takes the advertised [y/N/d] default)', () => {
+    expect(resolveQuitConfirm('')).toBe('cancel');
+    expect(resolveQuitConfirm('  ')).toBe('cancel');
+    expect(resolveQuitConfirm('n')).toBe('cancel');
+    expect(resolveQuitConfirm('no')).toBe('cancel');
+    expect(resolveQuitConfirm('cancel')).toBe('cancel');
+  });
+
+  test('a real message cancels AND must be restored to the input', () => {
+    expect(resolveQuitConfirm('actually, first summarize what miner found')).toBe('cancel-keep-input');
+    expect(resolveQuitConfirm('[paste #1: "…" 40000ch, 900L]')).toBe('cancel-keep-input');
+    expect(resolveQuitConfirm('/status')).toBe('cancel-keep-input');
+    expect(resolveQuitConfirm('yeah')).toBe('cancel-keep-input');
+  });
+});

package/test/tui-short-agent-name.test.ts

@@ -0,0 +1,36 @@
+import { describe, test, expect } from 'bun:test';
+import { shortAgentName } from '../src/tui.js';
+
+// Guards full↔short agent-name resolution against the naming schemes the
+// SubagentModule actually produces (see its spawn/fork paths). A helper that
+// misses one scheme silently breaks fleet-tree attribution for that agent
+// type — forks slipped through exactly this way once.
+describe('shortAgentName', () => {
+  test('spawn names: spawn-{name}-{ts}', () => {
+    expect(shortAgentName('spawn-web-1753221234567')).toBe('web');
+    expect(shortAgentName('spawn-zulip-reader-1753221234567')).toBe('zulip-reader');
+  });
+
+  test('fork names: {name}-d{depth}-{ts}, no fork- prefix', () => {
+    expect(shortAgentName('web-d1-1753221234567')).toBe('web');
+    expect(shortAgentName('zulip-reader-d3-1753221234567')).toBe('zulip-reader');
+  });
+
+  test('fork retry names: {name}-d{depth}-retry{n}-{ts}', () => {
+    expect(shortAgentName('web-d2-retry1-1753221234567')).toBe('web');
+  });
+
+  test('bare trailing -retryN (historical defensive strip)', () => {
+    expect(shortAgentName('web-retry2')).toBe('web');
+  });
+
+  test('names that are substrings of each other stay distinct', () => {
+    expect(shortAgentName('websearch-d1-1753221234567')).toBe('websearch');
+    expect(shortAgentName('spawn-websearch-1753221234567')).toBe('websearch');
+  });
+
+  test('plain names pass through', () => {
+    expect(shortAgentName('miner')).toBe('miner');
+    expect(shortAgentName('web')).toBe('web');
+  });
+});