mixdog 0.9.34 → 0.9.35

package/src/tui/engine/turn.mjs

@@ -137,16 +137,15 @@ export function createRunTurn(bag) {
     const deferredEntries = []; // creation-order list; each is pushed at most once
     // Push this entry AND every earlier-created still-deferred entry, in order,
     // so transcript order always matches call order even when a later card's
-    // result/timer fires before an earlier one's.
+    // result/timer fires before an earlier one's. Commit the collected cards in
+    // ONE state update: emitting one pushItem() per deferred card made a tool
+    // batch climb into view one row/card at a time ("툭툭" upward row jitter).
     const flushDeferredUpTo = (entry) => {
       if (!entry) return;
-      for (const e of deferredEntries) {
-        if (e.seq > entry.seq) break;
-        if (e.pushed) continue;
-        e.pushed = true;
-        if (e.timer) { clearTimeout(e.timer); e.timer = null; }
-        try { e.push(); } catch {}
-      }
+      const specs = collectDeferredUpTo(entry);
+      if (!specs.length) return;
+      flags.pushingFromDeferredEntry = true;
+      try { appendItemsBatch(specs); } finally { flags.pushingFromDeferredEntry = false; }
     };
     flags.flushDeferredBeforeImmediatePush = () => {
       if (!deferredEntries.length) return;

package/src/tui/engine.mjs

@@ -114,10 +114,12 @@ const TOOL_APPROVAL_TIMEOUT_MS = (() => {
 // runTurn holding busy=true with no unwind, so submit() only ever queues and
 // the UI is permanently input-dead. On trip we abort the in-flight run through
 // the SAME interrupt path Esc uses, force busy=false, and drain the queue.
-// Generous default (30min); env-overridable for tuning/tests.
+// Default is intentionally finite (5min): 30min made a stuck provider/worker
+// look like the Lead session had frozen mid-turn. Env-overridable for long
+// local experiments.
 const LEAD_TURN_TIMEOUT_MS = (() => {
   const value = Number(process.env.MIXDOG_LEAD_TURN_TIMEOUT_MS);
-  return Number.isFinite(value) && value > 0 ? Math.max(10_000, Math.round(value)) : 30 * 60_000;
+  return Number.isFinite(value) && value > 0 ? Math.max(10_000, Math.round(value)) : 5 * 60_000;
 })();
 
 // Opt-in diagnostic trace for the hang chain (runTurn start/end, busy-queue

package/src/vendor/statusline/bin/statusline-route.mjs

@@ -15,6 +15,7 @@ import {
   compactBoundaryDenominator,
   defaultEffectiveContextWindowPercent,
 } from '../src/gateway/route-meta.mjs';
+import { getModelMetadataSync } from '../../../runtime/agent/orchestrator/providers/model-catalog.mjs';
 
 function positiveInt(value) {
   const n = parseInt(String(value || ''), 10);
@@ -196,6 +197,8 @@ function routeContextMeta(provider, info = {}, inherited = {}) {
   const rawContextWindow = firstPositiveWindow(
     inherited.rawContextWindow,
     inherited.raw_context_window,
+    info.context_window,
+    info.max_context_window,
     info.contextWindow,
     info.maxContextWindow,
     info.max_input_tokens,
@@ -463,6 +466,26 @@ function configuredGatewayStatus(options = {}) {
     ? presets.find(p => p?.provider === provider && p?.model === model)
     : null);
   const info = loadCachedModel(provider, model) || {};
+  // Catalog/known metadata is authoritative for the context window. The cached
+  // model file can hold a STALE window (e.g. Opus 4.8 cached at 272k after its
+  // window grew to the catalog's 1M); routeContextMeta reads info.contextWindow,
+  // so reconcile it against the catalog before deriving the boundary. A live
+  // provider API window on the cached row (context_window / max_context_window)
+  // still outranks the catalog.
+  const _catalog = getModelMetadataSync(model, provider);
+  const _catalogWindow = num(
+    _catalog?.contextWindow
+      ?? _catalog?.maxContextWindow
+      ?? _catalog?.context_window
+      ?? _catalog?.max_context_window,
+    0,
+  );
+  const _apiWindow = num(info?.context_window ?? info?.max_context_window, 0);
+  const _cachedWindow = num(info?.contextWindow ?? info?.maxContextWindow, 0);
+  if (!_apiWindow && _catalogWindow > 0 && _cachedWindow !== _catalogWindow) {
+    info.contextWindow = _catalogWindow;
+    info.maxContextWindow = _catalogWindow;
+  }
   const effort = aliasTarget
     ? cleanString(aliasTarget.effort || gateway.effort || gateway.displayEffort || preset?.effort)
     : inherit
@@ -546,8 +569,18 @@ export function loadGatewayStatus(options = {}) {
   const routeMatchesConfigured = configured
     ? configured.provider === active.gateway_provider && configured.model === active.gateway_model
     : true;
+  const activeRouteBoundary = compactBoundaryForStatus({
+    autoCompactTokenLimit: active.gateway_auto_compact_token_limit,
+    contextWindow: active.gateway_context_window,
+    rawContextWindow: active.gateway_raw_context_window,
+  });
+  const configuredRouteBoundary = configured ? compactBoundaryForStatus(configured) : null;
+  const routeBoundaryMatchesConfigured = !configured
+    || !configuredRouteBoundary
+    || !activeRouteBoundary
+    || configuredRouteBoundary === activeRouteBoundary;
   const metricsOwnCurrentSession = !!(sessionStatus || gatewayCcSessionMatch || gatewayTranscriptMatch || activeTranscriptMatch);
-  const metricsMatch = gatewayClientHostMatch && metricsOwnCurrentSession && routeMatchesConfigured;
+  const metricsMatch = gatewayClientHostMatch && metricsOwnCurrentSession && routeMatchesConfigured && routeBoundaryMatchesConfigured;
   // Strong ownership = this session's own status file or an explicit session/
   // transcript id match from the gateway advert. `activeTranscriptMatch` (the
   // global active-instance transcript merely naming the current session) is NOT
@@ -555,12 +588,35 @@ export function loadGatewayStatus(options = {}) {
   // session while its stored gateway metrics (context pct, last usage) still
   // belong to the previous one.
   const strongSessionOwnership = !!(sessionStatus || gatewayCcSessionMatch || gatewayTranscriptMatch);
-  const lastUsage = gatewayClientHostMatch && strongSessionOwnership && active.gateway_last_usage && typeof active.gateway_last_usage === 'object'
+  // A model switch can keep strong session ownership while the active gateway
+  // advert still contains the previous route's lastUsage.compact. Do not let
+  // that stale compact boundary override the configured/current route window.
+  const lastUsage = gatewayClientHostMatch && strongSessionOwnership && routeMatchesConfigured && routeBoundaryMatchesConfigured && active.gateway_last_usage && typeof active.gateway_last_usage === 'object'
     ? active.gateway_last_usage
     : null;
-  const lastCompact = lastUsage?.compact && typeof lastUsage.compact === 'object'
+  const rawLastCompact = lastUsage?.compact && typeof lastUsage.compact === 'object'
     ? lastUsage.compact
     : null;
+  // A model/window switch updates the active route fields (context/raw window)
+  // but can leave the PREVIOUS route's boundary inside gateway_last_usage.compact.
+  // routeBoundaryMatchesConfigured only checks the active route fields, so that
+  // stale compact telemetry would otherwise survive and, via compactBoundaryTokens,
+  // resurrect the previous boundary in compactBoundaryForStatus below. Drop the
+  // compact telemetry when its own implied boundary contradicts the active route
+  // window.
+  const lastCompactBoundary = rawLastCompact
+    ? compactBoundaryForStatus({}, rawLastCompact)
+    : null;
+  const lastCompact = rawLastCompact
+    && (!activeRouteBoundary || !lastCompactBoundary || lastCompactBoundary === activeRouteBoundary)
+    ? rawLastCompact
+    : null;
+  const statusLastUsage = lastUsage
+    ? {
+      ...lastUsage,
+      compact: lastCompact,
+    }
+    : null;
   const contextBoundary = compactBoundaryForStatus({
     autoCompactTokenLimit: active.gateway_auto_compact_token_limit,
     contextWindow: active.gateway_context_window,
@@ -616,7 +672,7 @@ export function loadGatewayStatus(options = {}) {
     contextUsedPct: metricsMatch
       ? recomputedContextUsedPct ?? (strongSessionOwnership ? num(active.gateway_context_used_pct, null) : null)
       : null,
-    lastUsage,
+    lastUsage: statusLastUsage,
     quotaWindows: activeQuotaWindows.length ? activeQuotaWindows : (configuredStatus?.quotaWindows || []),
     // Provenance for monotonic hysteresis: live active-instance windows are
     // own-instance data timestamped by the advert's updatedAt; otherwise inherit

package/src/vendor/statusline/src/gateway/route-meta.mjs

@@ -9,7 +9,6 @@ import {
   estimateMessagesTokens,
   estimateRequestReserveTokens,
 } from '../../../../runtime/agent/orchestrator/session/context-utils.mjs';
-import { DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT } from '../../../../runtime/agent/orchestrator/session/compact/constants.mjs';
 import { CLAUDE_CURRENT_MODE } from './claude-current.mjs';
 
 const GATEWAY_USAGE_FILE = 'gateway-usage.local.json';
@@ -100,11 +99,11 @@ function boundedPercent(value, fallback = null) {
 }
 
 export function defaultEffectiveContextWindowPercent(_provider) {
-  // Gateway-routed models use catalog/provider context metadata (LiteLLM,
-  // models.dev, or native provider catalogs). Reserve a small universal
-  // headroom for output/tool/system tokens while keeping the raw model window
-  // visible separately.
-  return DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT;
+  // Gateway/statusline should report the full model boundary. The 10% safety
+  // headroom belongs to semantic-agent compact triggers, not to the main
+  // recall-fasttrack denominator.
+  void _provider;
+  return 100;
 }
 
 function effectiveContextWindowPercent(provider, info = {}, seed = {}) {
@@ -265,11 +264,34 @@ function mergeModelInfo(provider, model, providerObj) {
   const fromProvider = modelInfoFromProvider(providerObj, model);
   const fromCache = loadCachedModel(provider, model);
   const fromCatalog = getModelMetadataSync(model, provider);
-  return {
+  const merged = {
     ...(fromCatalog || {}),
     ...(fromCache || {}),
     ...(fromProvider || {}),
   };
+  // Catalog/known metadata is authoritative for the context window. Spreading
+  // fromCache after fromCatalog otherwise lets a STALE cached window (e.g. Opus
+  // 4.8 cached at 272k after its window grew to the catalog's 1M) override the
+  // catalog. Only a live provider API window (context_window / max_context_window)
+  // outranks the catalog; when the provider info supplies no such window and the
+  // catalog disagrees with the merged (cached) window, prefer the catalog.
+  const providerApiWindow = num(
+    fromProvider?.context_window ?? fromProvider?.max_context_window,
+    0,
+  );
+  const catalogWindow = num(
+    fromCatalog?.contextWindow
+      ?? fromCatalog?.maxContextWindow
+      ?? fromCatalog?.context_window
+      ?? fromCatalog?.max_context_window,
+    0,
+  );
+  const mergedWindow = num(merged?.contextWindow ?? merged?.maxContextWindow, 0);
+  if (!providerApiWindow && catalogWindow > 0 && mergedWindow !== catalogWindow) {
+    merged.contextWindow = catalogWindow;
+    merged.maxContextWindow = catalogWindow;
+  }
+  return merged;
 }
 
 export function readGatewayRouteInfo(seed = {}, providerObj = null) {
@@ -312,7 +334,14 @@ export function readGatewayRouteInfo(seed = {}, providerObj = null) {
     ?? cleanBool(preset?.fast)
     ?? false;
   const info = mergeModelInfo(provider, model, providerObj);
-  const rawContextWindow = num(info?.contextWindow ?? info?.maxContextWindow ?? info?.max_input_tokens, 0)
+  const rawContextWindow = num(
+    info?.context_window
+      ?? info?.max_context_window
+      ?? info?.contextWindow
+      ?? info?.maxContextWindow
+      ?? info?.max_input_tokens,
+    0,
+  )
     || num(seed.contextWindow, 0);
   const effectivePercent = effectiveContextWindowPercent(provider, info, seed);
   const contextWindow = effectiveContextWindow(rawContextWindow, effectivePercent);

package/src/workflows/default/WORKFLOW.md

@@ -7,39 +7,33 @@ agents: worker, heavy-worker, reviewer, debugger, maintainer
 
 # Default Workflow
 
-HARD APPROVAL GATE — no execution (changes, state mutations, delegation)
-before an explicit go-ahead ("do it", "proceed", "ㄱㄱ"); read-only
-exploration only. Diagnosis agreement or problem-pointing is NOT approval.
+HARD APPROVAL GATE — before explicit go-ahead ("do it", "proceed", "ㄱㄱ"),
+only read-only exploration; no changes, state mutations, or delegation.
+Diagnosis agreement/problem-pointing is NOT approval.
 
-Lead supervises: delegates, coordinates, judges, decides. Route by complexity
-(after approval):
-- Lead directly: only one-step fixes doable in a single turn, plus
-  coordination, config, and git deployment. Everything else delegates.
-- Worker: any multi-step or multi-file implementation. Heavy Worker:
-  high-complexity scopes.
-- Reviewer: verify implementation scopes. Debugger: very high complexity, or
-  root-causing already failed once.
+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.
 
-1. Plan — present a draft plan before ANY implementation; if not approved,
-   revise and re-present (ping-pong) until an explicit go-ahead.
-2. Delegate — maximize distribution: split the work into as many independent
-   implementation scopes as possible and hand each to its own worker or
-   heavy-worker, all spawned in the SAME turn (parallel by default; sequential
-   steps only inside one complex scope, gated build/test-green). Fan them out
-   across agents, never one at a time. Only a genuinely inseparable single
-   scope stays whole, and say so. Briefs per the Lead brief contract. After
-   spawning async agents, END THE TURN.
-3. Review — spawn one reviewer 1:1 per implementation scope, all reviewers in
-   the same turn once their scopes land.
-   Cross-check agent results yourself; send fixes back to the original scope
-   and loop fix -> re-verify until clean. Skip only for simple low-risk work.
-   Debugger first when the user asks for debugging or a bug survives 2+ fix
-   cycles.
-   On each agent report: tell the user what was received (scope + verdict)
-   and how work proceeds, marked in-progress — never as a conclusion.
-4. Report — final report briefs the whole work vs the approved plan and the
-   verified result, distinct from interim updates. Never forward raw agent
-   output. Ask about ship/deploy when relevant; deploy/build/commit only on an
-   explicit user request, after feedback with no issues.
+1. Plan — present a draft before ANY implementation; revise/re-present until
+   explicit go-ahead.
+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.
 
 On major direction shifts mid-work, pause and re-consult the user.

package/src/workflows/solo/WORKFLOW.md

@@ -7,22 +7,21 @@ agents:
 
 # Solo Workflow
 
-HARD APPROVAL GATE — no execution (changes, state mutations) before an
-explicit go-ahead ("do it", "proceed", "ㄱㄱ"); read-only exploration only.
-Diagnosis agreement or problem-pointing is NOT approval.
+HARD APPROVAL GATE — before explicit go-ahead ("do it", "proceed", "ㄱㄱ"),
+only read-only exploration; no changes or state mutations. Diagnosis
+agreement/problem-pointing is NOT approval.
 
-1. Plan — present a draft plan before ANY implementation; if not approved,
-   revise and re-present (ping-pong) until an explicit go-ahead. When
-   ambiguous, restate the plan and ask.
-2. Execute — Lead does all work directly; delegation forbidden. Interim
-   updates are marked in-progress — never phrased as conclusions.
+1. Plan — present a draft before ANY implementation; revise/re-present until
+   explicit go-ahead. 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 briefs the whole work vs the approved plan, the
-   verification result, and remaining risk/next step, distinct from interim
-   updates. Deploy/build/commit only after user feedback with no issues.
+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.
 
 On major direction shifts mid-work, pause and re-consult the user.
 
 Delegation rule:
-- Never delegate, spawn, send, or ask any agent to perform work; ignore any
-  available-agent section while this workflow is active.
+- Never delegate/spawn/send or ask agents to work; ignore available-agent
+  sections while this workflow is active.