mixdog 0.9.38 → 0.9.40

package/src/tui/engine.mjs

@@ -81,6 +81,7 @@ import {
 import { createToolApproval } from './engine/tool-approval.mjs';
 import { createToolCardResults } from './engine/tool-card-results.mjs';
 import { createAgentJobFeed } from './engine/agent-job-feed.mjs';
+import { appendAgentResponseTail } from './engine/agent-response-tail.mjs';
 import {
   appendTuiSteeringPersist,
   dropTuiSteeringPersist,
@@ -141,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,
@@ -204,6 +286,8 @@ export async function createEngineSession({
   };
   let state = {
     items: [],
+    structureRevision: 0,
+    streamingTail: null,
     toasts: [],
     progressHint: null,
     busy: false,
@@ -282,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:...,
@@ -296,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 ---
@@ -370,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;
@@ -424,6 +540,64 @@ export async function createEngineSession({
     if (origin === 'user') appendPromptHistory(state.cwd, text);
     pushItem({ kind: 'user', id, text });
   };
+  const pushAsyncAgentResponse = (text, id = nextId(), origin = 'injected', metadata = {}) => {
+    const synthetic = parseSyntheticAgentMessage(text);
+    const isAgent = synthetic?.name === 'agent';
+    if (!isAgent) return pushUserOrSyntheticItem(text, id, origin);
+    const responseHasBody = /\n\s*\n[\s\S]*\S/.test(String(text || ''));
+    const rawResult = synthetic.rawResult ?? text;
+    const args = {
+      ...(synthetic.args && typeof synthetic.args === 'object' ? synthetic.args : {}),
+      type: 'result',
+    };
+    const responseKey = String(metadata.responseKey || metadata.executionId || args.task_id || '').trim();
+    const previous = state.items.at(-1);
+    // Tail-only aggregation prevents a later completion from mutating a card
+    // above any outbound tool, assistant, user, or preview/body boundary.
+    if (
+      previous?.kind === 'tool'
+      && previous.agentDirection === 'inbound'
+    ) {
+      const patch = appendAgentResponseTail(previous, {
+        key: responseKey,
+        args,
+        result: synthetic.result,
+        rawResult,
+        hasBody: responseHasBody,
+        isError: synthetic.isError === true,
+      });
+      if (patch) {
+        patchItem(previous.id, patch);
+        return true;
+      }
+    }
+    pushItem({
+      kind: 'tool',
+      id,
+      name: 'agent',
+      args,
+      result: synthetic.result,
+      rawResult,
+      isError: synthetic.isError === true,
+      expanded: false,
+      count: 1,
+      completedCount: 1,
+      startedAt: Date.now(),
+      completedAt: Date.now(),
+      agentDirection: 'inbound',
+      agentResponseKey: responseKey,
+      agentResponseHasBody: responseHasBody,
+      agentResponseAggregate: false,
+      agentResponseEntries: [{
+        key: responseKey,
+        raw: String(rawResult ?? '').trim(),
+        result: synthetic.result,
+        hasBody: responseHasBody,
+        isError: synthetic.isError === true,
+      }],
+    });
+    return true;
+  };
   const pushToast = (text, tone = 'info', ttlMs = 3000) => {
     const id = nextId();
     const value = String(text ?? '').trim();
@@ -454,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
@@ -479,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;
@@ -524,9 +677,11 @@ export async function createEngineSession({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,
+    clearExecutionDedupState,
   } = createAgentJobFeed({
     runtime,
     getState: () => state,
@@ -537,11 +692,13 @@ export async function createEngineSession({
     enqueue: (...args) => bag.enqueue(...args),
     drain: (...args) => bag.drain(...args),
     pushUserOrSyntheticItem,
+    pushAsyncAgentResponse,
     makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
     getPending: () => pending,
     agentStatusState,
     displayedExecutionNotificationKeys,
     pushNotice,
+    itemIndexById,
   });
   lifecycle.unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
 
@@ -566,20 +723,23 @@ 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,
-    pushUserOrSyntheticItem, upsertSyntheticToolItem,
+    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,
-    kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, updateAgentJobCard, subscribeRuntimeNotifications,
+    clearExecutionDedupState,
+    kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, discardExecutionPendingResume, updateAgentJobCard, subscribeRuntimeNotifications,
   });
   Object.assign(bag, createSessionFlow(bag));
   bag.runTurn = createRunTurn(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

@@ -6,41 +6,31 @@ hidden: true
 agents: worker, heavy-worker, reviewer, debugger, maintainer
 ---
 
-# Bench Workflow
+# Bench
 
-Autonomous run: no user is present. Never wait for approval or ask
-questions — decide and proceed immediately. Loop until the task is verified
-complete or provably blocked.
+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. Route by complexity:
-- Lead directly: simple 1–2 step work, plus coordination, pre-planning, config
-  changes, and final git deployment.
-- Worker: implementation that takes several steps. Heavy Worker:
-  high-complexity, multi-step implementation.
-- Reviewer: verify implementation scopes (diff, regressions, missing checks).
-- Debugger: very high complexity, or when root-causing has already failed at
-  least once.
+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 the plan yourself and start executing immediately; no approval
-   step exists.
-2. Delegate — split into the maximum number of independent scopes.
-   - PARALLEL across independent scopes by default (implementation, analysis,
-     review, debugging alike); spawn every scope in the SAME turn. Shared or
-     cross-cutting code does NOT justify merging — split per path and verify
-     the shared parts yourself. The only single scope is a genuinely
-     inseparable dependency; then state it.
-   - SEQUENTIAL within a single complex scope: ordered steps with a
-     build/test-green gate between them, not one shot.
-   - Write briefs per the Lead brief contract.
-   - After spawning async agents, END THE TURN — no polling, guessing, or
-     dependent work until the completion notification resumes you.
-3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
-   same turn, never deferred or batched; wait for its result. Fact-check agent
-   responses and cross-check implementation and review results yourself before
-   acting. Send fixes back to the original scope and loop verify -> fix ->
-   re-verify until clean. Skip review only for simple, low-risk tasks. If a bug
-   survives 2+ fix cycles, have the debugger investigate first instead of
-   another fix round.
-4. Finish — verify the final state yourself; only stop when the task is
-   complete and verified, or a hard blocker makes progress impossible. State
-   the outcome and evidence in the final message.
+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.

package/src/workflows/default/WORKFLOW.md

@@ -5,39 +5,45 @@ description: "Default agent workflow — fan-out parallel delegation across inde
 agents: worker, heavy-worker, reviewer, debugger, maintainer
 ---
 
-# Default Workflow
+# Default
 
-HARD APPROVAL GATE — investigation/planning may proceed only as read-only
-exploration while consulting with the user. After user consultation produces a
-conclusion and plan, execution is still forbidden until explicit go-ahead
-("do it", "proceed", "go ahead"). Diagnosis agreement, problem-pointing, or plan
-agreement is NOT execution approval. No changes, state mutations, or delegation
-before explicit go-ahead.
+GATE: Before approval, only read-only investigation/planning while consulting.
+Approval is a later explicit user message after the latest plan ("do it",
+"proceed", "go ahead"). Initial/additional/changed requests reset planning;
+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 route by
-complexity: Lead directly only one-step single-turn fixes plus coordination,
-config, and git deployment; everything else delegates. Worker = multi-step or
-multi-file implementation; Heavy Worker = high-complexity scopes; Reviewer =
-implementation verification; Debugger = very high complexity or root-cause
-after a failed fix.
+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.
 
-1. Plan — present a draft before ANY implementation; revise/re-present until
-   user consultation is complete and a conclusion/plan is agreed. Then wait for
-   explicit go-ahead before executing. If ambiguous, restate the plan and ask.
-2. Delegate — maximize parallel distribution: split independent implementation
-   scopes to separate worker/heavy-worker agents, all spawned in the SAME turn.
-   Sequential steps only inside one inseparable complex scope, gated
-   build/test-green; say when a scope is inseparable. Briefs follow Lead brief
-   contract. After spawning async agents, END THE TURN.
-3. Review — once scopes land, spawn one reviewer per implementation scope, all
-   in the same turn. Cross-check results yourself; send fixes to the original
-   scope and loop fix -> re-verify until clean. Skip only simple low-risk work.
-   Use Debugger first when asked for debugging or a bug survives 2+ fix cycles.
-   On each agent report, relay scope+verdict and next work as in-progress,
-   never as a conclusion.
-4. Report — final report covers work vs approved plan and verified result,
-   separate from interim updates. Never forward raw agent output. Ask about
-   ship/deploy when relevant; deploy/build/commit only on explicit user request
-   after feedback with no issues.
+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.
+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
+   issue-free feedback; implementation approval alone is insufficient.
 
-On major direction shifts mid-work, pause and re-consult the user.
+On outcome/direction change, pause and re-consult; otherwise continue approved
+work without reapproval.

package/src/workflows/solo/WORKFLOW.md

@@ -1,31 +1,28 @@
 ---
 id: solo
 name: Solo
-description: "Solo workflow — Lead handles everything directly; delegation forbidden."
+description: "Solo workflow — Lead handles everything directly."
 agents:
 ---
 
-# Solo Workflow
+# Solo
 
-HARD APPROVAL GATE — investigation/planning may proceed only as read-only
-exploration while consulting with the user. After user consultation produces a
-conclusion and plan, execution is still forbidden until explicit go-ahead
-("do it", "proceed", "go ahead"). Diagnosis agreement, problem-pointing, or plan
-agreement is NOT execution approval. No changes or state mutations before
-explicit go-ahead.
+GATE: Before approval, only read-only investigation/planning while consulting.
+Approval is a later explicit user message after the latest plan ("do it",
+"proceed", "go ahead"). Initial/additional/changed requests reset planning;
+approval with a scope change needs a revised plan and fresh approval. Before
+approval: no edits or state mutation.
 
-1. Plan — present a draft before ANY implementation; revise/re-present until
-   user consultation is complete and a conclusion/plan is agreed. Then wait for
-   explicit go-ahead before executing. If ambiguous, restate the plan and ask.
-2. Execute — Lead does all work directly; delegation forbidden. Interim updates
-   are in-progress, never conclusions.
-3. Verify — check and fix directly until clean or a blocker is reported.
-4. Report — final report covers work vs approved plan, verification result, and
-   remaining risk/next step, distinct from interim updates. Deploy/build/commit
-   only after user feedback with no issues.
+1. Plan: draft before any implementation; settle scope/plan, ask if ambiguous,
+   then await the gate.
+2. Execute: after approval, Lead does all work. Never spawn, send, delegate, or
+   ask agents to work. Complete execution/in-scope fixes without reapproval;
+   interim updates are in-progress, never conclusions.
+3. Verify: Lead checks/fixes directly until clean or reports a blocker.
+4. Report: final (not interim) report compares work to approved plan and gives
+   verification, remaining risk/next step. Build/deploy/commit/push require an
+   explicit user request after issue-free feedback; implementation approval
+   alone is insufficient.
 
-On major direction shifts mid-work, pause and re-consult the user.
-
-Delegation rule:
-- Never delegate/spawn/send or ask agents to work; ignore available-agent
-  sections while this workflow is active.
+On outcome/direction change, pause and re-consult; otherwise continue approved
+work without reapproval.