mixdog 0.9.174 → 1.0.0

package/src/runtime/shared/model-display.mjs

@@ -0,0 +1,178 @@
+/**
+ * Pure model display-name helpers shared by the TUI snap path and statusline.
+ * No I/O, catalog, or gateway imports — safe for static TUI bundling.
+ */
+
+export function titleModelPart(part) {
+  const text = String(part || '').trim();
+  if (!text) return '';
+  const lower = text.toLowerCase();
+  if (lower === 'gpt') return 'GPT';
+  if (lower === 'api') return 'API';
+  if (lower === 'v4') return 'V4';
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+
+// Hyphen-separated id tail → title-cased words joined by `joiner`.
+function titleModelWords(tail, joiner = ' ') {
+  return tail.split('-').map(titleModelPart).filter(Boolean).join(joiner);
+}
+
+function stripModelId(model) {
+  const text = String(model || '').trim();
+  if (!text) return '';
+  return text.includes('/') ? text.split('/').filter(Boolean).at(-1) || text : text;
+}
+
+function normalizeDisplayHint(displayHint) {
+  if (displayHint == null || displayHint === '') return '';
+  if (typeof displayHint === 'object') {
+    return String(displayHint.displayName || displayHint.display || displayHint.name || '').trim();
+  }
+  return String(displayHint).trim();
+}
+
+export function canonicalModelDisplay(model, _provider) {
+  const raw = String(model || '')
+    .trim()
+    .replace(/-\d{4}-\d{2}-\d{2}$/, '')
+    .replace(/-\d{8}$/, '');
+  if (!raw) return '';
+
+  const gpt = raw.match(/^gpt-(\d+(?:\.\d+)?)(?:-(.+))?$/i);
+  if (gpt) {
+    const suffix = gpt[2] ? `-${titleModelWords(gpt[2], '-')}` : '';
+    return `GPT-${gpt[1]}${suffix}`;
+  }
+
+  if (/^gpt-/i.test(raw)) {
+    return raw
+      .split('-')
+      .map((part, index) => (index === 0 ? part.toUpperCase() : titleModelPart(part)))
+      .filter(Boolean)
+      .join('-');
+  }
+
+  const openaiO = raw.match(/^o(\d+(?:\.\d+)?)(?:-(.+))?$/i);
+  if (openaiO) {
+    const tail = openaiO[2] ? ` ${titleModelWords(openaiO[2])}` : '';
+    return `O${openaiO[1]}${tail}`;
+  }
+
+  const codex = raw.match(/^codex-(.+)$/i);
+  if (codex) {
+    return `Codex ${titleModelWords(codex[1])}`;
+  }
+
+  const deepseek = raw.match(/^deepseek-(.+)$/i);
+  if (deepseek) {
+    return `DeepSeek ${titleModelWords(deepseek[1])}`;
+  }
+
+  const grok = raw.match(/^grok-(.+)$/i);
+  if (grok) {
+    return `Grok ${titleModelWords(grok[1])}`;
+  }
+
+  const claudeLegacy = raw.match(/^claude-(\d+)(?:-(\d+))?-(opus|sonnet|haiku|fable)(?:-|$)/i);
+  if (claudeLegacy) {
+    const version = `${claudeLegacy[1]}${claudeLegacy[2] ? `.${claudeLegacy[2]}` : ''}`;
+    return `Claude ${titleModelPart(claudeLegacy[3])} ${version}`;
+  }
+
+  const claude = raw.match(/^claude-(opus|sonnet|haiku|fable)-(.+)$/i);
+  if (claude) {
+    return `Claude ${titleModelPart(claude[1])} ${claude[2].replace(/-/g, '.')}`;
+  }
+
+  const gemini = raw.match(/^gemini-(\d+(?:\.\d+)?)-(.+)$/i);
+  if (gemini) {
+    return `Gemini ${gemini[1]} ${titleModelWords(gemini[2])}`;
+  }
+
+  const geminiLoose = raw.match(/^gemini-(.+)$/i);
+  if (geminiLoose) {
+    return `Gemini ${titleModelWords(geminiLoose[1])}`;
+  }
+
+  return gatewayBrandDisplay(raw) || raw;
+}
+
+// Gateway brands (OpenCode Go and similar) whose ids carry the version
+// inside the first token (kimi-k2.7-code, qwen3.8-max, glm-5.3-flash).
+// Output follows the models.dev naming so online/offline labels match.
+const SPACED_BRANDS = [
+  [/^kimi-(.+)$/i, 'Kimi', ' '],
+  [/^qwen(\d.*)$/i, 'Qwen', ''],
+  [/^mimo-(.+)$/i, 'MiMo', ' '],
+  [/^muse-spark-(.+)$/i, 'Muse Spark', ' '],
+  [/^hy(\d.*)$/i, 'Hy', ''],
+];
+const HYPHENATED_BRANDS = [
+  [/^glm-(.+)$/i, 'GLM'],
+  [/^minimax-(.+)$/i, 'MiniMax'],
+  [/^longcat-(.+)$/i, 'LongCat'],
+];
+
+// Program-tier tokens the gateway appends to the id but that say nothing
+// about the model itself (muse-spark-1.3-contributor → "Muse Spark 1.3").
+const BRAND_NOISE_TOKENS = new Set(['contributor']);
+
+function brandVersionPart(part) {
+  const text = String(part || '').trim();
+  if (!text || BRAND_NOISE_TOKENS.has(text.toLowerCase())) return '';
+  // Version-ish tokens (k2.7, v2.5, 3.8, m3) upper-case a single leading
+  // letter; word tokens (code, max, flash, contributor) title-case.
+  return /^[a-z]?\d/i.test(text) ? text.toUpperCase() : titleModelPart(text);
+}
+
+export function gatewayBrandDisplay(raw) {
+  for (const [re, brand, joiner] of SPACED_BRANDS) {
+    const m = raw.match(re);
+    if (!m) continue;
+    const tail = m[1].split('-').map(brandVersionPart).filter(Boolean).join(' ');
+    return `${brand}${joiner}${tail}`;
+  }
+  for (const [re, brand] of HYPHENATED_BRANDS) {
+    const m = raw.match(re);
+    if (!m) continue;
+    const tail = m[1].split('-').map(brandVersionPart).filter(Boolean).join('-');
+    return `${brand}-${tail}`;
+  }
+  return '';
+}
+
+// A hint is "curated" when it is not merely the id re-spaced/re-cased
+// ("Claude Sonnet 4.5" for claude-sonnet-4-5 is not; "Muse Spark 1.3" for
+// muse-spark-1.3-contributor is). Curated hints — user aliases and catalog
+// names with real extra meaning — win over the id-derived rule.
+function displayKey(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '');
+}
+function isCuratedHint(hint, id) {
+  return !!hint && !!id && displayKey(hint) !== displayKey(id);
+}
+
+export function displayModelName(model, provider = '', displayHint = '') {
+  const id = stripModelId(model);
+  const hint = normalizeDisplayHint(displayHint);
+
+  if (isCuratedHint(hint, id)) return hint;
+  if (id) {
+    const canonical = canonicalModelDisplay(id, provider);
+    if (canonical && canonical !== id) return canonical;
+  }
+  if (hint) return hint;
+  return id;
+}
+
+export function shortenModelName(name, cols) {
+  let out = String(name || 'model').replace(/\s*\(1M context\)/i, ' (1M)');
+  out = out.replace(/^Claude\s+/i, '');
+  out = out.replace(/^OpenAI\s+/i, '');
+  if (cols < 80 && out.length > 18) return `${out.slice(0, 17)}…`;
+  if (cols < 120 && out.length > 28) return `${out.slice(0, 27)}…`;
+  return out;
+}

