mixdog 0.8.0 → 0.9.0

package/src/runtime/shared/err-text.mjs

@@ -50,10 +50,77 @@ function formatDurationMs(value) {
   return `${ms}ms`;
 }
 
+function compactDurationForStatus(value, { preferMinutes = false } = {}) {
+  const ms = Math.max(0, Number(value) || 0);
+  if (ms >= 1_000) {
+    if (preferMinutes && ms >= 60_000 && ms % 60_000 === 0) return `${Math.round(ms / 60_000)}m`;
+    if (ms < 600_000 && ms % 1_000 === 0) return `${Math.round(ms / 1_000)}s`;
+    if (ms >= 60_000 && ms % 60_000 === 0) return `${Math.round(ms / 60_000)}m`;
+    return `${Math.round(ms / 1_000)}s`;
+  }
+  return `${ms}ms`;
+}
+
+function parseDurationTokenToMs(token) {
+  const t = String(token || '').trim().toLowerCase();
+  const minutes = /^(\d+)m$/.exec(t);
+  if (minutes) return Number(minutes[1]) * 60_000;
+  const seconds = /^(\d+)s$/.exec(t);
+  if (seconds) return Number(seconds[1]) * 1_000;
+  const millis = /^(\d+)ms$/.exec(t);
+  if (millis) return Number(millis[1]);
+  return NaN;
+}
+
+function watchdogMsFromRawError(raw) {
+  const value = String(raw || '');
+  const timeout = /first response stale\s*\((\d+)ms\)/i.exec(value);
+  if (timeout) return { kind: 'timeout', ms: Number(timeout[1]) };
+  const stale = /(?:agent )?(?:task|tool running) stale\s*\((\d+)ms/i.exec(value);
+  if (stale) return { kind: 'stale', ms: Number(stale[1]) };
+  return null;
+}
+
+function compactReasonFromNormalizedTimeout(presented) {
+  const match = /no first response from (?:the )?[\w\s]*within (\d+m|\d+s|\d+ms)/i.exec(String(presented || ''));
+  if (!match) return '';
+  const ms = parseDurationTokenToMs(match[1]);
+  return Number.isFinite(ms)
+    ? `No first response ${compactDurationForStatus(ms)}`
+    : `No first response ${match[1]}`;
+}
+
+function compactReasonFromNormalizedStale(presented) {
+  const match = /went stale after (\d+m|\d+s|\d+ms)/i.exec(String(presented || ''));
+  if (!match) return '';
+  const ms = parseDurationTokenToMs(match[1]);
+  return Number.isFinite(ms)
+    ? `No progress ${compactDurationForStatus(ms, { preferMinutes: true })}`
+    : `No progress ${match[1]}`;
+}
+
+export function isBackgroundErrorOnlyBody(body, error = '') {
+  const trimmed = String(body ?? '').trim();
+  if (!trimmed) return false;
+  const err = String(error ?? '').trim();
+  const lines = trimmed.split('\n').map((line) => line.trim()).filter(Boolean);
+  if (lines.length !== 1) return false;
+  const line = lines[0];
+  if (/^error:\s*/i.test(line)) return true;
+  if (!err) return /^error:\s*/i.test(line);
+  const stripped = stripErrorPrefix(line);
+  const presented = presentErrorText(err, { max: 500 });
+  return line === err
+    || line === `Error: ${err}`
+    || stripped === err
+    || line === `Error: ${presented}`
+    || stripped === presented;
+}
+
 function subjectForSurface(surface) {
   const value = String(surface || '').toLowerCase();
   if (value.includes('search') || value.includes('web')) return 'web search agent';
-  if (value.includes('bridge') || value.includes('agent') || value.includes('task')) return 'agent';
+  if (value.includes('agent') || value.includes('task')) return 'agent';
   return 'tool';
 }
 
@@ -75,19 +142,26 @@ export function presentErrorText(error, options = {}) {
   text = oneLine(stripErrorPrefix(text));
   if (!text) return 'Unknown error';
 
-  if (/\bBRIDGE_CONTEXT_OVERFLOW\b|bridge context overflow|latest turn cannot fit|context budget|context window/i.test(text)) {
+  if (/\bAGENT_CONTEXT_OVERFLOW\b|agent context overflow|latest turn cannot fit|context budget|context window/i.test(text)) {
     return 'Context too large.';
   }
   if (/\bcompact(?:ion)?\b.*\b(?:failed|error|overflow)\b|\b(?:failed|error)\b.*\bcompact(?:ion)?\b/i.test(text)) {
     return 'Compact failed.';
   }
 
-  const firstResponse = /(?:bridge\s+)?first response stale\s*\((\d+)ms\)/i.exec(text);
+  const quotaRetry = /retryAfter=([^\s:]+)/i.exec(text);
+  if (/\b429\b|rate[_ -]?limit|quota|too many requests|resource exhausted|insufficient_quota|quota_exceeded/i.test(text)) {
+    const provider = /Anthropic OAuth/i.test(text) ? 'Anthropic' : 'Provider';
+    return `${provider} quota/rate limit hit${quotaRetry?.[1] ? `; retry after ${quotaRetry[1]}` : ''}.`;
+  }
+
+  const firstResponse = /(?:agent\s+)?first response stale\s*\((\d+)ms\)/i.exec(text);
   if (firstResponse) {
     return `No first response from the ${subject} within ${formatDurationMs(firstResponse[1])}.`;
   }
 
-  const stale = /bridge task stale\s*\((\d+)ms[^)]*\)/i.exec(text)
+  const stale = /agent (?:task|tool running) stale\s*\((\d+)ms[^)]*\)/i.exec(text)
+    || /tool running stale\s*\((\d+)ms[^)]*\)/i.exec(text)
     || /task stale\s*\((\d+)ms[^)]*\)/i.exec(text);
   if (stale) {
     return `The ${subject} went stale after ${formatDurationMs(stale[1])} without new stream/tool progress.`;
@@ -101,6 +175,10 @@ export function presentErrorText(error, options = {}) {
     return `${subject[0].toUpperCase()}${subject.slice(1)} stopped before the response completed.`;
   }
 
+  if (/^Session closed:\s*(?:closeSession|closed|aborted)\b/i.test(text)) {
+    return `${subject[0].toUpperCase()}${subject.slice(1)} stopped.`;
+  }
+
   if (/parent signal aborted/i.test(text)) {
     return `${subject[0].toUpperCase()}${subject.slice(1)} was cancelled by its caller.`;
   }
@@ -115,6 +193,55 @@ export function presentErrorText(error, options = {}) {
   return capText(text || 'Unknown error', max);
 }
 
+/**
+ * Compact `Failed · reason` label for background task/agent failure cards.
+ */
+export function backgroundTaskFailureStatusLabel(status, error, options = {}) {
+  const surface = options.surface || options.tool || '';
+  const raw = String(error ?? '').trim();
+  const statusNorm = String(status || '').trim().toLowerCase();
+  const terminal = /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(statusNorm);
+  if (!raw && !terminal) return '';
+
+  const presented = presentErrorText(error, { surface, max: 160 });
+  const watchdog = watchdogMsFromRawError(raw);
+
+  let head = 'Failed';
+  if (/^(cancelled|canceled)$/i.test(statusNorm)) head = 'Cancelled';
+  else if (
+    /^timeout$/i.test(statusNorm)
+    || watchdog?.kind === 'timeout'
+    || /first response stale/i.test(raw)
+    || /no first response from/i.test(presented)
+  ) head = 'Timeout';
+  else if (
+    watchdog?.kind === 'stale'
+    || /(?:agent )?(?:task|tool running) stale|went stale without/i.test(raw)
+    || /went stale after/i.test(presented)
+  ) head = 'Stale';
+
+  let reason = '';
+  if (/\bcontext too large\b/i.test(presented)) {
+    reason = 'Context too large';
+  } else if (head === 'Timeout') {
+    if (watchdog?.kind === 'timeout') {
+      reason = `No first response ${compactDurationForStatus(watchdog.ms)}`;
+    } else {
+      reason = compactReasonFromNormalizedTimeout(presented) || presented.replace(/\.$/, '');
+    }
+  } else if (head === 'Stale') {
+    if (watchdog?.kind === 'stale') {
+      reason = `No progress ${compactDurationForStatus(watchdog.ms, { preferMinutes: true })}`;
+    } else {
+      reason = compactReasonFromNormalizedStale(presented) || presented.replace(/\.$/, '');
+    }
+  } else {
+    reason = presented.replace(/\.$/, '');
+  }
+  if (!reason) return head;
+  return `${head} · ${reason}`;
+}
+
 export function errorLine(error, options = {}) {
   const text = presentErrorText(error, options);
   return /^error\s*:/i.test(text) ? text : `Error: ${text}`;

package/src/runtime/shared/llm/cost.mjs

@@ -1,5 +1,5 @@
 /**
- * Per-call cost estimator for bridge-trace usage rows.
+ * Per-call cost estimator for agent-trace usage rows.
  *
  * Pricing is pulled from the LiteLLM catalog (already warmed by providers/
  * agent bootstrap). All four token slots — input / output / cacheRead /
@@ -13,7 +13,7 @@
 
 import { getModelMetadataSync } from '../../agent/orchestrator/providers/model-catalog.mjs';
 
-// OpenAI / Codex / Gemini report `input_tokens` as the total prompt token
+// OpenAI OAuth / OpenAI API / Gemini report `input_tokens` as the total prompt token
 // count *including* the cached portion (inclusive). Anthropic reports the
 // uncached remainder only and bills cached_read / cached_write as separate
 // additive slots (additive). Cost and prompt-total math has to branch on this.

package/src/runtime/shared/llm/http-agent.mjs

@@ -66,7 +66,7 @@ function proxyConfigured() {
  * The shared singleton dispatcher for LLM API requests. Created on first use.
  *
  * keepAliveTimeout (~60s) keeps a socket warm across the typical idle gap
- * between bridge turns; connections caps concurrent sockets per origin so a
+ * between agent turns; connections caps concurrent sockets per origin so a
  * burst of parallel calls can't open an unbounded number of handshakes.
  *
  * Returns `undefined` when a proxy / any custom (non-default) global dispatcher
@@ -92,9 +92,19 @@ export function getLlmDispatcher() {
   return _globalInstalled ? undefined : _agent
 }
 
-// Origins already warmed (or warming) this process, so repeated provider
-// construction or multiple providers on the same host don't spam handshakes.
-const _preconnected = new Set()
+// Origins warmed (or warming) recently, with the timestamp of the last warm.
+// A time-based gate (instead of a permanent Set) lets us RE-warm a socket once
+// the kept-alive window has lapsed: a one-shot warm at provider construction
+// went cold after keepAliveTimeout (~60s idle between turns), so the first
+// request after a pause paid the full TLS handshake again. Re-warming just
+// before a turn keeps the hot-path send on a live socket.
+const _preconnectedAt = new Map()
+// Re-warm cadence: slightly below the keep-alive window so a socket is renewed
+// before it can lapse. Capped so an explicit short keepAlive still re-warms.
+function _preconnectTtlMs() {
+  const keepAlive = envInt('MIXDOG_LLM_KEEPALIVE_MS', 60_000)
+  return Math.max(5_000, keepAlive - 10_000)
+}
 
 /**
  * Best-effort warm a kept-alive socket to `origin` so the first real request
@@ -113,8 +123,10 @@ export function preconnect(origin) {
     try { url = new URL(origin) } catch { return }
     if (url.protocol !== 'https:' && url.protocol !== 'http:') return
     const key = url.origin
-    if (_preconnected.has(key)) return
-    _preconnected.add(key)
+    const now = Date.now()
+    const last = _preconnectedAt.get(key) || 0
+    if (now - last < _preconnectTtlMs()) return
+    _preconnectedAt.set(key, now)
     // A throwaway HEAD lands a pooled socket without fetching a body. Any
     // failure (offline, DNS, 4xx/5xx) is irrelevant — the handshake is the
     // point, and the real request will surface genuine errors.
@@ -124,6 +136,10 @@ export function preconnect(origin) {
       signal: AbortSignal.timeout(10_000),
     })
       .then((res) => res.body?.dump?.())
-      .catch(() => { /* best-effort warmup; ignore */ })
+      .catch(() => {
+        // Warm failed — clear the timestamp so the next call can retry instead
+        // of waiting out the full TTL on a connection that never landed.
+        _preconnectedAt.delete(key)
+      })
   } catch { /* never let warmup break construction */ }
 }

