mixdog 0.9.39 → 0.9.41

package/src/tui/engine.mjs

@@ -142,6 +142,87 @@ export { parseBackgroundTaskEnvelope };
 // so importers/tests keep resolving resolveTuiRuntimeNotificationDelivery from engine.mjs.
 export { resolveTuiRuntimeNotificationDelivery };
 
+export function replaceEngineItemsState({
+  state,
+  items,
+  itemIndexById,
+  preserveStreamingTail = false,
+  extra = {},
+}) {
+  const nextItems = Array.isArray(items) ? items : [];
+  itemIndexById.clear();
+  for (let i = 0; i < nextItems.length; i++) {
+    const id = nextItems[i]?.id;
+    if (id != null) itemIndexById.set(id, i);
+  }
+  return {
+    ...state,
+    ...extra,
+    items: nextItems,
+    structureRevision: (Number(state.structureRevision) || 0) + 1,
+    streamingTail: preserveStreamingTail ? state.streamingTail : null,
+  };
+}
+
+// Shared by the live engine and focused transcript tests so revision/tail
+// regressions exercise the exact mutation implementation used in production.
+export function createEngineItemMutators({ getState, set, itemIndexById }) {
+  const patchItem = (id, patch) => {
+    const state = getState();
+    let index = itemIndexById.get(id);
+    if (!Number.isInteger(index) || state.items[index]?.id !== id) {
+      index = state.items.findIndex((it) => it.id === id);
+      if (index >= 0) itemIndexById.set(id, index);
+    }
+    if (index < 0) return false;
+    const current = state.items[index];
+    let changed = false;
+    for (const [key, value] of Object.entries(patch || {})) {
+      if (!Object.is(current[key], value)) {
+        changed = true;
+        break;
+      }
+    }
+    if (!changed) return false;
+    const items = state.items.slice();
+    items[index] = { ...current, ...patch };
+    set({ items, structureRevision: (Number(state.structureRevision) || 0) + 1 });
+    return true;
+  };
+
+  const settleStreamingTail = (id, patch = {}, extra = {}) => {
+    const state = getState();
+    const tail = state.streamingTail?.id === id ? state.streamingTail : null;
+    // Bulk transcript replacement/reset owns the new transcript. A stale turn
+    // must never append into it after replaceItems deliberately cleared its tail.
+    if (!tail) return false;
+    let existingIndex = itemIndexById.get(id);
+    if (!Number.isInteger(existingIndex) || state.items[existingIndex]?.id !== id) {
+      existingIndex = state.items.findIndex((item) => item?.id === id);
+    }
+    if (existingIndex >= 0) return false;
+    const item = {
+      ...(tail || {}),
+      ...patch,
+      kind: 'assistant',
+      id,
+      streaming: false,
+    };
+    const index = state.items.length;
+    const items = [...state.items, item];
+    itemIndexById.set(id, index);
+    set({
+      items,
+      structureRevision: (Number(state.structureRevision) || 0) + 1,
+      streamingTail: null,
+      ...extra,
+    });
+    return true;
+  };
+
+  return { patchItem, settleStreamingTail };
+}
+
 export async function createEngineSession({
   provider: providerName,
   model,
@@ -205,6 +286,8 @@ export async function createEngineSession({
   };
   let state = {
     items: [],
+    structureRevision: 0,
+    streamingTail: null,
     toasts: [],
     progressHint: null,
     busy: false,
@@ -283,13 +366,8 @@ export async function createEngineSession({
   };
 
   const itemIndexById = new Map();
-  const replaceItems = (items) => {
+  const replaceItems = (items, { preserveStreamingTail = false } = {}) => {
     const nextItems = Array.isArray(items) ? items : [];
-    itemIndexById.clear();
-    for (let i = 0; i < nextItems.length; i++) {
-      const id = nextItems[i]?.id;
-      if (id != null) itemIndexById.set(id, i);
-    }
     // Bulk item swap (session load / clear / compact). Derive the prompt-history
     // list from the NEW items and stage it onto state here so App never rescans;
     // the callers that invoke replaceItems always follow with a set({items:...,
@@ -297,12 +375,21 @@ export async function createEngineSession({
     // emit (the accompanying set() diffs the full patch). A bulk swap also
     // discards the old transcript, so drop any tracked active tool calls.
     activeToolCalls.clear();
-    state = {
-      ...state,
+    state = replaceEngineItemsState({
+      state,
       items: nextItems,
-      promptHistoryList: buildMergedPromptHistory(recomputePromptHistory(nextItems), loadPromptHistory(state.cwd)),
-      activeToolSummary: null,
-    };
+      itemIndexById,
+      preserveStreamingTail,
+      extra: {
+        promptHistoryList: buildMergedPromptHistory(recomputePromptHistory(nextItems), loadPromptHistory(state.cwd)),
+        activeToolSummary: null,
+      },
+    });
+    // replaceItems stages the bulk state before its callers compose their
+    // accompanying patch. Emit here as well so an items-only replacement
+    // (for example removeNotice) cannot be hidden by the outer set seeing the
+    // already-installed array identity.
+    emit();
     return nextItems;
   };
   // --- Prompt-history list (newest-first, deduped) maintained incrementally ---
@@ -371,11 +458,39 @@ export async function createEngineSession({
       // first — set() diffs against the current state, so a pre-assign would make
       // the references identical and skip emit().
       const promptHistoryList = buildMergedPromptHistory(recomputePromptHistory(items), loadPromptHistory(state.cwd));
-      set({ items, promptHistoryList });
+      set({ items, structureRevision: state.structureRevision + 1, promptHistoryList });
     } else {
-      set({ items });
+      set({ items, structureRevision: state.structureRevision + 1 });
+    }
+  };
+  const updateStreamingTail = (id, patch = {}, extra = {}) => {
+    if (id == null) return false;
+    const current = state.streamingTail?.id === id
+      ? state.streamingTail
+      : { kind: 'assistant', id, text: '', streaming: true };
+    const next = { ...current, ...patch, kind: 'assistant', id, streaming: true };
+    let changed = state.streamingTail !== current;
+    if (!changed) {
+      for (const [key, value] of Object.entries(next)) {
+        if (!Object.is(current[key], value)) {
+          changed = true;
+          break;
+        }
+      }
+    }
+    return set(changed ? { streamingTail: next, ...extra } : extra);
+  };
+  const clearStreamingTail = (id = null, extra = {}) => {
+    if (!state.streamingTail || (id != null && state.streamingTail.id !== id)) {
+      return set(extra);
     }
+    return set({ streamingTail: null, ...extra });
   };
+  const { patchItem, settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
   const upsertSyntheticToolItem = (text, id = nextId(), parsed = null) => {
     const synthetic = parseSyntheticAgentMessage(text);
     if (!synthetic) return false;
@@ -513,7 +628,7 @@ export async function createEngineSession({
     if (id == null) return false;
     const items = state.items.filter((it) => !(it?.kind === 'notice' && it?.id === id));
     if (items.length === state.items.length) return false;
-    set({ items: replaceItems(items) });
+    set({ items: replaceItems(items, { preserveStreamingTail: true }) });
     return true;
   };
   // Sticky (non-TTL) input-hint-line progress state, for long-running
@@ -538,27 +653,6 @@ export async function createEngineSession({
     getDisposed: () => flags.disposed,
     timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
   });
-  const patchItem = (id, patch) => {
-    let index = itemIndexById.get(id);
-    if (!Number.isInteger(index) || state.items[index]?.id !== id) {
-      index = state.items.findIndex((it) => it.id === id);
-      if (index >= 0) itemIndexById.set(id, index);
-    }
-    if (index < 0) return false;
-    const current = state.items[index];
-    let changed = false;
-    for (const [key, value] of Object.entries(patch || {})) {
-      if (!Object.is(current[key], value)) {
-        changed = true;
-        break;
-      }
-    }
-    if (!changed) return false;
-    const items = state.items.slice();
-    items[index] = { ...current, ...patch };
-    set({ items });
-    return true;
-  };
   const toastTimers = new Set();
   lifecycle.runtimePulseTimer = setInterval(() => {
     if (flags.disposed) return;
@@ -587,6 +681,7 @@ export async function createEngineSession({
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,
+    clearExecutionDedupState,
   } = createAgentJobFeed({
     runtime,
     getState: () => state,
@@ -603,6 +698,7 @@ export async function createEngineSession({
     agentStatusState,
     displayedExecutionNotificationKeys,
     pushNotice,
+    itemIndexById,
   });
   lifecycle.unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
 
@@ -627,19 +723,22 @@ export async function createEngineSession({
     updateAgentJobCard,
     buildAgentJobCardPatch,
     agentStatusState,
+    itemIndexById,
   });
 
 
   Object.assign(bag, {
     runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS,
-    flags, lifecycle, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, listeners, itemIndexById,
+    flags, lifecycle, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, listeners, itemIndexById,
     getState: () => state, set,
-    pushItem, patchItem, replaceItems, pushToast, pushNotice, removeNotice, setProgressHint,
+    pushItem, patchItem, replaceItems, updateStreamingTail, settleStreamingTail, clearStreamingTail,
+    pushToast, pushNotice, removeNotice, setProgressHint,
     pushUserOrSyntheticItem, pushAsyncAgentResponse, upsertSyntheticToolItem,
     markToolCallActive, markToolCallDone, clearActiveToolSummary, clearToastTimers,
     autoClearState, agentStatusState, baseRouteState, routeState, syncContextStats,
     presentNextToolApproval, finishToolApproval, denyAllToolApprovals, requestToolApproval,
     patchToolCardResult, flushToolResults,
+    clearExecutionDedupState,
     kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, discardExecutionPendingResume, updateAgentJobCard, subscribeRuntimeNotifications,
   });
   Object.assign(bag, createSessionFlow(bag));

package/src/tui/index.jsx

@@ -281,7 +281,7 @@ function paintBootSplash() {
     const rows = Math.max(1, Number(process.stdout.rows) || 24);
     const windowsLikeTerminal = process.platform === 'win32' || Boolean(process.env.WT_SESSION);
     const frameCols = Math.max(1, cols - (windowsLikeTerminal ? 1 : 0));
-    const center = (s) => `${' '.repeat(Math.max(0, Math.floor((frameCols - displayWidth(s)) / 2)))}${s}`;
+    const center = (s, reserve = 0) => `${' '.repeat(Math.max(0, Math.floor((frameCols - reserve - displayWidth(s)) / 2)))}${s}`;
     const logo = [
       '███╗   ███╗██╗██╗  ██╗██████╗  ██████╗  ██████╗ ',
       '████╗ ████║██║╚██╗██╔╝██╔══██╗██╔═══██╗██╔════╝ ',
@@ -300,7 +300,7 @@ function paintBootSplash() {
       out += `${bold}${fg}${center(logo[i])}${reset}\r\n`;
     }
     out += '\r\n';
-    out += `${subtleFg}${center(`mixdog coding agent · v${localPackageVersion()} · ${process.cwd()}`)}${reset}`;
+    out += `${subtleFg}${center(`mixdog coding agent · v${localPackageVersion()} · ${process.cwd()}`, 4)}${reset}`;
 
     // Park the cursor at home so ink's first frame paints top-down over the
     // splash instead of starting at the bottom row and scrolling the screen.

package/src/workflows/bench/WORKFLOW.md

@@ -1,36 +1,60 @@
 ---
 id: bench
 name: Bench
-description: "Autonomous benchmark workflow — loop to completion without user approval."
+description: "Autonomous headless benchmark workflow with directed execution and parallel cross-verification."
 hidden: true
 agents: worker, heavy-worker, reviewer, debugger, maintainer
 ---
 
 # Bench
 
-Autonomous: no user. Never wait for approval or ask questions; decide/proceed.
-Loop until verified complete or provably blocked.
-
-Lead supervises, delegates, coordinates, judges, decides. Lead directly handles
-simple 1–2-step work, coordination, pre-planning, config, final git deployment.
-Worker: several-step implementation; Heavy Worker: high-complexity multi-step
-implementation; Reviewer: implementation diff/regression/missing-check review;
-Debugger: very high complexity or root cause already failed once.
-
-1. Plan: form it and execute immediately; no approval step.
-2. Delegate: split to the maximum independent scopes. Parallelize independent
-   implementation/analysis/review/debugging, spawning every scope in one turn.
-   Shared/cross-cutting code does not justify merging: split by path and verify
-   shared parts yourself. A single scope needs a genuinely inseparable
-   dependency; state it. Within one complex scope, sequence steps with a
-   build/test-green gate between them. Briefs follow the Lead brief contract.
-   After async spawn, end turn: no polling, guessing, or dependent work until
-   completion notification.
-3. Review: one Reviewer per implementation scope, spawned 1:1 in the same turn,
-   never deferred/batched; wait. Fact-check agent responses and cross-check
-   implementation/review yourself before acting. Return fixes to the original
-   scope; loop verify -> fix -> re-verify until clean. Skip only simple,
-   low-risk review. If a bug survives 2+ fix cycles, Debugger investigates
-   before another fix round.
-4. Finish: verify final state yourself; stop only verified complete or hard
-   blocked. Final states outcome and evidence.
+Autonomous headless run: no user exists. Never ask questions, propose plans
+for approval, or end the turn waiting — decide and proceed. Standing
+pre-approval covers every action: edits, state mutation, delegation, builds.
+Loop until the task is verified complete or provably blocked.
+
+The pipeline has exactly three stages. Lead directs and verifies it, but NEVER
+executes the work itself: no edits, answers, or artifact generation, regardless
+of task size, perceived simplicity, or number of steps.
+
+## 1. Lead analysis and direction
+Lead performs real analysis first on EVERY task: task structure, required
+deliverables, boundaries, the task's own verification means, and solution
+direction. Convert it into clear execution direction and delegation briefs
+following the Lead brief contract.
+
+Hand the direction and briefs to executors. Analysis is not permission for
+Lead to implement any portion of the result: all edits, answer production, and
+artifact generation belong to executor sessions.
+
+## 2. Executors perform the work
+Use Worker sessions, or Heavy Worker sessions for broad scopes, to execute the
+directed work. Multiple workers MAY fan out in parallel, one per independent
+scope. Keep ownership clear for each assigned deliverable.
+
+Executors build the answer or artifact and perform basic does-it-run checks.
+They are not a verification role and do not own acceptance, requirements
+judgment, or final correctness. Each executor reports its result to Lead.
+
+## 3. Lead and Reviewer verify
+
+When executors report, Lead and Reviewer start cross-verification IN PARALLEL,
+never serially. Lead personally runs the task's own verification means, such
+as its test suite, grader script, simulator, or self-checkable output.
+Reviewer independently judges the result against every task requirement,
+including intent, correctness, boundaries, and deliverables.
+
+Judgment-type answers with no direct ground truth still require parallel
+cross-verification, even for a single small deliverable. Lead evaluates against
+available criteria while Reviewer independently judges requirements;
+perceived simplicity is no exemption.
+
+Merge any finding into a clear fix delta and return it to the SAME executor
+session owning the affected scope. The executor applies it and reports again.
+Lead and Reviewer repeat the same parallel cross-verification until both legs
+are clean; Lead never fixes or completes the work directly.
+
+Before declaring completion, Lead personally runs the task-required
+verification one final time and checks that every deliverable is present.
+Never end with a question, approval request, or proposed next step. Continue
+until verified complete or stop only when completion is provably blocked.

package/src/workflows/default/WORKFLOW.md

@@ -13,33 +13,38 @@ Approval is a later explicit user message after the latest plan ("do it",
 approval with a scope change needs a revised plan and fresh approval. Before
 approval: no edits, state mutation, or delegation.
 
-Lead supervises, delegates, coordinates, judges, decides. After approval,
-delegate by default; Lead only coordinates, does git, or an obvious 1-edit/
-1-check change. Route other implementation/research/debugging to its matching
-agent. Worker: bounded established path, low local risk/coupling/verification,
-clear local check. Heavy Worker: high risk/coupling/verification (including any
-high-risk scope), or coupled staged work needing coordinated verification.
-Architecture, contracts, storage, concurrency, security, lifecycle are
-indicators, not automatic categories. Reviewer verifies an implementation;
-Debugger handles requested debugging or root cause after a failed fix.
+Lead orchestrates and verifies. Lead-direct work is allowed only for pure
+read/analysis, git/configuration, or when the user explicitly supplies both the
+exact target and exact replacement/output. Never infer an exemption from a task
+name, file count, or perceived difficulty. Every other implementation, reverse
+engineering, debugging application, or artifact generation delegates to the
+matching agent. Debugger owns diagnosis and reverse engineering; Worker applies
+an established bounded change or fully specified artifact; Heavy Worker owns
+implementation that must establish the change through investigation or staged
+delivery. Applying a Debugger result is implementation, not diagnosis.
 
 1. Plan: draft before any implementation; settle scope/plan, ask if ambiguous,
    then await the gate.
-2. Delegate: maximize useful fan-out—one suitable Worker/Heavy Worker per ready
-   independent scope whose parallel gain exceeds coordination/merge cost; spawn
-   all in one turn, with no count cap. Serialize only a real dependency,
-   overlapping write, or inseparable coupling. Briefs follow the Lead brief
-   contract. After async spawn, end the turn.
-3. Review: after approval, complete delegation, review, self-verification, and
-   in-scope fixes without reapproval. Every delegated implementation gets one
-   Reviewer (all ready reviewers in one turn) and Lead integration/cross-scope
-   verification in parallel. Reviewer independently judges risk, intent,
-   boundaries; Lead checks acceptance/interactions, not duplicate same-scope
-   work. High-risk scopes add distinct lenses. Synthesize one verdict; send
-   merged fixes to the original live session; loop fix -> re-verify (same
-   Reviewer + Lead re-check) until clean. Debugger first for requested debugging
-   or a bug surviving 2+ fix cycles. Agent reports relay scope, verdict, next
-   work as in-progress, never conclusions.
+2. Delegate: one agent per ready independent scope; spawn all ready scopes in
+   one turn, with no count cap. Serialize only a real dependency, overlapping
+   write, or inseparable coupling. Briefs follow the Lead brief contract.
+   After async spawn, end the turn.
+3. Review: review is exempt only for pure read/analysis with no edit, artifact,
+   or state mutation; git/configuration; or a request where the user explicitly
+   supplies both the exact target and exact replacement/output. Every
+   non-exempt mutation or artifact, whether produced or applied by Worker,
+   Heavy Worker, Debugger, or Lead, gets one Reviewer (all ready reviewers in
+   one turn) and Lead
+   integration/cross-scope verification in parallel. Debugger analysis cannot
+   substitute for implementation review: applying a Debugger result triggers
+   the same Reviewer + Lead verification. Reviewer independently judges risk,
+   intent, boundaries; Lead checks acceptance/interactions, not duplicate
+   same-scope work. High-risk scopes add distinct lenses. Synthesize one
+   verdict; send merged fixes to the original live session; loop fix ->
+   re-verify (same Reviewer + Lead re-check) until clean. Debugger first for
+   requested debugging or a bug surviving 2+ fix cycles. Exempt mutations still
+   require shell self-verification before report. Agent reports relay scope,
+   verdict, next work as in-progress, never conclusions.
 4. Report: final (not interim) report compares work to approved plan and gives
    verified result; never forward raw agent output. Ask about ship/deploy when
    relevant. Build/deploy/commit/push require an explicit user request after