mixdog 0.9.38 → 0.9.39

package/scripts/session-orphan-sweep-test.mjs

@@ -0,0 +1,83 @@
+/**
+ * session-orphan-sweep-test.mjs — proves the periodic sweep reclaims mature
+ * closed tombstones that exist ON DISK but are ABSENT from the summary index.
+ *
+ * Regression guard for the pre-fix bug where sweepStaleSessions iterated only
+ * listStoredSessionSummaries() rows, so on-disk session files missing from a
+ * stale index were never visited and their tombstones accumulated forever.
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+test('mature closed on-disk orphan absent from summary index gets tombstone-swept', async () => {
+    const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-orphan-sweep-'));
+    process.env.MIXDOG_DATA_DIR = dataDir;
+    try {
+        const store = await import('../src/runtime/agent/orchestrator/session/store.mjs');
+        const { sweepStaleSessions, _sessionSummary, _writeSummaryIndex } = store;
+
+        const sessionsDir = join(dataDir, 'sessions');
+        mkdirSync(sessionsDir, { recursive: true });
+
+        const now = Date.now();
+        const TWO_HOURS = 2 * 60 * 60 * 1000;
+        const ONE_HOUR = 60 * 60 * 1000;
+
+        // (1) An INDEXED, fresh, open agent session — present in the summary
+        //     index so the index is non-empty (blocking any rebuild) and must
+        //     survive the sweep.
+        const indexed = {
+            id: 'sess_indexed_keep',
+            closed: false,
+            status: 'idle',
+            owner: 'agent:test',
+            updatedAt: now,
+            createdAt: now,
+            lastHeartbeatAt: now,
+            messages: [],
+        };
+        writeFileSync(join(sessionsDir, `${indexed.id}.json`), JSON.stringify(indexed));
+
+        // (2) An ORPHAN closed+mature tombstone — on disk, NOT in the index,
+        //     closed >1h ago. Only reachable if the sweep reconciles the index
+        //     candidate set with a direct directory scan.
+        const orphan = {
+            id: 'sess_orphan_tombstone',
+            closed: true,
+            status: 'closed',
+            owner: 'agent:test',
+            updatedAt: now - TWO_HOURS,
+            createdAt: now - TWO_HOURS,
+            messages: [],
+        };
+        writeFileSync(join(sessionsDir, `${orphan.id}.json`), JSON.stringify(orphan));
+
+        // Index contains ONLY the indexed session — the orphan is absent.
+        const rows = _writeSummaryIndex([_sessionSummary(indexed)]);
+        assert.equal(rows.length, 1, 'index seeded with exactly one row');
+        assert.ok(!rows.some((r) => r.id === orphan.id), 'orphan is absent from the summary index');
+
+        // Tombstone-only pass (no idle sweep) with a 1h maturity threshold.
+        const result = sweepStaleSessions({ sweepIdle: false, tombstoneMaxAgeMs: ONE_HOUR });
+
+        assert.equal(result.tombstonesCleaned, 1, 'the orphan tombstone was reclaimed');
+        assert.ok(
+            result.tombstoneDetails.some((d) => d.id === orphan.id),
+            'sweep reports the orphan id among tombstone deletions',
+        );
+        assert.ok(
+            !existsSync(join(sessionsDir, `${orphan.id}.json`)),
+            'orphan session file was unlinked from disk',
+        );
+        assert.ok(
+            existsSync(join(sessionsDir, `${indexed.id}.json`)),
+            'fresh open indexed session was preserved',
+        );
+    } finally {
+        try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
+        delete process.env.MIXDOG_DATA_DIR;
+    }
+});

package/scripts/steering-drain-buckets-test.mjs

@@ -1,6 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
+import { createRunTurn } from '../src/tui/engine/turn.mjs';
 
 // Minimal bag: drainPendingSteering only touches pending, the queue helpers,
 // and commitSteeringQueueEntries (which no-ops on disk when runtime.id is not
@@ -118,3 +119,181 @@ test('post-turn drain does not send queued slash command to model', async () =>
   assert.equal(bag.pending.length, 1, 'slash command remains for command dispatcher');
   assert.equal(bag.pending[0].content, '/clear');
 });
+
+// Minimal store bag for createRunTurn: only the surface the streaming/steering
+// finalize path touches. runtime.ask is a caller-supplied mock that drives the
+// text-delta / steer-message callbacks.
+function makeTurnBag(ask) {
+  let seq = 0;
+  const state = {
+    items: [],
+    stats: { turns: 0, inputTokens: 0, outputTokens: 0 },
+    busy: false,
+    spinner: null,
+    thinking: null,
+  };
+  const itemIndexById = new Map();
+  const findIndexById = (id) => state.items.findIndex((it) => it.id === id);
+  const bag = {
+    runtime: { id: null, toolMode: 'auto', ask, abort: () => {} },
+    nextId: () => `id_${++seq}`,
+    tuiDebug: () => {},
+    LEAD_TURN_TIMEOUT_MS: 300000,
+    flags: { leadTurnEpoch: 0 },
+    pending: [],
+    itemIndexById,
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    pushItem: (spec) => {
+      state.items = [...state.items, spec];
+      if (spec?.id != null) itemIndexById.set(spec.id, state.items.length - 1);
+    },
+    patchItem: (id, patch) => {
+      const idx = findIndexById(id);
+      if (idx < 0) return;
+      const items = state.items.slice();
+      items[idx] = { ...items[idx], ...patch };
+      state.items = items;
+    },
+    pushNotice: () => {},
+    pushUserOrSyntheticItem: (text) => {
+      state.items = [...state.items, { kind: 'user', id: `u_${++seq}`, text }];
+    },
+    markToolCallActive: () => {},
+    markToolCallDone: () => {},
+    clearActiveToolSummary: () => {},
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    requestToolApproval: async () => ({ approved: false }),
+    patchToolCardResult: () => {},
+    flushToolResults: () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    drain: async () => {},
+    drainPendingSteering: () => [],
+  };
+  return { bag, getState: () => state };
+}
+
+test('onSteerMessage commits a streamed no-newline assistant tail into items', async () => {
+  // A terminal no-tool response streams a single line WITHOUT a trailing '\n',
+  // so no assistant row/currentAssistantId exists yet. A steering injection
+  // races finalization and must seal the pending tail instead of dropping it.
+  const TAIL = 'partial answer with no trailing newline';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  const runTurn = createRunTurn(bag);
+
+  await runTurn('do a thing');
+
+  const assistant = getState().items.find((it) => it.kind === 'assistant');
+  assert.ok(assistant, 'streamed no-newline tail must be committed as an assistant item');
+  assert.equal(assistant.text, TAIL);
+  assert.equal(assistant.streaming, false);
+});
+
+test('finalization does not duplicate a steer-committed tail when result.content repeats it', async () => {
+  // Same steer race, but the provider's final content equals the already-
+  // committed tail. Finalization must NOT re-emit it as a second item.
+  const TAIL = 'partial answer with no trailing newline';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: TAIL }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  const runTurn = createRunTurn(bag);
+
+  await runTurn('do a thing');
+
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 1, 'the committed tail must not be duplicated at finalize');
+  assert.equal(assistants[0].text, TAIL);
+  assert.equal(assistants[0].streaming, false);
+});
+
+test('finalization appends only the uncommitted remainder past a steer-committed tail', async () => {
+  // Provider content extends past the committed tail: only the new remainder
+  // becomes a fresh item, ordered after the committed segment (+ steering row).
+  const TAIL = 'partial answer with no trailing newline';
+  const REMAINDER = '\nmore text arriving after the steer';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: TAIL + REMAINDER }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  const runTurn = createRunTurn(bag);
+
+  await runTurn('do a thing');
+
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 2, 'committed tail + remainder are two distinct items');
+  assert.equal(assistants[0].text, TAIL, 'committed tail stays first, unchanged');
+  assert.equal(assistants[1].text, REMAINDER, 'only the uncommitted remainder is appended');
+  assert.equal(assistants[1].streaming, false);
+  const steerIdx = getState().items.findIndex((it) => it.kind === 'user' && it.text === 'steer now');
+  const remainderIdx = getState().items.findIndex((it) => it.kind === 'assistant' && it.text === REMAINDER);
+  assert.ok(steerIdx >= 0 && remainderIdx > steerIdx, 'remainder appends after the injected steering row');
+});
+
+// Two committed segments this turn: a prior preamble P, then a no-newline TAIL
+// sealed by the steer race. The provider's final content may OMIT P — the
+// per-segment strip must still peel BOTH out (a single concatenated 'P+TAIL'
+// prefix would fail to match and duplicate TAIL after the steering row).
+const P = 'preamble sealed before the tail';
+const TAIL2 = 'terminal tail with no trailing newline';
+function makeTwoSegmentAsk(finalContent) {
+  return async (_userText, opts) => {
+    opts.onTextDelta(P);
+    opts.onSteerMessage('steer one'); // seals P as its own item
+    opts.onTextDelta(TAIL2);
+    opts.onSteerMessage('steer two'); // seals TAIL2 as its own item
+    return { result: { content: finalContent }, session: { messages: [] } };
+  };
+}
+
+test('per-segment strip: final content = TAIL only (P omitted) → no new item', async () => {
+  const { bag, getState } = makeTurnBag(makeTwoSegmentAsk(TAIL2));
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.deepEqual(assistants.map((it) => it.text), [P, TAIL2], 'only the two committed segments exist');
+});
+
+test('per-segment strip: final content = P + newline + TAIL → no new item', async () => {
+  const { bag, getState } = makeTurnBag(makeTwoSegmentAsk(`${P}\n${TAIL2}`));
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.deepEqual(assistants.map((it) => it.text), [P, TAIL2], 'both segments stripped; nothing re-emitted');
+});
+
+test('per-segment strip: final content extends past both committed segments → only remainder', async () => {
+  const { bag, getState } = makeTurnBag(makeTwoSegmentAsk(`${P}\n${TAIL2}\nmore`));
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 3, 'committed P + TAIL + the new remainder');
+  assert.equal(assistants[2].text, '\nmore', 'only the uncommitted remainder is appended');
+  assert.equal(assistants[2].streaming, false);
+});
+
+test('per-segment strip: segment sealed WITH a leading newline still peels', async () => {
+  // The committed segment carries its own leading '\n' ('\nTAIL'); the provider
+  // returns the trimmed 'TAIL'. Trimming the segment before the compare lets it
+  // peel so it is not duplicated after the steering row.
+  const LEAD_TAIL = '\nterminal tail sealed with a leading newline';
+  const ask = async (_userText, opts) => {
+    opts.onTextDelta(LEAD_TAIL);
+    opts.onSteerMessage('steer now');
+    return { result: { content: LEAD_TAIL.replace(/^\s+/, '') }, session: { messages: [] } };
+  };
+  const { bag, getState } = makeTurnBag(ask);
+  await createRunTurn(bag)('do a thing');
+  const assistants = getState().items.filter((it) => it.kind === 'assistant');
+  assert.equal(assistants.length, 1, 'leading-newline segment must not be duplicated at finalize');
+  assert.equal(assistants[0].text, LEAD_TAIL);
+});

package/scripts/tool-smoke.mjs

@@ -609,6 +609,19 @@ const graphOut = await executeCodeGraphTool('code_graph', {
   file: 'scripts/smoke.mjs',
 }, root);
 assertOk('code_graph', graphOut, /binding|spawnSync|symbol/i);
+const graphStringSymbolOut = await executeCodeGraphTool('code_graph', {
+  mode: 'symbols',
+  symbols: 'executeBuiltinTool',
+}, root);
+assertOk('code_graph string symbols', graphStringSymbolOut, /executeBuiltinTool|symbol_search/i);
+const graphRootAnchorOut = await executeCodeGraphTool('code_graph', {
+  mode: 'symbol_search',
+  symbol: 'executeBuiltinTool',
+  file: root,
+}, root);
+if (/file not found|outside cwd|arbitrary tree/i.test(String(graphRootAnchorOut))) {
+  throw new Error(`code_graph redundant root anchor was not normalized:\n${graphRootAnchorOut}`);
+}
 
 const graphSymbolBatchOut = await executeCodeGraphTool('code_graph', {
   mode: 'symbol_search',
@@ -1242,16 +1255,11 @@ if (normalizedExplore.length !== 2 || normalizedExplore[0] !== 'where is model s
 }
 if (MAX_FANOUT_QUERIES !== 8) throw new Error(`explore fanout cap changed: ${MAX_FANOUT_QUERIES}`);
 const explorerPrompt = buildExplorerPrompt('where is <agent> & status?');
-if (!explorerPrompt.includes('&lt;agent&gt;') || !explorerPrompt.includes('&amp;') || /verdicts, ratings, or recommendations/.test(explorerPrompt) === false) {
+if (explorerPrompt !== '<query>where is &lt;agent&gt; &amp; status?</query>') {
   throw new Error(`explorer prompt contract failed: ${explorerPrompt}`);
 }
-if (
-  !/STOP and answer NOW/.test(explorerPrompt)
-  || !/Turns 2-3 exist SOLELY as zero-hit recovery/.test(explorerPrompt)
-  || !/HARD max 3 tool turns/.test(explorerPrompt)
-  || !/turn 1\/3/.test(explorerPrompt)
-) {
-  throw new Error(`explorer prompt must force immediate answer on a specific-token anchor while preserving the 3-turn cap: ${explorerPrompt}`);
+if (/Reminder:|BUDGET|STOP and answer|verdicts|ratings|recommendations|grep|code_graph|find|glob/i.test(explorerPrompt)) {
+  throw new Error(`explorer prompt must not duplicate the system routing/fan-out contract: ${explorerPrompt}`);
 }
 setInternalToolsProvider({
   executor: async () => 'tool-smoke internal tool',
@@ -1358,7 +1366,7 @@ setInternalToolsProvider({
     if (!/Read-only retrieval role/i.test(visible) || /# environment/i.test(visible) || /git operations deferred to Lead/i.test(visible)) {
       throw new Error(`explorer hidden retrieval context should stay slim: ${visible.slice(0, 1200)}`);
     }
-    if (!/# Role: explorer/i.test(systemVisible) || /# Role: explorer/i.test(userReminderVisible) || !/Coordinate locator/i.test(systemVisible)) {
+    if (!/# Role: explorer/i.test(systemVisible) || /# Role: explorer/i.test(userReminderVisible) || !/deliver WHERE/i.test(systemVisible)) {
       throw new Error(`explorer role md must ride BP2 system, not BP3 user reminder: system=${systemVisible.slice(0, 600)} user=${userReminderVisible.slice(0, 600)}`);
     }
     // System layers (BP1 tool policy + BP2 role md) are shared/frozen and sized
@@ -1734,7 +1742,7 @@ const readArrayItemAnyOf = readArraySchema?.items?.anyOf || [];
 if (!readArrayItemAnyOf.some((entry) => entry?.type === 'object' && entry?.properties?.offset && entry?.properties?.limit)) {
   throw new Error('read schema must expose array-of-region objects for batched spans');
 }
-if (/line\+context/i.test(readDescription) || !/verified file path/i.test(readDescription) || !/Unknown path.*find first/i.test(readDescription) || !/Batch paths\/regions as real arrays/i.test(readDescription)) {
+if (/line\+context/i.test(readDescription) || !/verified file path/i.test(readDescription) || !/guessed path.*find first/i.test(readDescription) || !/Batch paths\/regions as real arrays/i.test(readDescription)) {
   throw new Error('read description must expose offset/limit as the single window form');
 }
 if (readProps.line || readProps.context) {
@@ -1834,7 +1842,7 @@ if (codeGraphSymbolSearchErr) {
 if (!/code structure\/flow/i.test(codeGraphDescription) || !/symbols\/references\/calls\/deps/i.test(codeGraphDescription)) {
   throw new Error('code_graph description must stay structure-oriented and name its symbol modes');
 }
-if (!/Known symbols or verified files only/i.test(codeGraphDescription) || !/Batch symbols\[\]\/files\[\]/i.test(codeGraphDescription)) {
+if (!/files\[\] must be verified paths/i.test(codeGraphDescription) || !/Batch symbols\[\]\/files\[\]/i.test(codeGraphDescription)) {
   throw new Error('code_graph description must route unknown file paths through locators first');
 }
 if (!/repo-local/i.test(codeGraphDescription) || !/NOT web search|not web/i.test(codeGraphDescription)) {
@@ -2150,7 +2158,7 @@ const grepHeadLimitDescription = grepTool?.inputSchema?.properties?.head_limit?.
 if (!/Array = variants in one call/i.test(grepPatternDescription) || !/Verified file\/dir/i.test(grepPathDescription)) {
   throw new Error('grep schema must keep compact pattern/path guidance');
 }
-if (!/verified scope/i.test(grepTool?.description || '') || !/Unknown path\/name.*find first/i.test(grepTool?.description || '')) {
+if (!/verified scope/i.test(grepTool?.description || '') || !/guessed path fragment.*find first/i.test(grepTool?.description || '')) {
   throw new Error('grep description must require verified scopes and locator-first unknown paths');
 }
 if (!/Glob filter/i.test(grepGlobDescription) || !/no guessed src\/\*\*/i.test(grepGlobDescription)) {
@@ -2174,7 +2182,7 @@ if (!/exact glob from verified roots/i.test(globTool?.description || '')) {
 if (!/Partial path\/name lookup/i.test(findTool?.description || '') || !/verify roots before grep\/glob/i.test(findTool?.description || '')) {
   throw new Error('find description must advertise unverified path/name lookup and verified outputs');
 }
-if (!/List verified directories/i.test(listTool?.description || '') || !/Unknown dir.*find first/i.test(listTool?.description || '') || !/Verified directory/i.test(listTool?.inputSchema?.properties?.path?.description || '')) {
+if (!/List verified directories/i.test(listTool?.description || '') || !/Guessed dir.*find first/i.test(listTool?.description || '') || !/Verified directory/i.test(listTool?.inputSchema?.properties?.path?.description || '')) {
   throw new Error('list description must require verified directories and locator-first unknown dirs');
 }
 if (!/Repo-local/i.test(codeGraphProps.mode?.description || '') || !/one call/i.test(codeGraphProps.symbols?.description || '')) {

package/scripts/tool-tui-presentation-test.mjs

@@ -0,0 +1,202 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  aggregateToolCategoryEntry,
+  formatAggregateHeader,
+  summarizeToolArgs,
+  toolWorkUnit,
+} from '../src/runtime/shared/tool-surface.mjs';
+import {
+  normalizeToolTerminalStatus,
+  toolResultTerminalStatus,
+} from '../src/runtime/shared/tool-status.mjs';
+import {
+  aggregateBucketForCategory,
+  toolCallOutcome,
+} from '../src/tui/engine/tool-result-status.mjs';
+import { createToolCardResults } from '../src/tui/engine/tool-card-results.mjs';
+import {
+  appendAgentResponseTail,
+  formatAgentResponseRaw,
+} from '../src/tui/engine/agent-response-tail.mjs';
+
+test('tool action copy keeps Add/Delete patch verbs and human read offsets', () => {
+  assert.equal(
+    toolWorkUnit('apply_patch', { patch: '*** Begin Patch\n*** Add File: new.mjs\n+x\n*** End Patch' }).done,
+    'Created',
+  );
+  assert.equal(
+    toolWorkUnit('apply_patch', { patch: '*** Begin Patch\n*** Delete File: old.mjs\n*** End Patch' }).active,
+    'Deleting',
+  );
+  assert.match(summarizeToolArgs('read', { path: 'a.mjs', offset: 0, limit: 10 }), /lines 1-10/);
+});
+
+test('Agent aggregation is batch-scoped and keeps category action wording', () => {
+  const entry = aggregateToolCategoryEntry('agent', { type: 'spawn' }, 'Agent');
+  assert.equal(formatAggregateHeader({ [entry.key]: { ...entry, count: 2 } }, { pending: false }), 'Called 2 agents');
+  assert.notEqual(
+    aggregateBucketForCategory('Agent', { agentBatch: 1 }),
+    aggregateBucketForCategory('Agent', { agentBatch: 2 }),
+  );
+});
+
+test('terminal result statuses stay separate from tool-call failure accounting', () => {
+  assert.equal(normalizeToolTerminalStatus('denied'), 'denied');
+  assert.equal(toolResultTerminalStatus('[status: cancelled]\n'), 'cancelled');
+
+  const state = {
+    items: [{
+      id: 'aggregate',
+      kind: 'tool',
+      result: null,
+      count: 1,
+      completedCount: 0,
+    }],
+  };
+  const aggregate = {
+    itemId: 'aggregate',
+    calls: new Map([['call_1', { name: 'web_fetch', args: {}, category: 'Web Research' }]]),
+    nextSummarySeq: 0,
+    ensureVisible: () => {},
+  };
+  const { patchToolCardResult } = createToolCardResults({
+    getState: () => state,
+    set: () => {},
+    patchItem: (id, patch) => {
+      const index = state.items.findIndex((item) => item.id === id);
+      state.items[index] = { ...state.items[index], ...patch };
+      return true;
+    },
+    markToolCallDone: () => {},
+    updateAgentJobCard: () => {},
+    buildAgentJobCardPatch: () => ({}),
+    agentStatusState: () => ({}),
+  });
+  const card = { itemId: 'aggregate', callId: 'call_1', done: false, aggregate };
+  assert.equal(patchToolCardResult(card, {
+    tool_call_id: 'call_1',
+    content: 'status: failed\nHTTP 404 Not Found',
+  }, new Map(), new Set()), true);
+  assert.equal(state.items[0].errorCount, 0);
+  assert.equal(state.items[0].callErrorCount, 0);
+  assert.equal(aggregate.calls.get('call_1').isError, false);
+});
+
+function patchAggregate(messages) {
+  const state = { items: [{ id: 'aggregate', kind: 'tool', result: null, count: messages.length, completedCount: 0 }] };
+  const aggregate = {
+    itemId: 'aggregate',
+    calls: new Map(messages.map((message) => [message.tool_call_id, {
+      name: 'shell',
+      args: {},
+      category: 'Shell',
+    }])),
+    nextSummarySeq: 0,
+    ensureVisible: () => {},
+  };
+  const { patchToolCardResult } = createToolCardResults({
+    getState: () => state,
+    set: () => {},
+    patchItem: (id, patch) => {
+      const index = state.items.findIndex((item) => item.id === id);
+      state.items[index] = { ...state.items[index], ...patch };
+      return true;
+    },
+    markToolCallDone: () => {},
+    updateAgentJobCard: () => {},
+    buildAgentJobCardPatch: () => ({}),
+    agentStatusState: () => ({}),
+  });
+  for (const message of messages) {
+    patchToolCardResult(
+      { itemId: 'aggregate', callId: message.tool_call_id, done: false, aggregate },
+      message,
+      new Map(),
+      new Set(),
+    );
+  }
+  return state.items[0];
+}
+
+test('exit detail stays successful and does not inflate Ok or Failed counts', () => {
+  const exit = 'Error: [shell-run-failed] [exit code: 1]\ncommand output';
+  const exitOnly = patchAggregate([{ tool_call_id: 'exit', content: exit, toolKind: 'error' }]);
+  assert.equal(exitOnly.errorCount, 0);
+  assert.equal(exitOnly.callErrorCount, 0);
+  assert.equal(exitOnly.exitErrorCount, 1);
+  assert.equal(exitOnly.result, 'Exit 1');
+
+  const mixed = patchAggregate([
+    { tool_call_id: 'failed', content: 'transport unavailable', isError: true },
+    { tool_call_id: 'exit', content: exit, isError: true },
+  ]);
+  assert.equal(mixed.errorCount, 1);
+  assert.equal(mixed.callErrorCount, 1);
+  assert.equal(mixed.exitErrorCount, 1);
+  assert.equal(mixed.result, '1 Failed · 1 Exit');
+});
+
+test('eager call outcome uses only envelope failure metadata', () => {
+  const exit = 'Error: [shell-run-failed] [exit code: 1]';
+  assert.equal(toolCallOutcome({ content: 'Error: domain failure' }, 'Error: domain failure').isCallError, false);
+  assert.equal(toolCallOutcome({ isError: true, content: 'ok-looking body' }, 'ok-looking body').isCallError, true);
+  assert.deepEqual(toolCallOutcome({ toolKind: 'error' }, exit), { isCallError: false, isExitError: true, exitCode: 1 });
+  assert.deepEqual(toolCallOutcome({ isError: true }, exit), { isCallError: false, isExitError: true, exitCode: 1 });
+  assert.equal(toolCallOutcome({ isError: true }, 'Error: [shell-run-failed] [timeout: 1s]').isCallError, true);
+});
+
+test('tail response aggregation is ordered, idempotent, and boundary-safe', () => {
+  const first = {
+    kind: 'tool',
+    agentDirection: 'inbound',
+    agentResponseKey: 'one',
+    agentResponseHasBody: true,
+    agentResponseEntries: [{ key: 'one', raw: 'body one', result: 'one', hasBody: true, isError: false }],
+  };
+  const secondPatch = appendAgentResponseTail(first, {
+    key: 'two', args: { type: 'result' }, rawResult: 'body two', result: 'two', hasBody: true,
+  }, 1);
+  const second = { ...first, ...secondPatch };
+  const thirdPatch = appendAgentResponseTail(second, {
+    key: 'three', args: { type: 'result' }, rawResult: 'body three', result: 'three', hasBody: true,
+  }, 2);
+  assert.equal(thirdPatch.count, 3);
+  assert.equal(
+    thirdPatch.rawResult,
+    '1. agent\nbody one\n\n2. agent\nbody two\n\n3. agent\nbody three',
+  );
+  const retryPatch = appendAgentResponseTail({ ...second, ...thirdPatch }, {
+    key: 'two', args: { type: 'result' }, rawResult: 'body two retry', result: 'two retry', hasBody: true,
+  }, 3);
+  assert.equal(retryPatch.count, 3);
+  assert.match(retryPatch.rawResult, /2\. agent\nbody two retry/);
+  assert.equal(appendAgentResponseTail({ kind: 'user' }, {
+    key: 'four', rawResult: 'body four', result: 'four', hasBody: true,
+  }), null);
+  assert.equal(formatAgentResponseRaw(retryPatch.agentResponseEntries).match(/\d+\. agent/g).length, 3);
+});
+
+test('failure preview upgrades its tail entry, but a boundary forces a new body card', () => {
+  const failurePreview = {
+    kind: 'tool',
+    agentDirection: 'inbound',
+    agentResponseKey: 'task_1',
+    agentResponseHasBody: false,
+    agentResponseEntries: [{
+      key: 'task_1', raw: 'failed preview', result: 'failed', hasBody: false, isError: true,
+    }],
+  };
+  const upgrade = appendAgentResponseTail(failurePreview, {
+    key: 'task_1', args: { type: 'result' }, rawResult: 'final body', result: 'final', hasBody: true, isError: false,
+  }, 1);
+  assert.equal(upgrade.count, 1);
+  assert.equal(upgrade.rawResult, '1. agent\nfinal body');
+  assert.equal(upgrade.isError, false);
+
+  const boundary = appendAgentResponseTail({ kind: 'assistant', text: 'intervening text' }, {
+    key: 'task_1', args: { type: 'result' }, rawResult: 'final body', result: 'final', hasBody: true,
+  });
+  assert.equal(boundary, null);
+});

package/src/agents/heavy-worker/AGENT.md

@@ -3,14 +3,17 @@ permission: read-write
 ---
 
 # Heavy Worker
-Broad implementation agent.
+Own the assigned implementation slice through staged delivery.
 
-Bounded slices; smallest coherent change, not rewrite. Stop when scope is
-unclear or the blast radius grows.
+Break work into bounded, dependency-aware slices and execute them in sequence.
+At each checkpoint, run the narrowest relevant test or build before expanding
+the slice. Keep the smallest coherent change; control blast radius rather than
+rewriting adjacent systems.
 
-EDIT-FIRST DISCIPLINE. Patch the first bounded piece — edit incrementally,
-don't read exhaustively. Repeated read-only turns without an edit = stalling;
-on a runtime reminder, patch the piece you understand or report blocked.
+EDIT-FIRST DISCIPLINE. Patch incrementally and stop at the first explicit
+boundary: unclear ownership, a missing dependency, or growing blast radius.
+Do not cross that boundary without a new bounded assignment; report blocked
+work with the relevant file:line.
 
-Self-verify edits with shell (targeted test/build).
+Self-verify each checkpoint and the final slice with shell (targeted test/build).
 

package/src/agents/reviewer/AGENT.md

@@ -4,8 +4,10 @@ permission: read
 
 # Reviewer
 
-Regression/risk review agent.
+Independent regression/risk review agent.
 
-Find actionable correctness/regression/security/verification risks. Findings
-first, severity-ordered, one line with `file:line`; skip non-risky nits. If
-clean, one line + only material residual risk.
+Review the approved intent, diff, and tests with independent judgment. Prioritize
+actionable correctness, regression, security, and verification risks; inspect
+affected boundaries. Do not reimplement the change or report non-risky nits.
+Report findings first, severity-ordered, with one line per `file:line`. If clean,
+say so in one line and include only material residual risk.

package/src/agents/worker/AGENT.md

@@ -5,11 +5,13 @@ permission: read-write
 # Worker
 Scoped implementation agent.
 
-Smallest scoped change; no drive-by cleanup. Stop when done/blocked.
+Own only the bounded responsibility assigned in the brief. Trust its
+`file:line` anchors; do only minimal targeted discovery, then make the
+smallest coherent patch. No drive-by cleanup or scope expansion.
 
-EDIT-FIRST DISCIPLINE. Brief anchors (`file:line`) are pre-verified — trust
-and patch. Repeated read-only turns without an edit = stalling; on a runtime
-reminder, patch now or return blocked. Threshold is "plausible", not "proven".
+EDIT-FIRST DISCIPLINE. Patch promptly rather than repeating read-only turns;
+stop and report blocked when the assigned scope cannot be completed.
 
-Self-verify edits with shell (node --check/test).
+Self-verify with a targeted check (for example, `node --check` or a focused
+test), then report the changed `file:line` and stop.
 

package/src/rules/agent/00-common.md

@@ -1,7 +1,7 @@
 # Public Agent Constraints
 
-- Do not touch git/Ship; refuse any `git add`/`commit`/`push`/`stash` with
-  `git operations deferred to Lead`.
-- Shell only verifies your own edits (node --check, targeted tests, build/lint);
-  no exploration, installs, or state changes beyond the brief.
+- Do not touch git/Ship. Refuse `git add`/`commit`/`push`/`stash`: `git
+  operations deferred to Lead`.
+- Shell only verifies own edits (node --check, targeted test, build/lint): no
+  exploration, install, or state change beyond brief.
 - Overflow goes to a file; hand off path + fragments.