mixdog 0.9.18 → 0.9.19

package/src/runtime/shared/tool-result-summary.mjs

@@ -74,7 +74,7 @@ export function formatLineDelta(totals) {
 }
 
 export function parseUpdateSummary(text) {
-  const match = /^(Updated|Created|Deleted)\s+(.+?)(?:\s+·\s+|$)/i.exec(String(text || '').trim());
+  const match = /^(Updated|Created|Deleted|Checked)\s+(.+?)(?:\s+·\s+|$)/i.exec(String(text || '').trim());
   if (!match) return null;
   const action = titleWord(match[1]);
   const target = match[2].trim();

package/src/runtime/shared/tool-surface.mjs

@@ -703,7 +703,36 @@ export function formatAggregateDetail(summaries) {
     }
 
     const update = parseUpdateSummary(text);
-    if (update) {
+    // Dry-run patch checks ("Checked foo.js · +7 -5") are validations, not
+    // edits: their line delta must NEVER be summed into the real edit total.
+    // They get their own metric so repeated checks still merge; the preview
+    // delta is shown only when the card has no real edit delta it could be
+    // confused with. Delta-less "Checked ..." texts (task/memory summaries)
+    // fall through to extras unchanged.
+    if (update && update.action === 'Checked') {
+      if (update.seen) {
+        const metric = addMetric('checked_files', {
+          files: new Set(),
+          fileCount: 0,
+          added: 0,
+          removed: 0,
+          seen: false,
+          render: (m) => {
+            const count = m.fileCount + m.files.size;
+            const target = count === 1 && m.fileCount === 0 ? [...m.files][0] : `${count} ${pluralize(count, 'file')}`;
+            const editDelta = formatLineDelta(metrics.get('updated_files'));
+            const delta = editDelta ? '' : formatLineDelta(m);
+            return delta ? `Checked ${target} · ${delta}` : `Checked ${target}`;
+          },
+        });
+        if (update.file) metric.files.add(update.file);
+        metric.fileCount += update.fileCount;
+        metric.added += update.added;
+        metric.removed += update.removed;
+        metric.seen = metric.seen || update.seen;
+        continue;
+      }
+    } else if (update) {
       const metric = addMetric('updated_files', {
         files: new Set(),
         fileCount: 0,

package/src/session-runtime/config-lifecycle.mjs

@@ -58,7 +58,7 @@ export function createConfigLifecycle({
     ) {
       return outputStyleStatusCache;
     }
-    outputStyleStatusCache = outputStyleStatus(dataDir);
+    outputStyleStatusCache = outputStyleStatus(dataDir, { fresh });
     outputStyleStatusCacheAt = now;
     outputStyleStatusCacheDir = cacheDir;
     return outputStyleStatusCache;

package/src/session-runtime/cwd-plugins.mjs

@@ -45,6 +45,48 @@ export function createCwdPlugins({
   cfgMod,
   STANDALONE_DATA_DIR,
 }) {
+  // Per-plugin-root caches for pluginsStatus(): manifest + MCP discovery keyed
+  // by root path + manifest mtime (invalidated on manifest edit); recursive
+  // skill-file count keyed by root with a ~5s TTL fallback (the walk has no
+  // single mtime to key on).
+  const pluginRootCache = new Map();
+  const skillCountCache = new Map();
+  const mcpDiscoveryCache = new Map();
+  function manifestMtimeKey(root) {
+    let key = '';
+    for (const rel of ['.codex-plugin/plugin.json', 'plugin.json']) {
+      try { key += `${statSync(resolve(root, rel)).mtimeMs}:`; } catch { key += '0:'; }
+    }
+    return key;
+  }
+  function cachedPluginData(root) {
+    const key = manifestMtimeKey(root);
+    const hit = pluginRootCache.get(root);
+    if (hit && hit.key === key) return hit;
+    const entry = { key, manifest: pluginManifest(root) };
+    pluginRootCache.set(root, entry);
+    return entry;
+  }
+  // MCP discovery probes candidate script files (.mcp.json, scripts/run-mcp.mjs,
+  // ...) whose add/remove is NOT reflected in the manifest mtime, so key it on a
+  // short TTL instead (~5s, like the skill-file count).
+  function cachedMcpDiscovery(root) {
+    const now = Date.now();
+    const hit = mcpDiscoveryCache.get(root);
+    if (hit && (now - hit.at) < 5000) return hit.mcp;
+    const mcp = discoverPluginMcp(root);
+    mcpDiscoveryCache.set(root, { at: now, mcp });
+    return mcp;
+  }
+  function cachedSkillCount(root) {
+    const now = Date.now();
+    const hit = skillCountCache.get(root);
+    if (hit && (now - hit.at) < 5000) return hit.count;
+    const count = countSkillFiles(root);
+    skillCountCache.set(root, { at: now, count });
+    return count;
+  }
+
   function resolveCwdPath(value) {
     const raw = clean(value);
     if (!raw) throw new Error('cwd: path is required for action=set');
@@ -125,7 +167,8 @@ export function createCwdPlugins({
     const addRegisteredPlugin = (entry) => {
       const root = clean(entry.root);
       if (!root || !existsSync(root)) return;
-      const manifest = pluginManifest(root);
+      const cached = cachedPluginData(root);
+      const manifest = cached.manifest;
       const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
       const plugin = {
         id: clean(entry.id) || name,
@@ -141,9 +184,9 @@ export function createCwdPlugins({
         root,
         installedAt: entry.installedAt || null,
         updatedAt: entry.updatedAt || null,
-        skillCount: countSkillFiles(root),
+        skillCount: cachedSkillCount(root),
         ...(() => {
-          const { mcpScript, mcpInline } = discoverPluginMcp(root);
+          const { mcpScript, mcpInline } = cachedMcpDiscovery(root);
           return { mcpScript, mcpInline };
         })(),
       };

package/src/session-runtime/mcp-glue.mjs

@@ -4,9 +4,30 @@
 // `state` object so the facade's teardown/reconnect paths still observe it.
 // Method behavior is byte-for-byte identical; only grouping changes.
 import { resolve } from 'node:path';
+import { statSync } from 'node:fs';
 import { clean } from './session-text.mjs';
 import { readProjectMcpServers } from './plugin-mcp.mjs';
 
+// Cache project-local `.mcp.json` reads by path + mtime so repeated mcpStatus()
+// calls skip existsSync+readFileSync+JSON.parse when the file is unchanged.
+// Invalidated automatically on any mtime change (or create/delete via mtime=0).
+const projectMcpCache = new Map();
+const PROJECT_MCP_CACHE_MAX = 32;
+function cachedProjectMcpServers(cwd) {
+  const path = resolve(cwd || '.', '.mcp.json');
+  let mtimeMs = 0;
+  try { mtimeMs = statSync(path).mtimeMs; } catch { mtimeMs = 0; }
+  const hit = projectMcpCache.get(path);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.value;
+  const value = readProjectMcpServers(cwd);
+  // Bound the cache: Map preserves insertion order, so drop the oldest entry.
+  if (!projectMcpCache.has(path) && projectMcpCache.size >= PROJECT_MCP_CACHE_MAX) {
+    projectMcpCache.delete(projectMcpCache.keys().next().value);
+  }
+  projectMcpCache.set(path, { mtimeMs, value });
+  return value;
+}
+
 export function createMcpGlue({
   mcpClient,
   getConfig,
@@ -23,15 +44,15 @@ export function createMcpGlue({
   }
 
   // Merge mixdog-config `agent.mcpServers` with project-local `.mcp.json`.
-  // On name collision the project-local `.mcp.json` entry WINS (Claude Code
-  // precedence: project > user config). `sources[name]` records each server's
+  // On name collision the project-local `.mcp.json` entry WINS
+  // (precedence: project > user config). `sources[name]` records each server's
   // origin ('config' | 'project') for status reporting.
   function resolveEffectiveMcpServers() {
     const config = getConfig();
     const configured = config?.mcpServers && typeof config.mcpServers === 'object'
       ? config.mcpServers
       : {};
-    const project = readProjectMcpServers(getCurrentCwd());
+    const project = cachedProjectMcpServers(getCurrentCwd());
     const servers = { ...configured, ...project };
     const sources = {};
     for (const name of Object.keys(configured)) sources[name] = 'config';

package/src/session-runtime/output-styles.mjs

@@ -1,7 +1,7 @@
 // Output-style catalog + metadata parsing. Roots are injected so this module
 // stays free of the runtime's path constants.
 import { basename, join } from 'node:path';
-import { readFileSync, readdirSync } from 'node:fs';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { clean } from './session-text.mjs';
 import { readJsonSafe } from './fs-utils.mjs';
 
@@ -55,7 +55,7 @@ function parseOutputStyleFrontmatter(markdown) {
   return meta;
 }
 
-function readOutputStyleMetadata(filePath, source) {
+function computeOutputStyleMetadata(filePath, source) {
   let raw = '';
   try { raw = readFileSync(filePath, 'utf8'); } catch { return null; }
   const meta = parseOutputStyleFrontmatter(raw);
@@ -76,18 +76,52 @@ function readOutputStyleMetadata(filePath, source) {
   };
 }
 
-export function listOutputStyleCatalog(rootDir, dataDir) {
+// Per-file metadata cache keyed by path + mtime, and a per-directory listing
+// cache keyed by dir mtime — repeated catalog reads skip readdir/readFile when
+// nothing changed. File content edits (unchanged dir mtime) are still caught by
+// the per-file mtime check.
+const styleFileCache = new Map();
+function readOutputStyleMetadata(filePath, source) {
+  let mtimeMs = 0;
+  try { mtimeMs = statSync(filePath).mtimeMs; } catch { mtimeMs = 0; }
+  const hit = styleFileCache.get(filePath);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.value;
+  const value = computeOutputStyleMetadata(filePath, source);
+  styleFileCache.set(filePath, { mtimeMs, value });
+  return value;
+}
+
+const styleDirCache = new Map();
+function listStyleDirFiles(dir, fresh = false) {
+  let mtimeMs = 0;
+  try { mtimeMs = statSync(dir).mtimeMs; } catch { return null; }
+  if (!fresh) {
+    const hit = styleDirCache.get(dir);
+    if (hit && hit.mtimeMs === mtimeMs) return hit.files;
+  }
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return null; }
+  const files = entries
+    .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith('.md'))
+    .map((entry) => entry.name);
+  styleDirCache.set(dir, { mtimeMs, files });
+  return files;
+}
+
+export function listOutputStyleCatalog(rootDir, dataDir, { fresh = false } = {}) {
   const byId = new Map();
   const dirs = [
     { dir: join(rootDir, 'output-styles'), source: 'builtin' },
     { dir: join(dataDir, 'output-styles'), source: 'user' },
   ];
   for (const { dir, source } of dirs) {
-    let entries = [];
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) continue;
-      const style = readOutputStyleMetadata(join(dir, entry.name), source);
+    // Forced-fresh (e.g. setOutputStyle) bypasses the dir-listing cache so a
+    // just-added/removed .md is always seen; per-file metadata still reuses the
+    // path+mtime cache below.
+    const files = listStyleDirFiles(dir, fresh);
+    if (!files) continue;
+    for (const name of files) {
+      const style = readOutputStyleMetadata(join(dir, name), source);
       if (style) byId.set(style.id, style);
     }
   }
@@ -115,8 +149,8 @@ function configuredOutputStyleValue(dataDir) {
   return clean(unified.outputStyle || (unified.agent && unified.agent.outputStyle) || 'default') || 'default';
 }
 
-export function outputStyleStatus(rootDir, dataDir) {
-  const styles = listOutputStyleCatalog(rootDir, dataDir);
+export function outputStyleStatus(rootDir, dataDir, { fresh = false } = {}) {
+  const styles = listOutputStyleCatalog(rootDir, dataDir, { fresh });
   const configured = configuredOutputStyleValue(dataDir);
   const current = findOutputStyle(configured, styles)
     || findOutputStyle('default', styles)

package/src/session-runtime/workflow.mjs

@@ -201,7 +201,10 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
   }
 
   function workflowContextBlock(config, dir) {
-    const pack = loadWorkflowPack(dir, activeWorkflowId(config));
+    return workflowContextBlockFromPack(loadWorkflowPack(dir, activeWorkflowId(config)), dir);
+  }
+
+  function workflowContextBlockFromPack(pack, dir) {
     if (!pack) return '';
     const lines = [`# Active Workflow: ${pack.name}`];
     if (pack.description) lines.push(pack.description);
@@ -219,6 +222,17 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
     return lines.join('\n\n');
   }
 
+  // Single-pass variant: loads the active WORKFLOW.md pack once and derives both
+  // the summary and the context block from it, so session-create does not re-read
+  // and re-parse WORKFLOW.md twice on the hot boot path.
+  function activeWorkflowContext(config, dir) {
+    const pack = loadWorkflowPack(dir, activeWorkflowId(config));
+    return {
+      summary: workflowSummary(pack),
+      context: workflowContextBlockFromPack(pack, dir),
+    };
+  }
+
   return {
     listWorkflowPacks,
     activeWorkflowId,
@@ -227,6 +241,7 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
     activeWorkflowSummary,
     loadAgentDefinition,
     workflowContextBlock,
+    activeWorkflowContext,
   };
 }
 

package/src/standalone/channel-worker.mjs

@@ -1,5 +1,5 @@
 import { execFile, fork, spawnSync } from 'node:child_process';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, rmSync, writeFile } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -25,6 +25,9 @@ const WORKER_PRELOAD = fileURLToPath(new URL('./channel-worker-preload.cjs', imp
 // surfacing the failure to callers.
 const WORKER_BOOT_MAX_ATTEMPTS = 2;
 const WORKER_BOOT_RETRY_DELAY_MS = 1000;
+// Fail an in-flight IPC send whose flush callback never fires (wedged channel)
+// so the FIFO send queue can't stall permanently on one stuck message.
+const SEND_FLUSH_TIMEOUT_MS = 10_000;
 
 function logLine(path, line) {
   try {
@@ -83,21 +86,39 @@ export function createStandaloneChannelWorker({
   let parentExitCleanup = null;
   const pending = new Map();
   const ownedChildPids = new Set();
+  // Strict-FIFO backpressure queue for child IPC. child.send returns false
+  // when the channel is over its backpressure threshold; we keep at most one
+  // send in flight and only dispatch the next once the prior send's flush
+  // callback fires, so bursts don't unboundedly buffer and order is preserved.
+  const sendQueue = [];
+  let sendInFlight = false;
+  // Guards the single in-flight send: the token invalidates a stale settler
+  // (flush callback / watchdog / rejectPending) so only the first one to fire
+  // releases the slot; the watchdog handle lets rejectPending cancel it.
+  let inFlightToken = 0;
+  let inFlightWatchdog = null;
   const logPath = join(dataDir, 'channels-worker-standalone.log');
   const useProcessWorker = process.env.MIXDOG_CHANNEL_WORKER_PROCESS !== '0';
   const clientDir = join(runtimeRoot(), 'channel-clients');
   const clientPath = join(clientDir, `${process.pid}.json`);
   let clientHeartbeatTimer = null;
   let clientHeartbeatExitCleanup = null;
+  let clientDirReady = false;
 
   function writeClientHeartbeat() {
+    // Must write every tick: liveness readers key off the file's rolling
+    // mtime/updatedAt, so an unchanged-skip would make the client look dead.
+    // mkdir once and write async to keep the 5s interval off the sync-fs path.
     try {
-      mkdirSync(clientDir, { recursive: true });
-      writeFileSync(clientPath, JSON.stringify({
+      if (!clientDirReady) {
+        mkdirSync(clientDir, { recursive: true });
+        clientDirReady = true;
+      }
+      writeFile(clientPath, JSON.stringify({
         pid: process.pid,
         cwd,
         updatedAt: Date.now(),
-      }));
+      }), () => {});
     } catch {}
   }
 
@@ -147,6 +168,54 @@ export function createStandaloneChannelWorker({
       item.reject(error);
     }
     pending.clear();
+    // Fail any sends still queued/in-flight for the now-dead channel so their
+    // callers unblock instead of waiting on a flush callback that never fires.
+    // Invalidate + disarm the in-flight watchdog so it can't later flip
+    // sendInFlight under a freshly-started send (its owning call was already
+    // rejected via the pending map above).
+    inFlightToken++;
+    if (inFlightWatchdog) { clearTimeout(inFlightWatchdog); inFlightWatchdog = null; }
+    sendInFlight = false;
+    while (sendQueue.length) {
+      const item = sendQueue.shift();
+      try { item.cb?.(error); } catch {}
+    }
+  }
+
+  // Dispatch queued IPC sends one at a time, gating the next on the current
+  // send's flush callback so child.send backpressure (false return) is honored.
+  function drainSendQueue() {
+    if (sendInFlight) return;
+    const item = sendQueue.shift();
+    if (!item) return;
+    if (!child || !child.send) {
+      try { item.cb?.(new Error('channels worker is not running')); } catch {}
+      drainSendQueue();
+      return;
+    }
+    sendInFlight = true;
+    const token = ++inFlightToken;
+    // Settle exactly once, whichever of {flush callback, watchdog} fires first;
+    // a stale token (superseded by rejectPending or the sibling) is ignored.
+    const finish = (error) => {
+      if (token !== inFlightToken) return;
+      inFlightToken++;
+      if (inFlightWatchdog) { clearTimeout(inFlightWatchdog); inFlightWatchdog = null; }
+      sendInFlight = false;
+      try { item.cb?.(error); } catch {}
+      drainSendQueue();
+    };
+    // Watchdog: if the flush callback never fires (wedged IPC channel), fail
+    // this request via its normal rejection path and keep draining so a single
+    // stuck send can't wedge the queue forever.
+    inFlightWatchdog = setTimeout(() => finish(new Error('channels worker send timed out')), SEND_FLUSH_TIMEOUT_MS);
+    inFlightWatchdog.unref?.();
+    child.send(item.msg, (error) => finish(error));
+  }
+
+  function sendToChild(msg, cb) {
+    sendQueue.push({ msg, cb });
+    drainSendQueue();
   }
 
   function start() {
@@ -298,7 +367,7 @@ export function createStandaloneChannelWorker({
         reject(new Error(`channels tool timed out: ${name}`));
       }, timeoutMs);
       pending.set(callId, { resolve, reject, timer });
-      child.send({ type: 'call', callId, name, args: args || {} }, (error) => {
+      sendToChild({ type: 'call', callId, name, args: args || {} }, (error) => {
         if (!error) return;
         pending.delete(callId);
         clearTimeout(timer);

package/src/standalone/explore-tool.mjs

@@ -70,7 +70,7 @@ function escapeXml(str) {
 // reminder. The full no-verdict contract lives at system level
 // (rules/agent/30-explorer.md).
 export function buildExplorerPrompt(query) {
-  return `<query>${escapeXml(query)}</query>\nReminder: RULE ZERO is a binary gate after every tool result: >=1 path:line matching a SPECIFIC query token (product/library/domain name) -> answer NOW with those exact coordinates; zero -> one more batch if budget remains. A generic-word-only match (schema, handler, config, resolver, index, error...) while the query's specific tokens match nowhere counts as ZERO, not a hit. There is no third branch: "hits exist but I want better ones" IS branch one — answer now. Credibility is mechanical (specific-token match), never judged: "is this the real implementation / final handler / just a wrapper" are caller questions, FORBIDDEN here; mark weak anchors ? and answer anyway. Flow/how/trigger queries: first matching definition/entry anchors ARE the complete answer — never trace the chain, one anchor per concept. You locate WHERE, never WHY. HARD max 3 tool turns; counter line (turn 1/3, turn 2/3, turn 3/3) on every tool message; expected shape is turn 1 -> answer, turns 2-3 are miss-recovery only (previous turn had ZERO matching lines), with changed tokens or scope; after turn 3/3 you MUST answer best-so-far. Each turn = ONE maximal batch: a single grep whose pattern[] packs ALL token variants PLUS code_graph/find/glob in the SAME message; a single-tool turn is a wasted turn. EXPLORATION_FAILED only after all 3 turns found zero anchors. Final check before emitting: at least ONE anchor must contain a specific query token — if every anchor matches only generic words, output EXPLORATION_FAILED instead; a plausible-looking wrong anchor is worse than an honest miss. Output only anchor lines formatted as path:line — symbol/name — short reason, or EXPLORATION_FAILED. No preamble, bullets, numbering, headings, summary, code quotes, analysis, verdicts, ratings, or recommendations.`;
+  return `<query>${escapeXml(query)}</query>\nReminder: RULE ZERO is a binary gate after every tool result: >=1 path:line matching a SPECIFIC query token (product/library/domain name) -> answer NOW with those exact coordinates; zero -> one more batch if budget remains. A generic-word-only match (schema, handler, config, resolver, index, error...) while the query's specific tokens match nowhere counts as ZERO, not a hit. There is no third branch: "hits exist but I want better ones" IS branch one — answer now. A code_graph symbol hit (find_symbol/symbol_search returning path:line) IS an anchor — emit it directly, never re-locate it with grep. Credibility is mechanical (specific-token match), never judged: "is this the real implementation / final handler / just a wrapper" are caller questions, FORBIDDEN here; mark weak anchors ? and answer anyway. Flow/how/trigger queries: first matching definition/entry anchors ARE the complete answer — never trace the chain, one anchor per concept. You locate WHERE, never WHY. Scope is ALWAYS the session working directory: omit path or pass only a path seen in an earlier result; inventing a directory (/workspace/..., another repo's layout) is a defect — on zero hits change TOKENS, never guess paths. HARD max 3 tool turns; counter line (turn 1/3, turn 2/3, turn 3/3) on every tool message; expected shape is turn 1 -> answer, turns 2-3 are miss-recovery only (previous turn had ZERO matching lines), with changed tokens; after turn 3/3 you MUST answer best-so-far. Each turn = ONE maximal batch: a single grep whose pattern[] packs ALL token variants PLUS code_graph/find/glob in the SAME message; a single-tool turn is a wasted turn. Before emitting EXPLORATION_FAILED re-scan ALL earlier results: any line matching a specific query token -> answer with that anchor (? if weak) — a weak anchor beats a false miss; EXPLORATION_FAILED only when all 3 turns found zero token-matching lines. Output only anchor lines formatted as path:line — symbol/name — short reason, max 3 lines, or EXPLORATION_FAILED. No preamble, bullets, numbering, headings, summary, code quotes, analysis, verdicts, ratings, or recommendations.`;
 }
 
 export function normalizeExploreQueries(rawQuery) {