mixdog 0.9.41 → 0.9.43

package/src/tui/engine/session-flow.mjs

@@ -2,13 +2,14 @@
  * src/tui/engine/session-flow.mjs - prompt queue drain + session clear/reset. Extracted from engine.mjs.
  */
 import { presentErrorText } from '../../runtime/shared/err-text.mjs';
+import { resetAllStreamingMarkdownStablePrefixes } from '../markdown/streaming-markdown.mjs';
 import { createSessionStats } from './session-stats.mjs';
 import { queuePriorityValue, defaultQueuePriority, isQueuedEntryEditable, isQueuedEntryVisible, isSlashQueuedEntry, notificationDisplayText, sessionActivityTimestamp, promptDisplayText, mergePromptContents, mergePastedImages, mergePastedTexts, callCommitCallbacks, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { appendTuiSteeringPersist, dropTuiSteeringPersist, drainTuiSteeringPersist } from './tui-steering-persist.mjs';
 
 export function createSessionFlow(bag) {
   const {
-    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
+    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, clearToastTimers, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
   } = bag;
 
   // Upper bound on the awaited compacting clear. requireCompactSuccess makes
@@ -382,7 +383,10 @@ export function createSessionFlow(bag) {
   // Shared clear body for idle auto-clear and the session_manage tool.
   // useCompaction=true mirrors auto-clear (summarize via configured
   // compactType, context carries forward); false is a plain /clear wipe.
-  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
+  async function performSessionClear({
+    verb, doneLabel, skipLabel, surface, useCompaction,
+    compactTimeoutMs = AUTO_CLEAR_COMPACT_TIMEOUT_MS,
+  }) {
     flags.autoClearRunning = true;
     const startedAt = Date.now();
     // commandBusy blocks concurrent session commands (resume/newSession/
@@ -401,6 +405,7 @@ export function createSessionFlow(bag) {
         const compaction = runtime.getCompactionSettings();
         compactType = compaction.compactType || compaction.type || null;
       }
+      let clearResult;
       if (compactType) {
         // Bounded watchdog around the compacting clear. On timeout we throw so
         // the catch below keeps the conversation, surfaces a user-visible
@@ -410,21 +415,22 @@ export function createSessionFlow(bag) {
         // new auto-clear attempts until the abandoned promise settles, and on
         // late fulfillment we run the same post-success UI sync as the normal
         // path so the UI cannot diverge from a runtime session that actually
-        // got cleared. Late rejection is a no-op.
+        // got cleared. Late rejection or a false result is a no-op.
         const clearPromise = runtime.clear({ compactType, requireCompactSuccess: true });
         let timer = null;
         const timeout = new Promise((_, reject) => {
           timer = setTimeout(
-            () => reject(new Error(`compaction timed out after ${AUTO_CLEAR_COMPACT_TIMEOUT_MS}ms; auto-clear deferred to next idle`)),
-            AUTO_CLEAR_COMPACT_TIMEOUT_MS,
+            () => reject(new Error(`compaction timed out after ${compactTimeoutMs}ms; auto-clear deferred to next idle`)),
+            compactTimeoutMs,
           );
         });
         try {
-          await Promise.race([clearPromise, timeout]);
+          clearResult = await Promise.race([clearPromise, timeout]);
         } catch (raceError) {
           flags.autoClearInFlight = true;
           clearPromise.then(
-            () => {
+            (lateResult) => {
+              if (lateResult === false) return;
               if (getState().busy) {
                 // A turn started after commandBusy released; applying the
                 // cleared-session UI now would wipe items/queued and force
@@ -446,7 +452,10 @@ export function createSessionFlow(bag) {
           if (timer) clearTimeout(timer);
         }
       } else {
-        await runtime.clear({});
+        clearResult = await runtime.clear({});
+      }
+      if (clearResult === false) {
+        throw new Error('runtime clear returned false');
       }
       applyClearedSessionUi(doneLabel);
       return true;
@@ -490,6 +499,8 @@ export function createSessionFlow(bag) {
     return getState().stats;
   };
   const clearUiActivityBeforeContextSync = () => {
+    clearToastTimers();
+    resetAllStreamingMarkdownStablePrefixes();
     getState().items = replaceItems([]);
     getState().toasts = [];
     getState().queued = [];

package/src/tui/engine/turn.mjs

@@ -12,7 +12,7 @@ import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, ass
 
 export function createRunTurn(bag) {
   const {
-    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS, flags, pending, itemIndexById, getState, set, pushItem, patchItem, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drain, drainPendingSteering,
+    runtime, nextId, tuiDebug, LEAD_TURN_TIMEOUT_MS, flags, pending, itemIndexById, getState, set, pushItem, patchItem, replaceItems, updateStreamingTail: updateStreamingTailFromStore, settleStreamingTail: settleStreamingTailFromStore, clearStreamingTail: clearStreamingTailFromStore, pushNotice, pushUserOrSyntheticItem, markToolCallActive, markToolCallDone, clearActiveToolSummary, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, requestToolApproval, patchToolCardResult, flushToolResults, flushDeferredExecutionPendingResumeKick, drain, drainPendingSteering,
   } = bag;
   // Small fallbacks keep isolated createRunTurn harnesses source-compatible;
   // the real engine supplies atomic implementations that also maintain revision.
@@ -209,7 +209,14 @@ export function createRunTurn(bag) {
     let cancelled = false;
     let askResult = null;
     let turnFinishedNormally = false;
+    let transcriptCompactedThisTurn = false;
     const itemsAtTurnStart = getState().items.length;
+    const submittedIdSet = new Set(submittedIds.filter((id) => id != null));
+    const firstSubmittedIndex = getState().items.findIndex((item) => submittedIdSet.has(item?.id));
+    // The submitted user row is pushed immediately before runTurn. Keep it and
+    // everything produced after it if compaction succeeds mid-turn; dropping all
+    // items would invalidate live tool-card ids and the streaming assistant tail.
+    let currentTurnItemsStart = firstSubmittedIndex >= 0 ? firstSubmittedIndex : itemsAtTurnStart;
     const cardByCallId = new Map();
     const toolCards = [];
     const toolGroups = new Map();
@@ -987,6 +994,13 @@ export function createRunTurn(bag) {
           // later same-category tool call doesn't reuse a card whose count
           // would then change above this statusdone item.
           clearAggregateContinuation();
+          const compactStatus = String(event?.status || '').toLowerCase();
+          if (!['failed', 'skipped', 'no_change'].includes(compactStatus)) {
+            const currentTurnItems = getState().items.slice(currentTurnItemsStart);
+            set({ items: replaceItems(currentTurnItems, { preserveStreamingTail: true }) });
+            currentTurnItemsStart = 0;
+            transcriptCompactedThisTurn = true;
+          }
           pushItem({
             kind: 'statusdone',
             id: nextId(),
@@ -1103,6 +1117,13 @@ export function createRunTurn(bag) {
       } else {
         askResult = result;
         markPromptCommitted();
+        if (result?.terminationReason === 'refusal') {
+          pushNotice(
+            '모델이 안전 분류기(refusal)로 응답을 거부했습니다 — 다시 시도하거나 문구를 바꿔주세요.',
+            'warn',
+            { transcript: true },
+          );
+        }
 
         flushToolResults(session?.messages || [], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true });
         finalizeToolHeaders();
@@ -1208,7 +1229,8 @@ export function createRunTurn(bag) {
           }
         }
         const producedTranscriptItem =
-          getState().items.length + closingItems.length > itemsAtTurnStart;
+          transcriptCompactedThisTurn
+          || getState().items.length + closingItems.length > itemsAtTurnStart;
         const reclaimed = cancelled && flags.activePromptRestore?.reclaimed === true;
         flags.activePromptRestore = null;
         const elapsedMs = Date.now() - startedAt;

package/src/tui/engine.mjs

@@ -738,7 +738,6 @@ export async function createEngineSession({
     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/ui/statusline-agents.mjs

@@ -14,14 +14,6 @@ import { num, GRN, R, B } from './statusline-format.mjs';
 const DEFAULT_HIDDEN_STATUSLINE_AGENTS = Object.freeze(['explorer', 'cycle1-agent', 'cycle2-agent', 'cycle3-agent', 'scheduler-task', 'webhook-handler']);
 let _hiddenStatuslineAgents = null;
 
-export function summarizeWorkerTags(workers, limit = 3) {
-  const cleanLabels = [...new Set((Array.isArray(workers) ? workers : [])
-    .map((worker) => String(worker?.tag || '').trim())
-    .filter(Boolean))];
-  if (cleanLabels.length <= limit) return cleanLabels.join(', ');
-  return `${cleanLabels.slice(0, limit).join(', ')}, +${cleanLabels.length - limit}`;
-}
-
 function normalizeAgentWorkerForStatusline(worker = {}) {
   const tag = String(worker.tag || worker.agent || worker.name || '').trim();
   if (!tag) return null;

package/src/ui/statusline.mjs

@@ -23,7 +23,7 @@ import {
 } from './statusline-format.mjs';
 import { shellJobsStatus, memoryCycleStatus } from './statusline-segments.mjs';
 import {
-  summarizeWorkerTags, agentStatuslinePayload, classifyAgentWorkers, activeHiddenAgentWorkers, agentWebSearchStatus,
+  agentStatuslinePayload, classifyAgentWorkers, activeHiddenAgentWorkers, agentWebSearchStatus,
 } from './statusline-agents.mjs';
 export { createSessionStats, applyUsageDelta } from './session-stats.mjs';
 // Facade re-exports: keep these public symbols resolving from statusline.mjs.
@@ -362,14 +362,12 @@ function renderNativeStatusline({
   if (runningWorkers.length) {
     const n = runningWorkers.length;
     const label = `Running ${n} Agent${n === 1 ? '' : 's'}`;
-    const tagSummary = summarizeWorkerTags(runningWorkers);
-    const tags = tagSummary ? ` ${D}(${R}${B}${tagSummary}${R}${D})${R}` : '';
     const oldestStart = runningWorkers.reduce((min, w) => {
       const t = num(w?.startedAtMs);
       return t > 0 && t < min ? t : min;
     }, Infinity);
     const elapsed = Number.isFinite(oldestStart) ? formatElapsed(Date.now() - oldestStart) : '';
-    addL2(`${spin} ${B}${label}${R}${tags}${elapsedSuffix(elapsed)}`);
+    addL2(`${spin} ${B}${label}${R}${elapsedSuffix(elapsed)}`);
   }
   const tools = activeTools && typeof activeTools === 'object' ? activeTools : {};
   const exploreInfo = tools.explore || null;

package/src/workflows/default/WORKFLOW.md

@@ -13,15 +13,20 @@ 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 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.
+Lead owns three duties, in order: plan — set the direction of the work from its own
+understanding of the task; delegate — hand execution to the matching agent; verify —
+judge what comes back. Understanding is never delegated: without its own plan a Lead
+can neither brief nor judge. 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 is an
+escalation role reserved for explicitly requested debugging or a bug surviving 2+ fix
+cycles — not a default owner of analysis or reverse engineering, which route to
+Worker/Heavy Worker like any implementation. 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.
@@ -29,22 +34,26 @@ delivery. Applying a Debugger result is implementation, not diagnosis.
    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
+3. Review: triage by the work performed, never by the size, form, or destination
+   of its result — a one-line answer can carry non-trivial work, and a
+   conversational reply is not automatically exempt. Trivial work — a routine
+   lookup answered directly, routine git/configuration confirmed by its own
+   mechanical check, a change whose correctness is test/build/diff-obvious, or
+   applying an exact target and replacement the user supplied — ships on shell
+   self-verification alone, and only after that check actually ran and passed.
+   Non-trivial work — multi-step reasoning, interpretation, investigation, or
+   anything whose correctness is not verifiable at a glance — gets a Reviewer
+   cross-check (one reviewer per scope, kept across the fix loop; all ready
+   reviewers spawn in one turn) and Lead integration/cross-scope verification
+   in parallel, whoever performed it, Lead solo included. 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.
+   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

package/src/workflows/solo-review/WORKFLOW.md

@@ -0,0 +1,47 @@
+---
+id: solo-review
+name: Solo Review
+description: "Lead implements directly; eligible low-risk single scopes receive one independent Reviewer."
+agents: reviewer
+---
+
+# Solo Review
+
+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.
+
+1. Plan: before implementation, Lead classifies the scope as eligible
+   low-risk/single-scope or ineligible high-risk/multi-scope, drafts the plan,
+   settles scope, asks if ambiguous, then awaits the gate. Ineligible work must
+   switch to Default workflow with a revised Default plan and fresh approval
+   before implementation. After that switch, Solo Review constraints are
+   suspended: Default reviewer-per-scope fan-out and high-risk lenses override
+   Solo Review's single-Reviewer and concurrency limits.
+2. Execute: after approval, Lead performs all implementation and verification
+   directly. Never delegate implementation, investigation, debugging, or
+   maintenance to implementation helper roles (Worker, Heavy Worker, Explorer,
+   Debugger, or Maintainer). Complete in-scope fixes without reapproval; interim
+   updates are in-progress, never conclusions.
+3. Review: only an eligible low-risk, single-scope final deliverable, once
+   implemented and Lead-verified, receives exactly one Reviewer to critically
+   and independently evaluate the approved intent, complete deliverable,
+   affected boundaries, and verification. Lead evaluates the findings, applies
+   every necessary fix directly, and re-verifies. Send the revised deliverable
+   back to that same live Reviewer for every re-check. If that session is
+   unavailable, one cold replacement Reviewer may re-review the original intent,
+   current deliverable, and verification evidence; never run replacement or
+   additional Reviewers concurrently. Repeat fix -> Lead verification -> Reviewer
+   re-check until issue-free or blocked.
+4. Report: only after the review loop is clean, the final (not interim) report
+   compares the result to the approved plan and gives verification and material
+   remaining risk/next step; never forward raw Reviewer output. Ask about
+   ship/deploy when relevant. Verification builds/tests needed to evaluate the
+   deliverable are permitted during execution and review. Release builds,
+   deploy/commit/push require an explicit user request after issue-free feedback;
+   implementation approval alone is insufficient.
+
+On outcome/direction change, pause and re-consult; otherwise continue approved
+work without reapproval.

package/src/workflows/bench/WORKFLOW.md

@@ -1,60 +0,0 @@
----
-id: bench
-name: Bench
-description: "Autonomous headless benchmark workflow with directed execution and parallel cross-verification."
-hidden: true
-agents: worker, heavy-worker, reviewer, debugger, maintainer
----
-
-# Bench
-
-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.