mixdog 0.9.39 → 0.9.41

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

@@ -3,6 +3,8 @@ import assert from 'node:assert/strict';
 import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
 import { createRunTurn } from '../src/tui/engine/turn.mjs';
 
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
 // Minimal bag: drainPendingSteering only touches pending, the queue helpers,
 // and commitSteeringQueueEntries (which no-ops on disk when runtime.id is not
 // a valid session key). No provider/runTurn wiring needed.
@@ -71,7 +73,7 @@ test('drainPendingSteering accepts runtime callback signature', () => {
   assert.equal(bag.pending.length, 0);
 });
 
-test('drained notification key remains deduped and displayed key is not cleared', () => {
+test('drained notification key is released while displayed key is not cleared', () => {
   const { flow, bag } = makeFlow();
   bag.getState().busy = true;
   assert.equal(flow.enqueue('task finished', { mode: 'task-notification', key: 'task-1' }), true);
@@ -80,7 +82,7 @@ test('drained notification key remains deduped and displayed key is not cleared'
   const out = flow.drainPendingSteering({ maxPriority: 'later' });
 
   assert.deepEqual(out, ['task finished']);
-  assert.equal(flow.enqueue('task duplicate', { mode: 'task-notification', key: 'task-1' }), false);
+  assert.equal(flow.enqueue('task duplicate', { mode: 'task-notification', key: 'task-1' }), true);
   assert.equal(bag.displayedExecutionNotificationKeys.has('task-1'), true);
 });
 
@@ -123,7 +125,11 @@ test('post-turn drain does not send queued slash command to model', async () =>
 // 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) {
+function makeTurnBag(ask, {
+  timeoutMs = 300000,
+  getTurnLiveness,
+  abort,
+} = {}) {
   let seq = 0;
   const state = {
     items: [],
@@ -134,11 +140,13 @@ function makeTurnBag(ask) {
   };
   const itemIndexById = new Map();
   const findIndexById = (id) => state.items.findIndex((it) => it.id === id);
+  const runtime = { id: null, toolMode: 'auto', ask, abort: abort || (() => {}) };
+  if (typeof getTurnLiveness === 'function') runtime.getTurnLiveness = getTurnLiveness;
   const bag = {
-    runtime: { id: null, toolMode: 'auto', ask, abort: () => {} },
+    runtime,
     nextId: () => `id_${++seq}`,
     tuiDebug: () => {},
-    LEAD_TURN_TIMEOUT_MS: 300000,
+    LEAD_TURN_TIMEOUT_MS: timeoutMs,
     flags: { leadTurnEpoch: 0 },
     pending: [],
     itemIndexById,
@@ -176,6 +184,133 @@ function makeTurnBag(ask) {
   return { bag, getState: () => state };
 }
 
+test('watchdog accepts fresh runtime liveness without tripping', async () => {
+  let aborts = 0;
+  const ask = async () => {
+    await wait(45);
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs: 15,
+    abort: () => { aborts += 1; },
+    getTurnLiveness: () => ({
+      stage: 'tool_running',
+      lastProgressAt: Date.now(),
+      toolStartedAt: Date.now(),
+      toolSelfDeadlineMs: 0,
+    }),
+  });
+
+  assert.equal(await createRunTurn(bag)('do a thing'), 'done');
+  assert.equal(aborts, 0, 'fresh orchestrator heartbeats defer the watchdog');
+});
+
+test('watchdog trips at the tool ceiling despite fresh liveness', async () => {
+  const previousMax = process.env.MIXDOG_LEAD_TOOL_MAX_MS;
+  const timeoutMs = 30;
+  const ceilingMs = 95;
+  process.env.MIXDOG_LEAD_TOOL_MAX_MS = String(ceilingMs);
+  let rejectAsk;
+  let heartbeatTimer = null;
+  let heartbeatStartTimer = null;
+  let aborts = 0;
+  let abortAt = 0;
+  let livenessCalls = 0;
+  const toolStartedAt = Date.now();
+  const ask = (_userText, options) => new Promise((_resolve, reject) => {
+    rejectAsk = reject;
+    // Let the first watchdog probe defer from orchestrator liveness, then keep
+    // the TUI's local progress fresh so the ceiling-bounded re-arm is exercised.
+    heartbeatStartTimer = setTimeout(() => {
+      heartbeatTimer = setInterval(() => options.onStreamDelta(), 5);
+    }, 40);
+  });
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs,
+    abort: () => {
+      aborts += 1;
+      abortAt = Date.now();
+      clearTimeout(heartbeatStartTimer);
+      clearInterval(heartbeatTimer);
+      const error = new Error('interrupted');
+      error.name = 'SessionClosedError';
+      rejectAsk(error);
+    },
+    getTurnLiveness: () => {
+      livenessCalls += 1;
+      return {
+        stage: 'tool_running',
+        lastProgressAt: Date.now(),
+        toolStartedAt,
+        toolSelfDeadlineMs: 0,
+      };
+    },
+  });
+
+  try {
+    const result = await Promise.race([
+      createRunTurn(bag)('do a thing'),
+      wait(180).then(() => 'watchdog did not trip at the ceiling'),
+    ]);
+    assert.equal(result, 'cancelled');
+    assert.equal(aborts, 1);
+    assert.ok(livenessCalls >= 2, 'first probe deferred, then the ceiling probe rechecked liveness');
+    assert.ok(abortAt - toolStartedAt < ceilingMs + timeoutMs, 'ceiling trips before an unbounded watchdog interval');
+  } finally {
+    clearTimeout(heartbeatStartTimer);
+    clearInterval(heartbeatTimer);
+    if (previousMax === undefined) delete process.env.MIXDOG_LEAD_TOOL_MAX_MS;
+    else process.env.MIXDOG_LEAD_TOOL_MAX_MS = previousMax;
+  }
+});
+
+for (const [name, getTurnLiveness] of [
+  ['throws', () => { throw new Error('liveness unavailable'); }],
+  ['returns null', () => null],
+]) {
+  test(`watchdog ${name} probe falls back to abort`, async () => {
+    let rejectAsk;
+    let aborts = 0;
+    const ask = () => new Promise((_resolve, reject) => { rejectAsk = reject; });
+    const { bag } = makeTurnBag(ask, {
+      timeoutMs: 15,
+      getTurnLiveness,
+      abort: () => {
+        aborts += 1;
+        const error = new Error('interrupted');
+        error.name = 'SessionClosedError';
+        rejectAsk(error);
+      },
+    });
+
+    const [result] = await Promise.all([createRunTurn(bag)('do a thing'), wait(40)]);
+    assert.equal(result, 'cancelled');
+    assert.equal(aborts, 1);
+  });
+}
+
+test('stream-delta progress keeps the watchdog alive', async () => {
+  let aborts = 0;
+  let streamDeltas = 0;
+  const ask = async (_userText, options) => {
+    options.onStreamDelta();
+    streamDeltas += 1;
+    await wait(12);
+    options.onStreamDelta();
+    streamDeltas += 1;
+    await wait(12);
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs: 20,
+    abort: () => { aborts += 1; },
+  });
+
+  assert.equal(await createRunTurn(bag)('do a thing'), 'done');
+  assert.equal(streamDeltas, 2);
+  assert.equal(aborts, 0);
+});
+
 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

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/reviewer/AGENT.md

@@ -11,3 +11,7 @@ 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.
+
+When the work comes with stated criteria or reference material for judging
+it, verify against those as given — substituting your own interpretation or
+a self-built check is a verification risk to report.

package/src/rules/lead/lead-brief.md

@@ -1,11 +1,19 @@
 # Lead Brief
 
-- One-line fragments: `Goal:` `Anchors:` `Allow/Forbid:` `Deliver:` `Verify:`
-  (+`Stop:` for heavy-worker). Minimum chars, maximum info: omit background,
-  motivation, role-known rules, repeated context/facts; split scope, don't pad.
+- One-line fragments. `Task:` is mandatory and lossless: include the intent,
+  required outcomes, negative outcomes, and completion/stop boundary. Minimum
+  chars, maximum info: omit role-known rules and repeated context/facts; split
+  scope, don't pad or discard task requirements.
+- Preserve user-supplied exact targets and exact replacements/outputs in
+  `Task:`. Never infer exactness from a task name, file count, or perceived
+  difficulty.
+- All other fields are optional task-specific deltas: `Anchors:`
+  `Allow/Forbid:` `Deliver:` `Verify:`. Omit any that add no information.
 - Anchors: `file:line` + one-line conclusion; never log/code bodies. Specify
   outcome, not method unless required. `Deliver:` gives shape/size, never a long
   handoff. Referenced spec/test beats its summary.
+- Preserve the exact same `Task:` across Worker -> Debugger -> Reviewer. Never
+  summarize, rewrite, or replace it when handing the scope to the next role.
 - Full brief only for fresh spawn/`respawned: true`; live follow-ups are delta.
   Dead-tag send is cold: re-supply anchors.
 - Never `send` mid-run; batch one follow-up after completion; interrupt only to

package/src/rules/lead/lead-tool.md

@@ -3,5 +3,3 @@
 - Write-role agents self-verify via `shell`; Lead runs cross-scope
   verification, benches, and all git via it.
 - Use current project/workspace unless user request/tool need.
-- If workflow permits delegation, use `agent` for scoped
-  implementation/research/review/debugging; a no-delegation workflow controls.

package/src/rules/shared/01-tool.md

@@ -44,3 +44,7 @@
   reread returned spans. A third window means the first was too narrow.
 - One carve-out to parallel-first: apply the edit, then verify it in a
   separate shell turn and consume results in order. Otherwise stay parallel.
+- A long-running command promoted to background is a decision point, not a
+  cue to wait: estimate from its observed progress whether it can finish
+  within the remaining budget; if not, diagnose the bottleneck and switch to
+  an alternative route. Waiting is chosen, never assumed.

package/src/runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs

@@ -194,6 +194,10 @@ export const DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = envTimeoutMs(
     'MIXDOG_AGENT_FIRST_RESPONSE_TIMEOUT_MS',
     120_000,
 );
+export const DEFAULT_FIRST_VISIBLE_CEILING_MS = envTimeoutMs(
+    'MIXDOG_AGENT_FIRST_VISIBLE_TIMEOUT_MS',
+    600_000,
+);
 export const DEFAULT_STALE_TIMEOUT_MS = envTimeoutMs(
     'MIXDOG_AGENT_STALE_TIMEOUT_MS',
     30 * 60_000,
@@ -209,6 +213,10 @@ export function resolveAgentWatchdogPolicy(agent, overrides = {}) {
         overrides.firstResponseTimeoutMs,
         DEFAULT_FIRST_RESPONSE_TIMEOUT_MS,
     );
+    const firstVisibleCeilingMs = resolveExplicitMs(
+        overrides.firstVisibleTimeoutMs,
+        DEFAULT_FIRST_VISIBLE_CEILING_MS,
+    );
 
     let idleStaleMs;
     if (Number.isFinite(overrides.idleTimeoutMs) && overrides.idleTimeoutMs >= 0) {
@@ -238,6 +246,7 @@ export function resolveAgentWatchdogPolicy(agent, overrides = {}) {
 
     return {
         firstResponseMs,
+        firstVisibleCeilingMs,
         idleStaleMs,
         toolRunningMs,
     };
@@ -248,8 +257,16 @@ export function evaluateAgentWatchdogAbort(snapshot, now, policy) {
 
     if (snapshot.waitingForFirstActivity) {
         const startedAt = snapshot.modelRequestStartedAt || snapshot.askStartedAt;
-        if (policy.firstResponseMs > 0 && startedAt && now - startedAt > policy.firstResponseMs) {
-            return new AgentStallAbortError(`agent first response stale (${policy.firstResponseMs}ms)`);
+        const hasTransport = Boolean(
+            startedAt
+            && snapshot.lastTransportAt
+            && snapshot.lastTransportAt > startedAt
+        );
+        const ceilingMs = hasTransport
+            ? policy.firstVisibleCeilingMs
+            : policy.firstResponseMs;
+        if (ceilingMs > 0 && startedAt && now - startedAt > ceilingMs) {
+            return new AgentStallAbortError(`agent first response stale (${ceilingMs}ms)`);
         }
         return null;
     }
@@ -293,6 +310,7 @@ export function evaluateAgentWatchdogAbort(snapshot, now, policy) {
 export function agentWatchdogPolicyActive(policy) {
     if (!policy) return false;
     return (policy.firstResponseMs > 0)
+        || (policy.firstVisibleCeilingMs > 0)
         || (policy.idleStaleMs > 0)
         || (policy.toolRunningMs > 0);
 }

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -309,6 +309,12 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
     const errorFirstLine = resultKind === 'error'
         ? _firstNonEmptyLine(_redactLogText(String(resultText ?? ''))).slice(0, 200) || null
         : null;
+    // Failure taxonomy on the tool row itself (mirrors the failure log's
+    // `category`) so trace-level aggregation can exclude expected command
+    // exits (`command-exit`) without joining tool-failures.jsonl.
+    const errorCategory = resultKind === 'error'
+        ? classifyToolFailure(String(resultText ?? ''), toolName)
+        : null;
     // Flat shape — fields named exactly as the agent_calls PG columns so
     // insertAgentCalls can pick them up by direct property access without
     // a payload-unwrap step. result_kind has no column and rides as plain
@@ -327,6 +333,7 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
         tool_args_summary: summarizedArgs,
         result_kind: resultKind || null,
         result_error_first_line: errorFirstLine,
+        result_error_category: errorCategory,
         result_has_next_call: nextCallCount > 0,
         result_next_call_count: nextCallCount,
         result_bytes_est: resultBytesEst,

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -784,6 +784,13 @@ export function composeSystemPrompt(opts) {
         ? ''
         : loadScopedRoleInstructions(opts.agent || null, opts.provider || null);
     const stableSystemParts = [];
+    // Active workflow contract leads the role layer: it must outrank the
+    // generic role/tool guidance below it, not trail the profile/meta block
+    // in BP3 (observed: leads deprioritized delegation rules that sat behind
+    // ~3KB of profile/output-style text).
+    if (opts.workflowContext && typeof opts.workflowContext === 'string' && opts.workflowContext.trim()) {
+        stableSystemParts.push(opts.workflowContext.trim());
+    }
     if (opts.roleRules) stableSystemParts.push(opts.roleRules);
     if (opts.userPrompt) stableSystemParts.push(opts.userPrompt);
     if (roleInstructionContext) stableSystemParts.push(roleInstructionContext);
@@ -798,9 +805,6 @@ export function composeSystemPrompt(opts) {
     if (opts.metaContext && typeof opts.metaContext === 'string' && opts.metaContext.trim()) {
         sessionMarkerParts.push(opts.metaContext.trim());
     }
-    if (opts.workflowContext && typeof opts.workflowContext === 'string' && opts.workflowContext.trim()) {
-        sessionMarkerParts.push(opts.workflowContext.trim());
-    }
     if (!_skip.memory && opts.coreMemoryContext && typeof opts.coreMemoryContext === 'string' && opts.coreMemoryContext.trim()) {
         sessionMarkerParts.push('# Core Memory\n' + opts.coreMemoryContext.trim());
     }