mixdog 0.9.37 → 0.9.39

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,
@@ -424,6 +425,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();
@@ -524,6 +583,7 @@ export async function createEngineSession({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,
@@ -537,6 +597,7 @@ export async function createEngineSession({
     enqueue: (...args) => bag.enqueue(...args),
     drain: (...args) => bag.drain(...args),
     pushUserOrSyntheticItem,
+    pushAsyncAgentResponse,
     makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
     getPending: () => pending,
     agentStatusState,
@@ -574,12 +635,12 @@ export async function createEngineSession({
     flags, lifecycle, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, listeners, itemIndexById,
     getState: () => state, set,
     pushItem, patchItem, replaceItems, pushToast, pushNotice, removeNotice, setProgressHint,
-    pushUserOrSyntheticItem, upsertSyntheticToolItem,
+    pushUserOrSyntheticItem, pushAsyncAgentResponse, upsertSyntheticToolItem,
     markToolCallActive, markToolCallDone, clearActiveToolSummary, clearToastTimers,
     autoClearState, agentStatusState, baseRouteState, routeState, syncContextStats,
     presentNextToolApproval, finishToolApproval, denyAllToolApprovals, requestToolApproval,
     patchToolCardResult, flushToolResults,
-    kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, updateAgentJobCard, subscribeRuntimeNotifications,
+    kickExecutionPendingResume, flushDeferredExecutionPendingResumeKick, scheduleExecutionPendingResumeKick, discardExecutionPendingResume, updateAgentJobCard, subscribeRuntimeNotifications,
   });
   Object.assign(bag, createSessionFlow(bag));
   bag.runTurn = createRunTurn(bag);

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.