mixdog 0.9.40 → 0.9.43

package/scripts/submit-commandbusy-race-test.mjs

@@ -7,12 +7,39 @@ import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
 // command (commandBusy) or an auto-clear. Wires the real session-flow queue
 // (enqueue/drain) + the real submit() against a minimal bag whose set() mirrors
 // engine.mjs's commandBusy-release drain kick.
-function makeEngine({ autoClearBeforeSubmit } = {}) {
+function makeEngine({
+  autoClearBeforeSubmit,
+  autoClearEnabled = false,
+  runtimeClear = async () => true,
+} = {}) {
   let seq = 0;
   const executed = [];
-  let state = { queued: [], busy: false, commandBusy: false };
+  const providerRequests = [];
+  let resolveProviderDispatch;
+  const providerDispatch = new Promise((resolve) => { resolveProviderDispatch = resolve; });
+  let state = {
+    items: [{ kind: 'user', id: 'existing', text: 'existing prompt' }],
+    queued: [],
+    busy: false,
+    commandBusy: false,
+  };
   const bag = {
-    runtime: { id: null, consumePendingSessionReset: () => null },
+    runtime: {
+      id: 'session_1',
+      session: {
+        id: 'session_1',
+        messages: [{ role: 'user', content: 'existing prompt' }],
+        lastUsedAt: Date.now() - 1000,
+      },
+      getCompactionSettings: () => ({}),
+      clear: runtimeClear,
+      consumePendingSessionReset: () => null,
+      ask: async (text) => {
+        providerRequests.push(text);
+        resolveProviderDispatch(text);
+        return { result: { content: 'ok' }, session: bag.runtime.session };
+      },
+    },
     nextId: () => `id_${++seq}`,
     tuiDebug: () => {},
     flags: {},
@@ -30,12 +57,15 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
       if (released) queueMicrotask(() => { void bag.drain?.(); });
       return true;
     },
-    pushItem: () => {},
+    pushItem: (item) => { state = { ...state, items: [...state.items, item] }; },
     patchItem: () => {},
     replaceItems: (x) => x,
     pushNotice: () => {},
-    pushUserOrSyntheticItem: (text) => { executed.push(text); },
-    autoClearState: () => ({ enabled: false }),
+    pushUserOrSyntheticItem: (text, id) => {
+      executed.push(text);
+      state = { ...state, items: [...state.items, { kind: 'user', id, text }] };
+    },
+    autoClearState: () => ({ enabled: autoClearEnabled, idleMs: 0, minContextPercent: 0 }),
     agentStatusState: () => ({}),
     routeState: () => ({}),
     syncContextStats: () => {},
@@ -44,7 +74,10 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
     requeueEntriesFront: () => {},
     resetStatsAndSyncContext: () => {},
     flushDeferredExecutionPendingResumeKick: () => {},
-    runTurn: async () => 'ok',
+    runTurn: async (text) => {
+      await bag.runtime.ask(text);
+      return 'ok';
+    },
   };
   Object.assign(bag, createSessionFlow(bag));
   if (autoClearBeforeSubmit) bag.autoClearBeforeSubmit = autoClearBeforeSubmit;
@@ -53,6 +86,14 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
     api,
     bag,
     getExecuted: () => executed,
+    getProviderRequests: () => providerRequests,
+    waitForProviderDispatch: (timeoutMs = 250) => new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`provider dispatch timed out after ${timeoutMs}ms`)), timeoutMs);
+      providerDispatch.then((text) => {
+        clearTimeout(timer);
+        resolve(text);
+      }, reject);
+    }),
     getState: () => bag.getState(),
     mutateState: (mutator) => { mutator(state); },
   };
@@ -107,6 +148,57 @@ test('submit still enqueues when autoClearBeforeSubmit rejects', async () => {
   assert.deepEqual(getExecuted(), ['survives rejection'], 'rejected auto-clear must not lose the prompt');
 });
 