package/src/runtime/shared/llm/index.mjs

@@ -2,8 +2,8 @@
  * Shared LLM helpers (post v0.6.46).
  *
  * The legacy `callLLM` dispatcher and direct CLI/HTTP runners have been
- * removed — every LLM call now flows through `bridge-llm.mjs`
- * (`makeBridgeLlm({ taskType })`) and, for memory maintenance specifically,
+ * removed — every LLM call now flows through `agent-dispatch.mjs`
+ * (`makeAgentDispatch({ taskType })`) and, for memory maintenance specifically,
  * through `maintenance-llm.mjs`'s thin wrapper.
  *
  * Only preset resolution remains here: memory-cycle and future backend
@@ -24,18 +24,41 @@ function loadAgentConfig() {
 }
 
 /**
- * Resolve maintenance preset ID for a given task from agent-config.
- * Falls back to canonical defaults (DEFAULT_MAINTENANCE from config.mjs).
- * Returns null if no matching preset is registered (lets callers skip the call).
+ * Resolve the maintenance model ROUTE for a given task from agent-config.
+ *
+ * Maintenance slots now store a direct `{provider, model, effort?, fast?}`
+ * route (parity with `agents.<role>`). This returns that route object. For
+ * backward compatibility a slot still holding a legacy preset-NAME string is
+ * resolved against config.presets and returned as a route. Falls back to the
+ * canonical DEFAULT_MAINTENANCE route. Returns null only when nothing resolves.
+ *
+ * The returned value is passed straight through as `opts.preset` to
+ * makeAgentDispatch, whose resolveMaintenanceRoute()/maintenanceRouteToPreset()
+ * accept either a route object or a legacy name string.
  */
 export function resolveMaintenancePreset(task, agentConfig) {
   const cfg = agentConfig || loadAgentConfig()
   const maint = cfg?.maintenance || {}
-  const presetId = maint[task] || DEFAULT_MAINTENANCE[task]
   const presets = cfg?.presets || []
-  if (presets.some(p => p.id === presetId || p.name === presetId)) return presetId
-  // No registered preset found — return the first available preset id so callers
-  // always receive a real id, or null if the presets list is empty.
-  const first = presets.find(p => p?.id || p?.name)
-  return first ? (first.id || first.name) : null
+  const slot = maint[task]
+  // Preferred: slot already holds a direct route object.
+  if (slot && typeof slot === 'object' && !Array.isArray(slot)
+      && slot.provider && slot.model) {
+    return { ...slot }
+  }
+  // Legacy: slot holds a preset-NAME string — resolve it to a route.
+  const name = String(slot || '').trim()
+  if (name) {
+    const preset = presets.find(p => p && (p.id === name || p.name === name))
+    if (preset && preset.provider && preset.model) {
+      const route = { provider: preset.provider, model: preset.model }
+      if (preset.effort) route.effort = preset.effort
+      if (preset.fast === true) route.fast = true
+      return route
+    }
+  }
+  // Canonical default route (DEFAULT_MAINTENANCE is now route-shaped).
+  const def = DEFAULT_MAINTENANCE[task]
+  if (def && def.provider && def.model) return { ...def }
+  return null
 }