package/src/runtime/shared/notify-trace.mjs

@@ -3,13 +3,24 @@
 // in the field (2026-08-17: bench shell output never rendered while the model
 // queue twin worked every time). One append-only line per decision point keeps
 // the delivery chain reconstructable after the fact. Small, bounded lines;
-// best-effort writes; never throws into the caller.
-import { appendFileSync, mkdirSync } from 'node:fs';
+// best-effort writes; never throws into the caller. Lines are queued and
+// written asynchronously; the file keeps its last 1 MiB once it passes 4 MiB.
+import { mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { createAsyncLogAppender } from './async-log-appender.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
 
+const NOTIFY_TRACE_MAX_BYTES = 4 * 1024 * 1024;
+const NOTIFY_TRACE_KEEP_BYTES = 1024 * 1024;
+const appender = createAsyncLogAppender({ maxBytes: NOTIFY_TRACE_MAX_BYTES, keepBytes: NOTIFY_TRACE_KEEP_BYTES });
+
 let traceDir = null;
 
+/** Resolves once every trace line queued so far is on disk. */
+export function flushNotifyTrace() {
+  return appender.flush();
+}
+
 // Resolved per call: a pristine boundary retargets MIXDOG_DATA_DIR/MIXDOG_HOME
 // at runtime, and its traces must stay inside that isolated root.
 function tracePath() {
@@ -32,7 +43,7 @@ export function notifyTrace(stage, fields = {}) {
       if (value === undefined || value === null) continue;
       parts.push(`${key}=${String(value).replace(/\s+/g, ' ').slice(0, 120)}`);
     }
-    appendFileSync(tracePath(), `${parts.join(' ')}\n`);
+    appender.append(tracePath(), `${parts.join(' ')}\n`);
   } catch {
     /* tracing must never break delivery */
   }

package/src/runtime/shared/owner-fair-gate.mjs

@@ -1,4 +1,4 @@
-import { createFairCallScheduler } from '../../standalone/fair-call-scheduler.mjs';
+import { createFairCallScheduler } from './fair-call-scheduler.mjs';
 import { positiveInt } from './numbers.mjs';
 import { currentToolExecutionOwner } from './tool-execution-owner.mjs';
 

package/src/runtime/shared/pending-json-projection.mjs

@@ -0,0 +1,17 @@
+// Leaf registry: a JSON file whose in-process writer persists asynchronously
+// (standalone/agent-tool/index-write-queue.mjs) publishes its document-with-
+// unpersisted-writes here, so other in-process readers of that same file (the
+// cold session catalog) still see this process's own writes immediately.
+import { resolve } from 'node:path';
+
+const projections = new Map(); // resolved file path → () => document | null
+
+export function registerJsonProjection(file, getProjection) {
+  projections.set(resolve(file), getProjection);
+}
+
+/** Document including this process's unpersisted writes, or null when the
+ *  file on disk is current. */
+export function readJsonProjection(file) {
+  return projections.get(resolve(file))?.() ?? null;
+}

package/src/runtime/shared/pristine-execution.mjs

@@ -10,7 +10,6 @@ import { platformEntryKey } from './native-asset.mjs';
 import { clean } from './clean.mjs';
 
 const contractPath = fileURLToPath(new URL('./pristine-execution-contract.json', import.meta.url));
-const patchManifestPath = fileURLToPath(new URL('../agent/orchestrator/tools/patch-manifest.json', import.meta.url));
 
 const PRISTINE_EXECUTION_CONTRACT = Object.freeze(JSON.parse(readFileSync(contractPath, 'utf8')));
 
@@ -118,7 +117,8 @@ function hostDataDir(env) {
   return join(home, 'data');
 }
 
-function seedVerifiedPatchBinaryCache(sourceDataDir, dataDir, { manifestPath = patchManifestPath } = {}) {
+function seedVerifiedPatchBinaryCache(sourceDataDir, dataDir, { manifestPath } = {}) {
+  if (!manifestPath) return false;
   try {
     const sourcePatchDir = join(sourceDataDir, 'patch-bin');
     const manifestBytes = readFileSync(manifestPath);
@@ -198,6 +198,7 @@ export function createPristineExecutionBoundary({
   env = process.env,
   approvedExecutionEnv = {},
   apiKeyResolver = getAgentApiKey,
+  patchManifestPath,
 } = {}) {
   const routeError = validateExplicitPristineRoute({ provider, model, effort, fast });
   if (routeError) throw new Error(routeError);
@@ -265,7 +266,7 @@ export function createPristineExecutionBoundary({
 
   try {
     const sourceDataDir = hostDataDir(hostEnv);
-    seedVerifiedPatchBinaryCache(sourceDataDir, dataDir);
+    seedVerifiedPatchBinaryCache(sourceDataDir, dataDir, { manifestPath: patchManifestPath });
     const approvedNames = new Set(contract.approvedExecutionEnv || []);
     for (const name of Object.keys(approvedExecutionEnv || {})) {
       if (!approvedNames.has(name)) {

package/src/runtime/shared/process-lifecycle.mjs

@@ -111,6 +111,10 @@ function appendLedgerLine(active, line) {
   return statSync(active.ledger).size <= LIFECYCLE_LEDGER_MAX_BYTES;
 }
 
+// Synchronous append for the paths that cannot await (process-start ordering,
+// fatal/exit records). timeoutMs 0 is a try-lock: it never waits on the lock,
+// so it cannot stall the event loop for more than the one-line append itself.
+// Everything that can run on a live loop uses appendEntryAsync.
 function appendEntry(active, entry) {
   const line = `${JSON.stringify(entry)}\n`;
   if (Buffer.byteLength(line) > LIFECYCLE_LEDGER_MAX_BYTES) return false;
@@ -283,10 +287,6 @@ function priorVanishedEntry(previous) {
   };
 }
 
-function recordPriorVanished(active, previous) {
-  return appendEntry(active, priorVanishedEntry(previous));
-}
-
 function markerMatchesSnapshot(markerPath, previous) {
   try {
     const current = JSON.parse(readFileSync(markerPath, 'utf8'));
@@ -398,19 +398,30 @@ function reapVanishedMarkers(active) {
   } catch {}
   if (existsSync(active.legacyMarker)) candidates.push(active.legacyMarker);
   const occupied = [];
+  const vanished = [];
   for (const markerPath of candidates) {
     try {
       const previous = JSON.parse(readFileSync(markerPath, 'utf8'));
       if (previous?.pid === process.pid && previous?.token !== active.token) {
-        if (recordPriorVanished(active, previous)) unlinkSync(markerPath);
+        vanished.push({ markerPath, previous });
         continue;
       }
       const liveness = pidLiveness(previous?.pid);
       if (liveness === 'occupied') occupied.push({ markerPath, previous });
-      else if (liveness === 'dead' && recordPriorVanished(active, previous)) unlinkSync(markerPath);
+      else if (liveness === 'dead') vanished.push({ markerPath, previous });
     } catch {}
   }
-  void reapOccupiedMarkers(active, occupied).catch(() => {});
+  // The ledger appends run on the async lock path, one at a time: a boot that
+  // finds many dead markers must not hold the event loop in synchronous
+  // locked writes.
+  void (async () => {
+    for (const { markerPath, previous } of vanished) {
+      try {
+        await recordPriorVanishedAsync(active, markerPath, previous);
+      } catch {}
+    }
+    await reapOccupiedMarkers(active, occupied);
+  })().catch(() => {});
 }
 
 async function reapOccupiedMarkers(active, occupied) {