mixdog 0.9.38 → 0.9.40

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/scripts/tui-transcript-perf-test.mjs

@@ -0,0 +1,279 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createEngineItemMutators, replaceEngineItemsState } from '../src/tui/engine.mjs';
+import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
+import { createRunTurn } from '../src/tui/engine/turn.mjs';
+import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-window.mjs';
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function makeTurnHarness(ask) {
+  let seq = 0;
+  let state = {
+    items: [],
+    structureRevision: 0,
+    streamingTail: null,
+    stats: { turns: 0, inputTokens: 0, outputTokens: 0 },
+    busy: false,
+    spinner: null,
+    thinking: null,
+  };
+  const itemIndexById = new Map();
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const pushItem = (item) => {
+    const items = [...state.items, item];
+    if (item?.id != null) itemIndexById.set(item.id, items.length - 1);
+    set({ items, structureRevision: state.structureRevision + 1 });
+  };
+  const updateStreamingTail = (id, patch) => set({
+    streamingTail: {
+      ...(state.streamingTail?.id === id ? state.streamingTail : {}),
+      ...patch,
+      kind: 'assistant',
+      id,
+      streaming: true,
+    },
+  });
+  const { patchItem, settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  const clearStreamingTail = (id = null) => {
+    if (id == null || state.streamingTail?.id === id) set({ streamingTail: null });
+  };
+  const bag = {
+    runtime: { id: null, toolMode: 'auto', ask, abort: () => true },
+    nextId: () => `id_${++seq}`,
+    tuiDebug: () => {},
+    LEAD_TURN_TIMEOUT_MS: 300_000,
+    flags: { leadTurnEpoch: 0, disposed: false },
+    pending: [],
+    itemIndexById,
+    getState: () => state,
+    set,
+    pushItem,
+    patchItem,
+    updateStreamingTail,
+    settleStreamingTail,
+    clearStreamingTail,
+    pushNotice: () => {},
+    pushUserOrSyntheticItem: () => {},
+    markToolCallActive: () => {},
+    markToolCallDone: () => {},
+    clearActiveToolSummary: () => {},
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    requestToolApproval: async () => ({ approved: false }),
+    patchToolCardResult: () => {},
+    flushToolResults: () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    drain: async () => {},
+    drainPendingSteering: () => [],
+  };
+  return { runTurn: createRunTurn(bag), getState: () => state };
+}
+
+test('stream flush keeps settled items identity and finalize appends one assistant', async () => {
+  let identityStable = false;
+  const harness = makeTurnHarness(async (_text, options) => {
+    const before = harness.getState().items;
+    options.onTextDelta('settled line\n');
+    await wait(30);
+    identityStable = harness.getState().items === before;
+    assert.match(harness.getState().streamingTail?.text || '', /settled line/);
+    return { result: { content: 'settled line\n' }, session: { messages: [] } };
+  });
+
+  assert.equal(await harness.runTurn('go'), 'done');
+  assert.equal(identityStable, true, 'tail flush must not swap settled items');
+  assert.equal(harness.getState().streamingTail, null);
+  const assistants = harness.getState().items.filter((item) => item.kind === 'assistant');
+  assert.equal(assistants.length, 1);
+  assert.equal(assistants[0].streaming, false);
+  assert.equal(assistants[0].text, 'settled line\n');
+});
+
+test('abort after stream progress settles the tail and leaves no orphan', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onTextDelta('partial line\n');
+    await wait(30);
+    const error = new Error('interrupted');
+    error.name = 'SessionClosedError';
+    throw error;
+  });
+
+  assert.equal(await harness.runTurn('go'), 'cancelled');
+  assert.equal(harness.getState().streamingTail, null);
+  const assistants = harness.getState().items.filter((item) => item.kind === 'assistant');
+  assert.equal(assistants.length, 1);
+  assert.equal(assistants[0].streaming, false);
+  assert.match(assistants[0].text, /partial line/);
+});
+
+// Codifies pre-existing parity: text had no item/currentAssistantId before its first completed line.
+test('abort before a newline has no tail id and preserves prior text-drop parity', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onTextDelta('partial without newline');
+    await wait(30);
+    const error = new Error('interrupted');
+    error.name = 'SessionClosedError';
+    throw error;
+  });
+
+  assert.equal(await harness.runTurn('go'), 'cancelled');
+  assert.equal(harness.getState().streamingTail, null);
+  assert.equal(
+    harness.getState().items.filter((item) => item.kind === 'assistant').length,
+    0,
+    'without a visible tail id, pre-newline text keeps the existing drop-on-abort behavior',
+  );
+});
+
+// Codifies pre-existing parity: the old in-items completed-line snapshot survived starved recovery.
+test('starved Esc recovery settles a non-empty tail exactly once', async () => {
+  let state = {
+    items: [],
+    structureRevision: 0,
+    streamingTail: { id: 'tail_abort', kind: 'assistant', text: 'visible partial\n', streaming: true },
+    queued: [],
+    busy: true,
+    commandBusy: false,
+    spinner: { active: true },
+    thinking: null,
+    lastTurn: null,
+  };
+  const itemIndexById = new Map();
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { patchItem, settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  const bag = {
+    runtime: { abort: () => true },
+    nextId: () => 'notice',
+    flags: { leadTurnEpoch: 1, disposed: false, draining: false, manualAbortRecoveryMs: 10 },
+    pending: [],
+    listeners: new Set(),
+    getState: () => state,
+    set,
+    pushItem: () => {},
+    patchItem,
+    replaceItems: (items) => items,
+    settleStreamingTail,
+    clearStreamingTail: () => set({ streamingTail: null }),
+    pushNotice: () => {},
+    autoClearState: () => ({}),
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    updateAgentJobCard: () => {},
+    requeueEntriesFront: () => {},
+    enqueue: () => {},
+    autoClearBeforeSubmit: async () => {},
+    restoreQueued: () => {},
+    resetStatsAndSyncContext: () => {},
+    drain: async () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    discardExecutionPendingResume: () => {},
+  };
+
+  createEngineApiA(bag).abort();
+  await wait(30);
+  assert.equal(state.streamingTail, null);
+  const assistants = state.items.filter((item) => item.kind === 'assistant');
+  assert.equal(assistants.length, 1);
+  assert.equal(assistants[0].id, 'tail_abort');
+  assert.equal(assistants[0].streaming, false);
+});
+
+test('removeNotice-style replacement preserves the live tail and later settles once', () => {
+  let state = {
+    items: [{ id: 'notice', kind: 'notice', text: 'temporary' }],
+    structureRevision: 4,
+    streamingTail: { id: 'tail_notice', kind: 'assistant', text: 'visible\n', streaming: true },
+  };
+  const itemIndexById = new Map([['notice', 0]]);
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  state = replaceEngineItemsState({
+    state,
+    items: state.items.filter((item) => item.id !== 'notice'),
+    itemIndexById,
+    preserveStreamingTail: true,
+  });
+
+  assert.equal(state.streamingTail?.id, 'tail_notice');
+  assert.equal(settleStreamingTail('tail_notice', { text: 'complete final text' }), true);
+  assert.equal(state.items.length, 1);
+  assert.equal(state.items[0].text, 'complete final text');
+  assert.equal(state.items[0].streaming, false);
+  assert.equal(settleStreamingTail('tail_notice', { text: 'duplicate' }), false);
+  assert.equal(state.items.length, 1);
+});
+
+test('bulk replacement clears the tail and stale settle cannot append into reset transcript', () => {
+  let state = {
+    items: [{ id: 'old', kind: 'user', text: 'old prompt' }],
+    structureRevision: 8,
+    streamingTail: { id: 'stale_tail', kind: 'assistant', text: 'old response\n', streaming: true },
+  };
+  const itemIndexById = new Map([['old', 0]]);
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  state = replaceEngineItemsState({ state, items: [], itemIndexById });
+
+  assert.equal(state.streamingTail, null);
+  assert.equal(settleStreamingTail('stale_tail', { text: 'must not reappear' }), false);
+  assert.deepEqual(state.items, []);
+});
+
+test('tool-card revision invalidates the incremental prefix cache', () => {
+  const cacheRef = { current: null };
+  const tail = { id: 'tail', kind: 'assistant', text: 'live\n', streaming: true };
+  let state = {
+    items: [{ id: 'tool', kind: 'tool', name: 'shell', text: 'ok', result: 'ok' }],
+    structureRevision: 1,
+    streamingTail: tail,
+  };
+  const itemIndexById = new Map([['tool', 0]]);
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { patchItem } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  const before = buildTranscriptRowIndexIncremental([...state.items, state.streamingTail], {
+    columns: 24,
+    cacheRef,
+    prefixRevision: state.structureRevision,
+  });
+  const cachedBeforePatch = cacheRef.current;
+  assert.equal(patchItem('tool', {
+    text: 'a much longer tool result '.repeat(20),
+    result: 'a much longer tool result '.repeat(20),
+  }), true);
+  assert.equal(state.structureRevision, 2, 'real engine patchItem bumps revision');
+  const after = buildTranscriptRowIndexIncremental([...state.items, state.streamingTail], {
+    columns: 24,
+    cacheRef,
+    prefixRevision: state.structureRevision,
+  });
+
+  assert.notEqual(cacheRef.current, cachedBeforePatch, 'revision bump rebuilds the prefix cache');
+  assert.equal(after.rows.length, before.rows.length);
+  assert.equal(cacheRef.current.prefixRevision, 2);
+});

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.

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

@@ -1,16 +1,13 @@
 # Agent Constraints
 
-- Use English for agent task communication.
-- One turn = one batch; any read-only call that could have ridden the prior
-  turn is wasted.
-- Never preamble/progress before tools; call tools immediately. Text only in
-  the final handoff after tool work.
-- Final handoff: fragments only — outcome, key `file:line`, verification
-  command+result, material risks/blockers. Follow stricter role contracts.
-- Do not repeat the brief, process, search path, or any fact. Report done/
-  missing/blocker instead of retrieving to avoid reporting.
-- Handoff cap ~30 lines unless `Deliver:` raises it; this is a ceiling.
-- Ban headings, tables unless requested, prose narration, raw logs/tool traces,
-  speculative next-checks, restated brief, articles/politeness.
-- Runtime wrap-up directives override this and may require done/remaining/
-  blocking summary.
+- Agent communication: English. One turn = one batch; a read-only call that
+  could join the prior turn is wasted.
+- Call tools immediately: no preamble/progress; text only in final handoff.
+- Final handoff is fragments: outcome, key `file:line`, verification
+  command+result, material risk/blocker; stricter role contracts win. Don't
+  repeat brief/process/search path/facts; report done/missing/blocker, don't
+  retrieve to report.
+- Cap ~30 lines unless `Deliver:` raises it. No headings/tables unless asked,
+  prose narration, raw logs/tool traces, speculative next-checks, restated
+  brief, articles/politeness.
+- Runtime wrap-up overrides; it may require done/remaining/blocking summary.

package/src/rules/agent/20-skip-protocol.md

@@ -1,5 +1,5 @@
 # Skip Protocol
 
-For inbound-event reports (`webhook-handler`, `scheduler-task`) with nothing
-actionable to relay (label-only, duplicate/dedup, no action needed/report),
-prefix the whole response with `[meta:silent]`.
+For non-actionable inbound-event reports (`webhook-handler`, `scheduler-task`:
+label-only, duplicate/dedup, no action needed/report), prefix the whole response
+with `[meta:silent]`.