mixdog 0.9.22 → 0.9.24

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,
+  summarizeWorkerTags, 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.
@@ -90,6 +90,28 @@ function rememberNonEmptyQuotaSegments(key, segments) {
     _lastNonEmptyQuotaSegmentsByKey.delete(oldestKey);
   }
 }
+
+// Monotonic hysteresis for the quota/usage segment. Once a value has rendered
+// (held), a new non-empty result replaces it ONLY when it is at least as fresh
+// or is confirmed own-instance live data. This stops the 5H/7D values flapping
+// when another mixdog instance overwrites the shared active-instance/usage cache
+// with an OLDER snapshot: metricsMatch flips false, the source alternates to a
+// provider-wide cache snapshot captured at a different time, and without this
+// gate the two sources would oscillate tick-to-tick.
+//   - nothing displayed yet .................. accept
+//   - incoming is own-instance live data ..... accept (always wins)
+//   - either side lacks a comparable asOf .... accept (preserves prior behavior)
+//   - displayed value is own live data ....... accept only a STRICTLY newer snapshot
+//   - both shared-cache snapshots ............ accept same-or-newer asOf
+export function acceptQuotaSnapshot(held, incoming) {
+  if (!held) return true;
+  if (incoming && incoming.owned) return true;
+  const incomingAsOf = num(incoming && incoming.asOf);
+  const heldAsOf = num(held.asOf);
+  if (!incomingAsOf || !heldAsOf) return true;
+  if (held.owned) return incomingAsOf > heldAsOf;
+  return incomingAsOf >= heldAsOf;
+}
 // Option A boot gate: the L1 usage/quota segment stays fully empty until THIS
 // process has captured its FIRST confirmed (current-process) OAuth usage
 // snapshot for THAT provider. The latch is monotonic PER PROVIDER — once a