+test('runtime clear false skips auto-clear and sends the first post-failure prompt to the provider', async () => {
+  const {
+    api, bag, getExecuted, getProviderRequests, getState,
+  } = makeEngine({ autoClearEnabled: true, runtimeClear: async () => false });
+
+  assert.equal(api.submit('first after failed auto-clear'), true);
+  await tick(); await tick();
+
+  assert.deepEqual(getExecuted(), ['first after failed auto-clear'], 'user card remains visible');
+  assert.deepEqual(getProviderRequests(), ['first after failed auto-clear'], 'first post-failure input reaches provider');
+  assert.equal(getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
+  assert.equal(getState().items.some((item) => item.label === 'Auto-clear complete'), false);
+  assert.equal(getState().items.some((item) => item.id === 'existing'), true, 'failed clear preserves the existing session UI');
+  assert.equal(bag.runtime.session.messages[0].content, 'existing prompt', 'failed clear preserves the runtime session');
+});
+
+test('late runtime clear false keeps the UI skipped and sends the first post-timeout prompt', async () => {
+  let resolveClear;
+  let harness;
+  const autoClearBeforeSubmit = () => harness.bag.performSessionClear({
+    verb: 'Auto-clearing idle conversation',
+    doneLabel: 'Auto-clear complete',
+    skipLabel: 'Auto-clear skipped',
+    surface: 'auto-clear',
+    useCompaction: true,
+    compactTimeoutMs: 5,
+  });
+  harness = makeEngine({
+    autoClearBeforeSubmit,
+    runtimeClear: () => new Promise((resolve) => { resolveClear = resolve; }),
+  });
+  harness.bag.runtime.getCompactionSettings = () => ({ compactType: 'summary' });
+
+  assert.equal(harness.api.submit('first after timed-out auto-clear'), true);
+  await harness.waitForProviderDispatch();
+  assert.equal(typeof resolveClear, 'function', 'compacting clear started');
+  assert.deepEqual(
+    harness.getProviderRequests(),
+    ['first after timed-out auto-clear'],
+    'first post-timeout input reaches provider before late clear settles',
+  );
+
+  resolveClear(false);
+  await tick(); await tick();
+
+  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
+  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear complete'), false);
+  assert.equal(harness.getState().items.some((item) => item.id === 'existing'), true, 'late false preserves the existing session UI');
+  assert.equal(harness.bag.runtime.session.messages[0].content, 'existing prompt', 'late false preserves the runtime session');
+});
+
 test('empty and whitespace submits are still rejected', () => {
   const { api, bag } = makeEngine();
   assert.equal(api.submit('   '), false);

package/scripts/tui-transcript-perf-test.mjs

@@ -8,7 +8,7 @@ import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-wi
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-function makeTurnHarness(ask) {
+function makeTurnHarness(ask, stateOverrides = {}) {
   let seq = 0;
   let state = {
     items: [],
@@ -18,6 +18,7 @@ function makeTurnHarness(ask) {
     busy: false,
     spinner: null,
     thinking: null,
+    ...stateOverrides,
   };
   const itemIndexById = new Map();
   const set = (patch) => { state = { ...state, ...patch }; return true; };
@@ -43,6 +44,15 @@ function makeTurnHarness(ask) {
   const clearStreamingTail = (id = null) => {
     if (id == null || state.streamingTail?.id === id) set({ streamingTail: null });
   };
+  const replaceItems = (items, options = {}) => {
+    state = replaceEngineItemsState({
+      state,
+      items,
+      itemIndexById,
+      preserveStreamingTail: options.preserveStreamingTail === true,
+    });
+    return items;
+  };
   const bag = {
     runtime: { id: null, toolMode: 'auto', ask, abort: () => true },
     nextId: () => `id_${++seq}`,
@@ -55,6 +65,7 @@ function makeTurnHarness(ask) {
     set,
     pushItem,
     patchItem,
+    replaceItems,
     updateStreamingTail,
     settleStreamingTail,
     clearStreamingTail,
@@ -77,6 +88,50 @@ function makeTurnHarness(ask) {
   return { runTurn: createRunTurn(bag), getState: () => state };
 }
 
+test('successful mid-turn compact trims history but preserves live turn references', async () => {
+  let preservedTail = false;
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onTextDelta('before compact\n');
+    await wait(30);
+    options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    preservedTail = harness.getState().streamingTail?.text === 'before compact\n';
+    options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    options.onTextDelta('after compact\n');
+    return { result: { content: 'before compact\nafter compact\n' }, session: { messages: [] } };
+  }, {
+    items: [
+      { id: 'old', kind: 'assistant', text: 'old history' },
+      { id: 'current-user', kind: 'user', text: 'go' },
+    ],
+  });
+
+  assert.equal(await harness.runTurn('go', { submittedIds: ['current-user'] }), 'done');
+  assert.equal(preservedTail, true);
+  assert.equal(harness.getState().items.some((item) => item.id === 'old'), false);
+  assert.equal(harness.getState().items.some((item) => item.id === 'current-user'), true);
+  assert.equal(
+    harness.getState().items.filter((item) => item.label === 'Compact complete (overflow recovery)').length,
+    2,
+  );
+  assert.equal(
+    harness.getState().items.find((item) => item.kind === 'assistant')?.text,
+    'before compact\nafter compact\n',
+  );
+});
+
+test('failed mid-turn compact leaves prior transcript items untouched', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onCompactEvent({ status: 'failed' });
+    return { result: { content: '' }, session: { messages: [] } };
+  }, {
+    items: [{ id: 'old', kind: 'assistant', text: 'old history' }],
+  });
+
+  assert.equal(await harness.runTurn('go'), 'done');
+  assert.equal(harness.getState().items.some((item) => item.id === 'old'), true);
+  assert.equal(harness.getState().items.some((item) => item.label === 'Compact failed'), true);
+});
+
 test('stream flush keeps settled items identity and finalize appends one assistant', async () => {
   let identityStable = false;
   const harness = makeTurnHarness(async (_text, options) => {

package/src/agents/reviewer/AGENT.md

@@ -9,5 +9,13 @@ Independent regression/risk review agent.
 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.
+Treat implementer and Lead reports as claims to test rather than evidence;
+independently evaluate the final deliverable against the original request and
+available evidence with a critical lens, actively seeking errors, unsupported
+assumptions, and counterexamples before confirming.
 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/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());
     }

package/src/runtime/agent/orchestrator/internal-tools.mjs

@@ -15,7 +15,8 @@
  * no-tool role guard) — not a permission check. No gating is needed here.
  */
 
-import { isToolEnvelope, makeToolEnvelope } from './session/tool-envelope.mjs';
+import { isToolEnvelope, makeToolEnvelope, normalizeToolEnvelope } from './session/tool-envelope.mjs';
+import { classifyResultKind } from './session/result-classification.mjs';
 
 let _executor = null;
 let _tools = [];
@@ -62,12 +63,24 @@ function _normalize(result) {
     // JSON.stringify below and the loop would see the stringified envelope as
     // the tool_result (body inlined + duplicated, no newMessages).
     if (isToolEnvelope(result)) {
-        return makeToolEnvelope(_normalize(result.result), result.newMessages);
+        const normalized = normalizeToolEnvelope(_normalize(result.result));
+        return makeToolEnvelope(normalized.result, result.newMessages, {
+            explicitSuccess: normalized.explicitSuccess || result.explicitSuccess === true,
+        });
     }
     if (result && typeof result === 'object' && Array.isArray(result.content)) {
-        return result.content
+        const text = result.content
             .map((c) => (c?.type === 'text' ? c.text || '' : JSON.stringify(c)))
             .join('\n');
+        // Preserve MCP-style handler outcome metadata across the object→string
+        // boundary. Explicit failures retain the canonical Error: convention;
+        // explicit successes use a transient envelope so legitimate output
+        // beginning with Error: is not mistaken for a failed execution.
+        if (result.isError === true) return !text.startsWith('Error:') ? `Error: ${text}` : text;
+        if (result.isError === false && classifyResultKind(text) === 'error') {
+            return makeToolEnvelope(text, [], { explicitSuccess: true });
+        }
+        return text;
     }
     if (typeof result === 'string') return result;
     return JSON.stringify(result);

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -6,6 +6,8 @@ import { randomUUID } from 'crypto';
 import { smartReadTruncate } from '../tools/builtin/read-formatting.mjs';
 import { shutdownStdioChild, killStdioChildTreeFast } from './child-tree.mjs';
 import { readServicePort, markServiceUnreachable, isConnRefuseError } from '../../../shared/service-discovery.mjs';
+import { makeToolEnvelope, normalizeToolEnvelope } from '../session/tool-envelope.mjs';
+import { classifyResultKind } from '../session/result-classification.mjs';
 // --- Types ---
 /** Known auto-detect targets: port file path relative to tmpdir.
  *  Note: `mixdog` used to self-loopback via active-instance.json's
@@ -215,6 +217,16 @@ export async function executeMcpTool(name, args) {
             throw new Error(`Tool call failed: ${firstMsg}; retry after reconnect also failed: ${retryMsg}`);
         }
     }
+    const normalized = normalizeToolEnvelope(normalizeMcpToolResult(result));
+    const text = capMcpOutput(normalized.result);
+    return normalized.explicitSuccess
+        ? makeToolEnvelope(text, [], { explicitSuccess: true })
+        : text;
+}
+
+// Preserve MCP failure metadata across the object→string boundary. The
+// session loop classifies the canonical Error: prefix as toolKind:error.
+export function normalizeMcpToolResult(result) {
     const content = result.content;
     let text;
     if (Array.isArray(content)) {
@@ -224,7 +236,11 @@ export async function executeMcpTool(name, args) {
     } else {
         text = typeof content === 'string' ? content : JSON.stringify(content);
     }
-    return capMcpOutput(text);
+    if (result.isError === true) return !text.startsWith('Error:') ? `Error: ${text}` : text;
+    if (result.isError === false && classifyResultKind(text) === 'error') {
+        return makeToolEnvelope(text, [], { explicitSuccess: true });
+    }
+    return text;
 }
 
 // MCP per-tool-call timeout. Default 2min: a hung/unresponsive MCP server