package/src/runtime/shared/llm/usage-log.mjs

@@ -1,13 +1,13 @@
 /**
  * Unified LLM usage logger.
  *
- * Phase 2: Routes via appendBridgeTrace (HTTP buffer to memory-service)
- * instead of writing directly to bridge-trace.jsonl.
+ * Phase 2: Routes via appendAgentTrace (HTTP buffer to memory-service)
+ * instead of writing directly to the local trace jsonl.
  *
  * Signature unchanged — callers are unaffected.
  */
 
-import { appendBridgeTrace } from '../../agent/orchestrator/bridge-trace.mjs';
+import { appendAgentTrace } from '../../agent/orchestrator/agent-trace.mjs';
 
 /**
  * Append a usage entry to the trace store.
@@ -34,7 +34,7 @@ function warnMissingProviderOnce(key) {
 export function logLlmCall(entry, opts = {}) {
     try {
         if (!entry.provider) warnMissingProviderOnce(entry.model || '?');
-        appendBridgeTrace({
+        appendAgentTrace({
             ts: entry.ts || Date.now(),
             kind: 'usage',
             ...entry,

package/src/runtime/shared/markdown-frontmatter.mjs

@@ -0,0 +1,56 @@
+const FRONTMATTER_RE = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+
+const AGENT_PERMISSION_ALIASES = new Map([
+  ['none', 'none'],
+  ['readonly', 'read'],
+  ['read-only', 'read'],
+  ['read', 'read'],
+  ['write', 'read-write'],
+  ['readwrite', 'read-write'],
+  ['read_write', 'read-write'],
+  ['read-write', 'read-write'],
+  ['mcp', 'mcp'],
+  ['full', 'full'],
+]);
+
+function clean(value) {
+  return String(value ?? '').trim();
+}
+
+function unquote(value) {
+  return clean(value).replace(/^['"]|['"]$/g, '').trim();
+}
+
+export function parseMarkdownFrontmatter(markdown) {
+  const match = String(markdown || '').match(FRONTMATTER_RE);
+  if (!match) return {};
+  const meta = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
+    if (!kv) continue;
+    meta[kv[1]] = unquote(kv[2]);
+  }
+  return meta;
+}
+
+export function stripMarkdownFrontmatter(markdown) {
+  return String(markdown || '').replace(FRONTMATTER_RE, '').trim();
+}
+
+export function readMarkdownDocument(markdown) {
+  return {
+    frontmatter: parseMarkdownFrontmatter(markdown),
+    body: stripMarkdownFrontmatter(markdown),
+  };
+}
+
+export function normalizeAgentPermission(value) {
+  const key = clean(value).toLowerCase();
+  return AGENT_PERMISSION_ALIASES.get(key) || null;
+}
+
+export function normalizeAgentPermissionOrNone(value) {
+  const raw = clean(value);
+  if (!raw) return null;
+  return normalizeAgentPermission(raw) || 'none';
+}

package/src/runtime/shared/singleton-owner.mjs

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export function isPidAlive(pid) {
+  const n = Number(pid);
+  if (!Number.isInteger(n) || n <= 0) return false;
+  try {
+    process.kill(n, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function readJson(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonAtomic(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`);
+  renameSync(tmp, path);
+}
+
+function waitSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {}
+}
+
+function acquireClaimLock(path) {
+  const lockPath = `${path}.claim.lock`;
+  for (let i = 0; i < 20; i++) {
+    try {
+      mkdirSync(lockPath, { recursive: false });
+      return lockPath;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      try {
+        const ageMs = Date.now() - statSync(lockPath).mtimeMs;
+        if (ageMs > 5000) {
+          rmSync(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch {}
+      waitSync(25);
+    }
+  }
+  return null;
+}
+
+export function readSingletonOwner(path) {
+  const owner = readJson(path);
+  if (!owner || typeof owner !== 'object') return { owner: null, alive: false };
+  return { owner, alive: isPidAlive(owner.pid) };
+}
+
+export function claimSingletonOwner(path, {
+  kind = 'runtime',
+  pid = process.pid,
+  meta = {},
+} = {}) {
+  const owner = {
+    kind,
+    pid,
+    claimedAt: new Date().toISOString(),
+    ...meta,
+  };
+
+  const current = readJson(path);
+  if (current?.pid && Number(current.pid) !== Number(pid) && isPidAlive(current.pid)) {
+    return { owned: false, owner: current };
+  }
+
+  const lockPath = acquireClaimLock(path);
+  if (!lockPath) return { owned: false, owner: readJson(path) };
+  try {
+    const lockedCurrent = readJson(path);
+    if (lockedCurrent?.pid && Number(lockedCurrent.pid) !== Number(pid) && isPidAlive(lockedCurrent.pid)) {
+      return { owned: false, owner: lockedCurrent };
+    }
+    writeJsonAtomic(path, owner);
+    return { owned: true, owner };
+  } finally {
+    rmSync(lockPath, { recursive: true, force: true });
+  }
+}
+
+export function releaseSingletonOwner(path, pid = process.pid) {
+  const current = readJson(path);
+  if (!current?.pid || Number(current.pid) !== Number(pid)) return false;
+  try {
+    rmSync(path, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}