@@ -310,10 +332,21 @@ function renderNativeStatusline({
   if (usageReady && _oauthUsageArmedProviders.has(normalizedHoldProvider)) {
     const holdKey = quotaSegmentsHoldKey({ provider, model, effort, fast, sessionId, clientHostPid });
     if (quotaSegments.length) {
-      rememberNonEmptyQuotaSegments(holdKey, quotaSegments);
+      // Monotonic replace: keep the currently displayed value unless the new
+      // one is same-or-newer, or is confirmed own-instance live data.
+      const incoming = {
+        asOf: num(quotaStatus?.quotaWindowsAsOf),
+        owned: quotaStatus?.quotaWindowsOwned === true,
+      };
+      const held = _lastNonEmptyQuotaSegmentsByKey.get(holdKey);
+      if (acceptQuotaSnapshot(held, incoming)) {
+        rememberNonEmptyQuotaSegments(holdKey, { segments: quotaSegments, asOf: incoming.asOf, owned: incoming.owned });
+      } else if (held?.segments?.length) {
+        quotaSegments = held.segments;
+      }
     } else {
       const held = _lastNonEmptyQuotaSegmentsByKey.get(holdKey);
-      if (held && held.length) quotaSegments = held;
+      if (held?.segments?.length) quotaSegments = held.segments;
     }
   }
   for (const seg of quotaSegments) addL1(seg);
@@ -329,7 +362,9 @@ function renderNativeStatusline({
   const sp = l2SpinnerFrame(spinnerNow);
   const spin = `${GRN}${sp}${R}`;
   const elapsedSuffix = (label) => (label ? ` ${D}·${R} ${label}` : '');
-  // Segment order: Running Agents → Exploring → Searching → Running Shells.
+  // Segment order: Running Agents → Exploring → Web Searching → Running Shells.
+  // (activeTools.search counts WEB searches — category 'Web Research' — not
+  // local file search, which is intentionally not surfaced.)
   if (runningWorkers.length) {
     const n = runningWorkers.length;
     const label = `Running ${n} Agent${n === 1 ? '' : 's'}`;
@@ -349,9 +384,17 @@ function renderNativeStatusline({
     const elapsed = num(exploreInfo.startedAt) > 0 ? formatElapsed(Date.now() - num(exploreInfo.startedAt)) : '';
     addL2(`${spin} ${B}Exploring${R}${elapsedSuffix(elapsed)}`);
   }
-  if (searchInfo && num(searchInfo.count) > 0) {
-    const elapsed = num(searchInfo.startedAt) > 0 ? formatElapsed(Date.now() - num(searchInfo.startedAt)) : '';
-    addL2(`${spin} ${B}Searching${R}${elapsedSuffix(elapsed)}`);
+  // Web Searching = lead's own web searches (activeTools.search) PLUS any
+  // spawned agent sub-session whose current tool call is a web search
+  // (agentWebSearchStatus reads the live session-runtime map). Earliest start
+  // wins for the elapsed label.
+  const agentSearch = agentWebSearchStatus({ sessionId, clientHostPid });
+  const webSearchCount = (searchInfo ? num(searchInfo.count) : 0) + num(agentSearch.count);
+  if (webSearchCount > 0) {
+    const starts = [searchInfo ? num(searchInfo.startedAt) : 0, num(agentSearch.startedAt)].filter((v) => v > 0);
+    const searchStart = starts.length ? Math.min(...starts) : 0;
+    const elapsed = searchStart > 0 ? formatElapsed(Date.now() - searchStart) : '';
+    addL2(`${spin} ${B}Web Searching${R}${elapsedSuffix(elapsed)}`);
   }
   if (shellStatus.count > 0) {
     const n = shellStatus.count;
@@ -530,6 +573,10 @@ function fallbackQuotaStatus({ provider, model } = {}) {
             value = {
               ...routeInfo,
               quotaWindows: limits.quotaWindows || [],
+              // Shared provider-wide OAuth usage cache snapshot: not owned by
+              // this instance. asOf = the snapshot's cachedAt for hysteresis.
+              quotaWindowsAsOf: num(usageSnapshot?.cachedAt),
+              quotaWindowsOwned: false,
               balance: limits.balance || null,
               routeSpend: limits.routeSpend || null,
             };
@@ -556,12 +603,15 @@ function providerKindForQuota(provider) {
 function mergeQuotaStatus(primary, fallback) {
   if (!primary) return fallback || null;
   if (!fallback) return primary;
+  const usePrimaryWindows = Array.isArray(primary.quotaWindows) && primary.quotaWindows.length;
   return {
     ...fallback,
     ...primary,
-    quotaWindows: Array.isArray(primary.quotaWindows) && primary.quotaWindows.length
-      ? primary.quotaWindows
-      : (fallback.quotaWindows || []),
+    quotaWindows: usePrimaryWindows ? primary.quotaWindows : (fallback.quotaWindows || []),
+    // Keep asOf/owned aligned with whichever windows won, so the hysteresis gate
+    // compares against the timestamp of the value actually being rendered.
+    quotaWindowsAsOf: usePrimaryWindows ? num(primary.quotaWindowsAsOf) : num(fallback.quotaWindowsAsOf),
+    quotaWindowsOwned: usePrimaryWindows ? primary.quotaWindowsOwned === true : fallback.quotaWindowsOwned === true,
     balance: primary.balance || fallback.balance || null,
     routeSpend: primary.routeSpend || fallback.routeSpend || null,
     providerKind: primary.providerKind || fallback.providerKind || providerKindForQuota(primary.provider || fallback.provider),

package/src/ui/tool-card.mjs

@@ -9,6 +9,7 @@
  * malformed argument objects (the engine hands us `{ name, arguments, id }`).
  */
 import { bold, cyan, gray } from './ansi.mjs';
+import { parseMcpToolName, isSelfMcpToolName } from '../runtime/shared/tool-primitives.mjs';
 
 const MAX_SUMMARY = 72;
 
@@ -38,13 +39,19 @@ export function renderToolCard(call) {
 
   const summary = safeSummary(name, args);
   const bullet = cyan('>');
-  const label = bold(name);
+  const label = bold(mcpCardLabel(name));
   if (!summary) return `  ${bullet} ${label}`;
   return `  ${bullet} ${label} ${gray(truncate(summary, MAX_SUMMARY))}`;
 }
 
 // --- helpers -----------------------------------------------------------------
 
+function mcpCardLabel(name) {
+  const mcp = parseMcpToolName(name);
+  if (!mcp || isSelfMcpToolName(name)) return name;
+  return `MCP ${mcp.server}.${mcp.tool}`;
+}
+
 function safeSummary(name, args) {
   try {
     const fn = SUMMARIZERS[name];

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

@@ -343,27 +343,30 @@ function cachedQuotaWindowsFallback(provider, model) {
   // OAuth quota is provider/account-scoped, not model-scoped. Prefer the
   // current route key, then provider-wide cache, then the freshest same-provider
   // route entry so a model switch keeps showing quota before the next live fetch.
-  if (!provider || !model) return [];
+  // Returns the chosen entry's cachedAt alongside the windows so the caller can
+  // apply monotonic hysteresis (never displace a displayed value with an older
+  // shared-cache snapshot written by a different instance).
+  if (!provider || !model) return { quotaWindows: [], cachedAt: 0 };
   try {
     const cachePath = path.join(pluginDataDir(), 'gateway-oauth-usage-cache.json');
     const cache = readJson(cachePath);
     const routes = cache && typeof cache.routes === 'object' ? cache.routes : null;
-    if (!routes) return [];
+    if (!routes) return { quotaWindows: [], cachedAt: 0 };
     const routeKey = `${String(provider).toLowerCase()}
${String(model)}`;
     const providerOnlyKey = String(provider).toLowerCase();
     const routePrefix = `${providerOnlyKey}
`;
     const entry = routes[routeKey] || routes[providerOnlyKey] || Object.entries(routes)
       .filter(([key, value]) => key.startsWith(routePrefix) && Array.isArray(value?.quotaWindows))
       .sort((a, b) => (Number(b[1]?.cachedAt) || 0) - (Number(a[1]?.cachedAt) || 0))[0]?.[1];
-    if (!Array.isArray(entry?.quotaWindows)) return [];
+    if (!Array.isArray(entry?.quotaWindows)) return { quotaWindows: [], cachedAt: 0 };
     // Boot guard: do not render previous-launch usage before the current runtime
     // has captured at least one snapshot. Once captured in this process, hold it
     // instead of blanking it during idle/network gaps.
     const cachedAt = Number(entry.cachedAt);
-    if (!Number.isFinite(cachedAt) || cachedAt < STATUSLINE_PROCESS_STARTED_AT_MS) return [];
-    return entry.quotaWindows;
+    if (!Number.isFinite(cachedAt) || cachedAt < STATUSLINE_PROCESS_STARTED_AT_MS) return { quotaWindows: [], cachedAt: 0 };
+    return { quotaWindows: entry.quotaWindows, cachedAt };
   } catch {
-    return [];
+    return { quotaWindows: [], cachedAt: 0 };
   }
 }
 
@@ -499,11 +502,18 @@ function configuredGatewayStatus(options = {}) {
 
 export function loadGatewayStatus(options = {}) {
   const configured = configuredGatewayStatus(options);
+  const quotaFallback = configured
+    ? cachedQuotaWindowsFallback(configured.provider, configured.model)
+    : { quotaWindows: [], cachedAt: 0 };
   const configuredStatus = configured ? {
     ...configured,
     contextUsedPct: pctOf(options.activeContextTokens, compactBoundaryForStatus(configured)),
     lastUsage: null,
-    quotaWindows: cachedQuotaWindowsFallback(configured.provider, configured.model),
+    quotaWindows: quotaFallback.quotaWindows,
+    // Shared provider-wide cache snapshot: not owned by this instance. asOf is
+    // the cache entry's cachedAt so an older snapshot can be rejected downstream.
+    quotaWindowsAsOf: num(quotaFallback.cachedAt, 0),
+    quotaWindowsOwned: false,
     balance: null,
     routeSpend: null,
   } : null;
@@ -609,6 +619,12 @@ export function loadGatewayStatus(options = {}) {
       : null,
     lastUsage,
     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
+    // the shared-cache fallback's (unowned) asOf. Older/unowned snapshots must
+    // not displace a value already rendered from newer/owned data.
+    quotaWindowsAsOf: activeQuotaWindows.length ? (updatedAt || 0) : num(configuredStatus?.quotaWindowsAsOf, 0),
+    quotaWindowsOwned: activeQuotaWindows.length ? metricsMatch : false,
     balance: metricsMatch && active.gateway_balance && typeof active.gateway_balance === 'object' ? active.gateway_balance : (configuredStatus?.balance || null),
     routeSpend: metricsMatch && active.gateway_route_spend && typeof active.gateway_route_spend === 'object' ? active.gateway_route_spend : (configuredStatus?.routeSpend || null),
     providerKind: statusProviderKind,

package/src/workflows/bench/WORKFLOW.md

@@ -0,0 +1,46 @@
+---
+id: bench
+name: Bench
+description: "Autonomous benchmark workflow — loop to completion without user approval."
+hidden: true
+agents: worker, heavy-worker, reviewer, debugger, maintainer
+---
+
+# Bench Workflow
+
+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.
+
+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.
+
+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.

package/src/workflows/default/WORKFLOW.md

@@ -7,7 +7,13 @@ agents: worker, heavy-worker, reviewer, debugger, maintainer
 
 # Default Workflow
 
+HARD APPROVAL GATE — before the user gives an explicit go-ahead ("do it",
+"proceed", "ㄱㄱ"), NO edits, apply_patch, state-changing shell commands, or
+agent spawns. Read-only exploration only. Agreeing with a diagnosis or
+pointing out a problem is NOT approval.
+
 Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
+(routing applies only AFTER approval)
 - 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:

package/src/workflows/solo/WORKFLOW.md

@@ -7,6 +7,11 @@ agents:
 
 # Solo Workflow
 
+HARD APPROVAL GATE — before the user gives an explicit go-ahead ("do it",
+"proceed", "ㄱㄱ"), NO edits, apply_patch, or state-changing shell commands.
+Read-only exploration only. Agreeing with a diagnosis or pointing out a
+problem is NOT approval.
+
 1. Plan — Lead discusses the request with the user, forms a plan, and waits for
    approval before execution.
    Only an explicit go-ahead is approval; diagnosis agreement is not. When

package/vendor/ink/build/ink.js

@@ -225,6 +225,10 @@ export default class Ink {
     // refreshed every render; read back via getSelectionRows() so the app can
     // stitch selections taller than the viewport. null when no selection.
     lastSelectionRows = null;
+    // [mixdog fork] One-shot flag: the next interactive frame takes the full
+    // clearTerminal+rewrite path even when nothing changed. Set via
+    // forceFullRepaint(); consumed (and reset) in renderInteractiveFrame.
+    forceClearNextFrame = false;
     constructor(options) {
         autoBind(this);
         this.options = options;
@@ -569,6 +573,19 @@ export default class Ink {
     getSelectionRows = () => {
         return this.lastSelectionRows;
     };
+    // [mixdog fork] Force a one-shot whole-screen clear + rewrite. Windows
+    // Terminal keeps its NATIVE (shift+drag) selection overlay alive across
+    // incremental in-place repaints, so a stale native highlight can sit on top
+    // of the app-drawn selection; a real clearTerminal+full rewrite dismisses
+    // it. The frame is BSU/ESU-wrapped by renderInteractiveFrame, so there is
+    // no visible flash. Called by the app on mouse-press via the render handle.
+    forceFullRepaint = () => {
+        if (this.isUnmounted || this.isUnmounting) {
+            return;
+        }
+        this.forceClearNextFrame = true;
+        this.rootNode.onImmediateRender();
+    };
     restoreLastOutput = () => {
         if (!this.interactive) {
             return;
@@ -1115,7 +1132,11 @@ export default class Ink {
         if (isFullscreen && outputToRender.endsWith('\n')) {
             outputToRender += '\u001B[0m';
         }
-        const shouldClearTerminal = shouldClearTerminalForFrame({
+        // [mixdog fork] One-shot forced clear (see forceFullRepaint): TTY-only,
+        // consumed here so it applies to exactly one frame.
+        const forcedClear = this.forceClearNextFrame && isTty;
+        this.forceClearNextFrame = false;
+        const shouldClearTerminal = forcedClear || shouldClearTerminalForFrame({
             isTty,
             viewportRows,
             previousViewportRows,
@@ -1147,6 +1168,7 @@ export default class Ink {
         // with identical output text but must still force a full clear to
         // avoid ghosting stale cells left outside the new viewport.
         if (shouldClearTerminal &&
+            !forcedClear &&
             !this.isUnmounting &&
             output === this.lastOutput &&
             staticOutput === '' &&