mixdog 0.9.40 → 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,33 +13,47 @@ 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 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.
-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: 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. 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,36 +0,0 @@
----
-id: bench
-name: Bench
-description: "Autonomous benchmark workflow — loop to completion without user approval."
-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.