mixdog 0.9.124 → 0.9.126

package/LICENSES/codex-NOTICE.txt

@@ -4,3 +4,6 @@ Copyright 2025 OpenAI
 This project includes code derived from [Ratatui](https://github.com/ratatui/ratatui), licensed under the MIT license.
 Copyright (c) 2016-2022 Florian Dehau
 Copyright (c) 2023-2025 The Ratatui Developers
+
+The native fuzzy-search architecture is derived from OpenAI Codex file search,
+licensed under the Apache License 2.0.

package/LICENSES/ripgrep-NOTICE.txt

@@ -0,0 +1,6 @@
+This project includes code from ripgrep's grep library crates,
+licensed under the MIT License or the Unlicense.
+
+Copyright (c) 2015 Andrew Gallant
+
+See LICENSES/MIT.txt for the MIT license text.

package/README.md

@@ -97,8 +97,8 @@ every number above live under `benchmarks/terminal-bench-2.1/`.
 **Any environment**
 
 - Full-screen TUI with slash commands, provider setup, model/workflow
-  pickers, statusline integration, and detailed tool cards — plus headless
-  role mode for scripting.
+  pickers, statusline integration, and detailed tool cards — plus `exec`
+  mode for headless scripting.
 - Mixdog Desktop: a full agent workbench for Windows/macOS/Linux (see
   below).
 - Installable web app over relay pairing — scan a QR code to open your
@@ -156,16 +156,22 @@ mixdog --remote
 mixdog --onboarding
 ```
 
-Headless role mode is also supported. It requires an explicit
-provider/model pair and runs with ephemeral config — host behavioral config
-and personal state are not loaded:
+Headless `exec` is also supported. It runs one non-interactive primary-model
+session and requires an explicit provider/model pair. Ephemeral config keeps
+host behavioral config and personal state out of the run:
 
 ```bash
-mixdog --provider anthropic-oauth --model claude-opus-5 worker "fix the failing test"
-mixdog --provider openai-oauth --model gpt-5.6-sol reviewer "review the current diff"
+mixdog exec --provider anthropic-oauth --model claude-opus-5 "fix the failing test"
+mixdog exec --provider openai-oauth --model gpt-5.6-sol --effort xhigh --fast "review the current diff"
+mixdog exec --provider openai-oauth --model gpt-5.6-sol --json "fix the failing test"
 ```
 
-Roles: `worker`, `heavy-worker`, `reviewer`, `maintainer`, `web-researcher`.
+`--json` emits timestamped JSONL. The stream contains thread/turn lifecycle,
+provider request timing, reasoning and assistant messages, tool start/completion
+with arguments/output and queue/dispatch/execution/batch-wait/postprocess timing,
+background notifications, final usage, and a
+terminal success/error result. Without `--json`, stdout remains final text only.
+In JSON mode stdout is JSONL-only; runtime diagnostics remain on stderr.
 
 ## TUI basics
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.124",
+  "version": "0.9.126",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -55,14 +55,17 @@
     "smoke:loop": "node scripts/smoke-loop.mjs",
     "smoke:loop:final": "node scripts/smoke-loop-report.mjs --require-complete --min-elapsed 5h --min-iterations 400 --max-gap 60s --max-smoke-ms 10000 --max-avg-smoke-ms 8500 --max-step-ms smoke.mjs=4000 --max-step-ms boot-smoke.mjs=8000 --max-rss-mb 140 --max-rss-growth-mb 50",
     "smoke:loop:report": "node scripts/smoke-loop-report.mjs",
-    "test:tool-contracts": "node scripts/tool-smoke.mjs",
+    "build:spawn:test": "cargo build --locked --manifest-path native/mixdog-spawn/Cargo.toml",
+    "test:tool-contracts": "npm run build:spawn:test && node scripts/tool-smoke.mjs",
     "smoke:patch": "node scripts/apply-patch-edit-smoke.mjs",
-    "test:shellhardening": "node --test scripts/suite-shellhardening-test.mjs",
+    "test:shellhardening": "npm run build:spawn:test && node --test scripts/suite-shellhardening-test.mjs scripts/suite-shell-direct-exe-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs scripts/provider-contract-test.mjs scripts/provider-stream-outcome-test.mjs",
     "test:embedding-runtime:warmup": "node scripts/verify-embedding-runtime.mjs --warmup",
     "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/release-gate-test.mjs && node --test scripts/release-gate-test.mjs",
+    "test:native-edit-wire": "node scripts/native-edit-wire-test.mjs",
     "test:release-focused": "npm run test:release-critical && npm run test:compact && npm run test:shellhardening && npm run test:tool-contracts && npm run test:session && npm run test:session-transport",
     "test:release-critical": "npm run test:release-assets && npm run smoke:patch && npm run test:providers",
+    "test:spec-advisory": "node scripts/advisory-spec-test.mjs && npm run test:spec-advisory --prefix apps/desktop",
     "test:session-transport": "node --test scripts/session-transport-test.mjs scripts/daemon-bootstrap-test.mjs",
     "test:session": "node --test scripts/runtime-turn-contract-test.mjs scripts/session-save-fault-store-test.mjs",
     "test:media": "node --test src/runtime/media/store.test.mjs src/runtime/media/renditions.test.mjs src/runtime/media/adapters/codex-image.test.mjs",
@@ -76,6 +79,8 @@
     "bench:corpus": "node scripts/routing-corpus.mjs",
     "bench:run": "node scripts/bench-run.mjs",
     "bench:recall": "node scripts/recall-bench.mjs",
+    "bench:recall:strict": "node scripts/recall-bench.mjs --strict",
+    "test:recall-validator": "node --test scripts/recall-bench-test.mjs",
     "bench:tui-load": "node scripts/tui-runtime-load-bench.mjs",
     "bench:output-style": "node scripts/output-style-bench.mjs",
     "bench:session-context": "node scripts/session-context-bench.mjs",

package/scripts/build-token-addon.mjs

@@ -0,0 +1,32 @@
+import { copyFile, mkdir } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const manifest = join(root, 'native', 'mixdog-token', 'Cargo.toml');
+const release = process.argv.includes('--release');
+const profile = release ? 'release' : 'debug';
+const sourceName = process.platform === 'win32'
+  ? 'mixdog_token.dll'
+  : process.platform === 'darwin' ? 'libmixdog_token.dylib' : 'libmixdog_token.so';
+const source = join(root, 'native', 'mixdog-token', 'target', profile, sourceName);
+const destination = join(root, 'native', 'mixdog-token', 'target', profile, 'mixdog-token.node');
+
+if (process.argv.includes('--build')) {
+  const args = ['build', '--locked', '--manifest-path', manifest];
+  if (release) args.splice(1, 0, '--release');
+  const child = spawn('cargo', args, { cwd: root, stdio: 'inherit', shell: process.platform === 'win32' });
+  const code = await new Promise((resolveExit, reject) => {
+    child.once('error', reject);
+    child.once('exit', (value, signal) => {
+      if (signal) reject(new Error(`cargo build terminated by ${signal}`));
+      else resolveExit(value ?? 1);
+    });
+  });
+  if (code !== 0) process.exit(code);
+}
+
+await mkdir(dirname(destination), { recursive: true });
+await copyFile(source, destination);
+process.stdout.write(`${destination}\n`);

package/scripts/daemon-stub.mjs

@@ -8,18 +8,14 @@ process.env.MIXDOG_WORKER_MODE = process.env.MIXDOG_WORKER_MODE || '1';
 
 import os from 'node:os';
 import path from 'node:path';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { rmSync, writeFileSync } from 'node:fs';
 import { writeJsonAtomicSync } from '../src/runtime/shared/atomic-file.mjs';
+import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../src/runtime/shared/runtime-root.mjs';
 import { claimSingletonOwner, releaseSingletonOwner } from '../src/runtime/shared/singleton-owner.mjs';
 import { safeIpcSend } from '../src/runtime/shared/safe-ipc-send.mjs';
 import { createChannelTransport } from '../src/standalone/channel-transport.mjs';
 
-function runtimeRoot() {
-  return process.env.MIXDOG_RUNTIME_ROOT
-    ? path.resolve(process.env.MIXDOG_RUNTIME_ROOT)
-    : path.join(os.tmpdir(), 'mixdog');
-}
-const RUNTIME_ROOT = runtimeRoot();
+const RUNTIME_ROOT = resolveRuntimeRoot();
 const DATA_DIR = process.env.MIXDOG_DATA_DIR ? path.resolve(process.env.MIXDOG_DATA_DIR) : RUNTIME_ROOT;
 const DISCOVERY_PATH = path.join(RUNTIME_ROOT, 'daemon.json');
 const OWNER_PATH = path.join(DATA_DIR, 'daemon-owner.json');
@@ -38,7 +34,7 @@ async function shutdown(reason, code = 0) {
 }
 
 async function main() {
-  try { mkdirSync(RUNTIME_ROOT, { recursive: true }); } catch {}
+  ensurePrivateRuntimeRoot(RUNTIME_ROOT);
   const claim = claimSingletonOwner(OWNER_PATH, { kind: 'mixdog-daemon', pid: process.pid, meta: { cwd: process.cwd() } });
   if (!claim.owned) { process.exit(0); } // race loser → spawner attaches to winner
   process.on('exit', () => { try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {} });
@@ -50,6 +46,7 @@ async function main() {
       writeFileSync(process.env.SMOKE_CHANNEL_ENV_OUT, JSON.stringify({
         cliOwned: process.env.MIXDOG_CLI_OWNED,
         host: process.env.MIXDOG_DAEMON_HOST,
+        supervisorPid: process.env.MIXDOG_SUPERVISOR_PID,
       }));
     } catch { /* smoke-only, best-effort */ }
   }
@@ -75,7 +72,7 @@ async function main() {
     pid: process.pid,
     startedAt: Date.now(),
     endpoints: { channel: { port, token } },
-  }, { compact: true });
+  }, { compact: true, secret: true });
   safeIpcSend(process, { type: 'ready', port, token });
   log(`ready port=${port} pid=${process.pid}`);
 }

package/scripts/fixtures/patch-replay-corpus.json

@@ -94,5 +94,133 @@
     "expect_error": "\"patch\" is required",
     "file_snapshots": {},
     "args": { "base_path": null }
+  },
+  {
+    "id": "eof-star-as-context",
+    "note": "observed: models close the EOF marker as *** End of File ***; that used to become a fake old line",
+    "expect": "applied",
+    "expect_content": { "a.txt": "one\nTWO\nthree\n" },
+    "file_snapshots": { "a.txt": "one\ntwo\nthree\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.txt\n@@\n one\n-two\n+TWO\n three\n*** End of File ***\n*** End Patch\n" }
+  },
+  {
+    "id": "opcode-dash-list-item",
+    "note": "observed: markdown/list line `- Plan` sent as a delete of ` Plan`",
+    "expect": "applied",
+    "expect_content": { "a.md": "- Plan keep\n  new body\ntail\n" },
+    "file_snapshots": { "a.md": "- Plan keep\n  old body\ntail\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.md\n@@\n- Plan keep\n-  old body\n+  new body\n*** End Patch\n" }
+  },
+  {
+    "id": "indent-only-unique-window",
+    "note": "observed (tool-failures indent-only): same text, 2-space vs 4-space; unique window must apply",
+    "expect": "applied",
+    "expect_content": { "a.js": "    // landed thumbnail (each restart re-rendered the whole grid).\n    const generating = true;\n" },
+    "file_snapshots": { "a.js": "    // landed thumbnail (each restart re-rendered the whole grid).\n    const generating = false;\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n  // landed thumbnail (each restart re-rendered the whole grid).\n-    const generating = false;\n+    const generating = true;\n*** End Patch\n" }
+  },
+  {
+    "id": "indent-only-ambiguous-brace",
+    "note": "guard: indent-only `});` must not pick a window when it occurs twice",
+    "expect": "rejected",
+    "expect_error": "context not found",
+    "file_snapshots": { "a.js": "function a() {\n  });\n}\nfunction b() {\n  });\n}\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n});\n*** End Patch\n" }
+  },
+  {
+    "id": "opcode-plus-list-item",
+    "note": "observed: markdown/diff line `+ TODO` sent as an add of ` TODO`",
+    "expect": "applied",
+    "expect_content": { "a.md": "+ TODO keep\n  new body\ntail\n" },
+    "file_snapshots": { "a.md": "+ TODO keep\n  old body\ntail\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.md\n@@\n+ TODO keep\n-  old body\n+  new body\n*** End Patch\n" }
+  },
+  {
+    "id": "opcode-plus-after-context",
+    "note": "observed: `+ TODO` after a real context line must stay context, not insert",
+    "expect": "applied",
+    "expect_content": { "a.md": "keep\n+ TODO keep\n  new body\ntail\n" },
+    "file_snapshots": { "a.md": "keep\n+ TODO keep\n  old body\ntail\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.md\n@@\n keep\n+ TODO keep\n-  old body\n+  new body\n*** End Patch\n" }
+  },
+  {
+    "id": "escape-equiv-unique",
+    "note": "file stores literal \\uXXXX; unique window must apply the real-character patch",
+    "expect": "applied",
+    "expect_content": { "a.js": "const a = \"x\";\nmid\n" },
+    "file_snapshots": { "a.js": "const a = \"\\u00e9\";\nmid\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n-const a = \"é\";\n+const a = \"x\";\n*** End Patch\n" }
+  },
+  {
+    "id": "escape-equiv-two-windows",
+    "note": "guard: escape-equivalence must not pick a window when it occurs twice",
+    "expect": "rejected",
+    "expect_error": "context not found",
+    "file_snapshots": { "a.js": "const label = \"\\u00e9\";\nmid\nconst label = \"\\u00e9\";\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n-const label = \"é\";\n+const label = \"x\";\n*** End Patch\n" }
+  },
+  {
+    "id": "crlf-rename",
+    "note": "V4A rename must keep the source file's CRLF endings",
+    "expect": "applied",
+    "expect_content": { "new.js": "line1\r\nLINE2\r\n" },
+    "file_snapshots": { "old.js": "line1\r\nline2\r\n" },
+    "args": { "mode": "atomic", "patch": "*** Begin Patch\n*** Update File: old.js\n*** Move to: new.js\n@@\n line1\n-line2\n+LINE2\n*** End Patch\n" }
+  },
+  {
+    "id": "add-overwrite-crlf",
+    "note": "Add File overwrite of an existing CRLF file must keep CRLF",
+    "expect": "applied",
+    "expect_content": { "a.txt": "NEW\r\n" },
+    "file_snapshots": { "a.txt": "old\r\n" },
+    "args": { "patch": "*** Begin Patch\n*** Add File: a.txt\n+NEW\n*** End Patch\n" }
+  },
+  {
+    "id": "indent-new-follows-file",
+    "note": "indent recovery must rewrite added lines with the file's leading whitespace",
+    "expect": "applied",
+    "expect_content": { "a.js": "\tconst x = 1;\n\tconst y = 3;\n" },
+    "file_snapshots": { "a.js": "\tconst x = 1;\n\tconst y = 2;\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n  const x = 1;\n-  const y = 2;\n+  const y = 3;\n*** End Patch\n" }
+  },
+  {
+    "id": "cr-only-update",
+    "note": "classic Mac CR-only files must match and keep CR",
+    "expect": "applied",
+    "expect_content": { "a.txt": "hello\rWORLD\r" },
+    "file_snapshots": { "a.txt": "hello\rworld\r" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.txt\n@@\n hello\n-world\n+WORLD\n*** End Patch\n" }
+  },
+  {
+    "id": "already-applied-insert",
+    "note": "observed: re-sent insertion whose unique new-side is already on disk",
+    "expect": "applied",
+    "expect_content": { "a.js": "const STATUS = {\n  pending: 1,\n  archived: 2,\n}\n" },
+    "file_snapshots": { "a.js": "const STATUS = {\n  pending: 1,\n  archived: 2,\n}\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n const STATUS = {\n   pending: 1,\n+  archived: 2,\n }\n*** End Patch\n" }
+  },
+  {
+    "id": "already-applied-replace",
+    "note": "observed: re-sent replacement whose unique new-side is already on disk",
+    "expect": "applied",
+    "expect_content": { "a.js": "head\nreturn ALL.has(v) || v === 'core' || v === 'lineage'\ntail\n" },
+    "file_snapshots": { "a.js": "head\nreturn ALL.has(v) || v === 'core' || v === 'lineage'\ntail\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n head\n-return ALL.has(v) || v === 'core'\n+return ALL.has(v) || v === 'core' || v === 'lineage'\n tail\n*** End Patch\n" }
+  },
+  {
+    "id": "already-applied-mixed-remaining",
+    "note": "already-applied hunks skip; a later unique old-side hunk still applies",
+    "expect": "applied",
+    "expect_content": { "a.js": "const STATUS = {\n  pending: 1,\n  archived: 2,\n}\n// lineage backfill\n" },
+    "file_snapshots": { "a.js": "const STATUS = {\n  pending: 1,\n  archived: 2,\n}\n// pending/active only\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n const STATUS = {\n   pending: 1,\n+  archived: 2,\n }\n@@\n-// pending/active only\n+// lineage backfill\n*** End Patch\n" }
+  },
+  {
+    "id": "already-applied-duplicate-new",
+    "note": "guard: unique new-side required; two copies stay a hard miss",
+    "expect": "rejected",
+    "expect_error": "context not found",
+    "file_snapshots": { "a.js": "flag = false;\nmid\nflag = false;\n" },
+    "args": { "patch": "*** Begin Patch\n*** Update File: a.js\n@@\n-flag = true;\n+flag = false;\n*** End Patch\n" }
   }
 ]

package/scripts/lib/recall-bench-eval.mjs

@@ -0,0 +1,241 @@
+const TIMESTAMP_RE = /^\[(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?)\b/;
+const SESSION_HEADER_RE = /^##\s+session\b/i;
+
+export function textOfResult(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result.content.map((part) => (part?.type === 'text' ? part.text || '' : JSON.stringify(part))).join('\n');
+  }
+  if (result && typeof result === 'object' && typeof result.text === 'string') return result.text;
+  if (typeof result === 'string') return result;
+  return JSON.stringify(result ?? '');
+}
+
+function timestampMs(raw) {
+  const value = Date.parse(String(raw || '').replace(' ', 'T'));
+  return Number.isFinite(value) ? value : null;
+}
+
+export function parseRecallOutput(text) {
+  const items = [];
+  const headers = [];
+  let current = null;
+  let group = null;
+  let groupLabel = null;
+  let groupIndex = -1;
+  for (const raw of String(text || '').split('\n')) {
+    const line = raw.trim();
+    if (!line || line === '(no results)' || line === '(no valid ids)') continue;
+    if (SESSION_HEADER_RE.test(line)) {
+      groupIndex += 1;
+      group = groupIndex;
+      groupLabel = line.replace(/^##\s+session\s+/i, '').split(/\s+\(/, 1)[0].trim();
+      current = null;
+      headers.push({ text: line, group, label: groupLabel });
+      continue;
+    }
+    const stamp = TIMESTAMP_RE.exec(line);
+    if (stamp) {
+      current = {
+        text: line,
+        firstLine: line,
+        timestampText: stamp[1],
+        timestampMs: timestampMs(stamp[1]),
+        group,
+        groupLabel,
+      };
+      items.push(current);
+      continue;
+    }
+    if (line.startsWith('[recall truncated') || line.startsWith('note:')) {
+      current = null;
+      continue;
+    }
+    if (/^\[[^\]]+\]$/.test(line)) {
+      current = null;
+      continue;
+    }
+    if (current) current.text += `\n${line}`;
+  }
+  return { items, headers };
+}
+
+export function topItems(items, n = 3, maxLen = 140) {
+  return items.slice(0, n).map((item) => {
+    const line = item.text.replace(/\s+/g, ' ');
+    return line.length > maxLen ? `${line.slice(0, maxLen - 1)}…` : line;
+  });
+}
+
+export function scoreTopNContains(items, substrings, n) {
+  const lower = items.map((item) => item.text.toLowerCase());
+  const perSubstring = substrings.map((needle) => {
+    const target = String(needle || '').toLowerCase();
+    let rank = null;
+    for (let i = 0; i < lower.length; i += 1) {
+      if (target && lower[i].includes(target)) {
+        rank = i + 1;
+        break;
+      }
+    }
+    const hit = rank !== null && rank <= n;
+    return { needle, rank, hit, rr: hit ? 1 / rank : 0 };
+  });
+  const total = perSubstring.length || 1;
+  return {
+    perSubstring,
+    hitAtN: perSubstring.reduce((sum, row) => sum + (row.hit ? 1 : 0), 0) / total,
+    mrr: perSubstring.reduce((sum, row) => sum + row.rr, 0) / total,
+    n,
+  };
+}
+
+function firstRecencyBreak(items) {
+  for (let i = 1; i < items.length; i += 1) {
+    const previous = items[i - 1];
+    const current = items[i];
+    if (current.timestampMs !== null && previous.timestampMs !== null && current.timestampMs > previous.timestampMs) {
+      return { prev: previous.timestampText, cur: current.timestampText };
+    }
+  }
+  return null;
+}
+
+export function scoreRecencyOrdered(items) {
+  const timestamped = items.filter((item) => item.timestampMs !== null);
+  const grouped = timestamped.some((item) => item.group !== null);
+  if (!grouped) {
+    const firstViolation = firstRecencyBreak(timestamped);
+    return {
+      parsed: timestamped.length,
+      groups: 0,
+      ordered: firstViolation === null,
+      firstViolation,
+    };
+  }
+  const groups = new Map();
+  for (const item of timestamped) {
+    const key = item.group ?? -1;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(item);
+  }
+  let firstViolation = null;
+  for (const rows of groups.values()) {
+    const hit = firstRecencyBreak(rows);
+    if (hit) {
+      firstViolation = { ...hit, scope: 'within-session' };
+      break;
+    }
+  }
+  if (!firstViolation) {
+    const hit = firstRecencyBreak([...groups.values()].map((rows) => rows[0]));
+    if (hit) firstViolation = { ...hit, scope: 'across-sessions' };
+  }
+  return {
+    parsed: timestamped.length,
+    groups: groups.size,
+    ordered: firstViolation === null,
+    firstViolation,
+  };
+}
+
+function groupHeads(parsed) {
+  const heads = [];
+  const seen = new Set();
+  for (const item of parsed?.items || []) {
+    const key = item.groupLabel ?? `group:${item.group ?? -1}`;
+    if (seen.has(key) || item.timestampMs === null) continue;
+    seen.add(key);
+    heads.push(item);
+  }
+  return heads;
+}
+
+export function scorePageAfter(previousParsed, currentParsed) {
+  const previousHeads = groupHeads(previousParsed);
+  const currentHeads = groupHeads(currentParsed);
+  const previousLabels = new Set((previousParsed?.headers || []).map((header) => header.label).filter(Boolean));
+  const duplicateGroups = (currentParsed?.headers || [])
+    .filter((header) => header.label && previousLabels.has(header.label));
+  const previousLast = previousHeads.at(-1) || null;
+  const currentFirst = currentHeads[0] || null;
+  const inverted = previousLast?.timestampMs != null
+    && currentFirst?.timestampMs != null
+    && currentFirst.timestampMs > previousLast.timestampMs;
+  return {
+    ok: duplicateGroups.length === 0 && !inverted,
+    duplicateGroups,
+    inverted,
+    previousLast,
+    currentFirst,
+  };
+}
+
+export function scoreAllContain(items, substrings) {
+  const needles = substrings.map((value) => String(value || '').toLowerCase()).filter(Boolean);
+  const offenders = items.filter((item) => {
+    const text = item.text.toLowerCase();
+    return !needles.some((needle) => text.includes(needle));
+  });
+  return { needles: substrings, offenders, ok: offenders.length === 0 };
+}
+
+export function scoreWithinPeriod(items, temporal, toleranceMs = 60_000) {
+  const startMs = Number(temporal?.startMs);
+  const endMs = Number(temporal?.endMs);
+  const hasStart = Number.isFinite(startMs);
+  const hasEnd = Number.isFinite(endMs);
+  const offenders = items.filter((item) => (
+    item.timestampMs !== null
+    && ((hasStart && item.timestampMs < startMs - toleranceMs)
+      || (hasEnd && item.timestampMs > endMs + toleranceMs))
+  ));
+  return { checked: items.filter((item) => item.timestampMs !== null).length, offenders, ok: offenders.length === 0 };
+}
+
+export function evaluateCase(kase, outcome, quality, recency, allContain, withinPeriod, pageOrder) {
+  const warnings = [];
+  const expectObj = kase.expect && typeof kase.expect === 'object' ? kase.expect : {};
+  const expectKind = expectObj.kind || kase.expect;
+  const allowEmpty = expectObj.allowEmpty === true;
+  const minResults = Number.isInteger(expectObj.minResults)
+    ? Math.max(0, expectObj.minResults)
+    : (expectKind === 'empty' || allowEmpty ? 0 : 1);
+  const maxResults = Number.isInteger(expectObj.maxResults) ? Math.max(0, expectObj.maxResults) : null;
+  if (outcome.isError) warnings.push('error result');
+  if (outcome.ms > 3000) warnings.push(`latency ${outcome.ms}ms > 3000ms`);
+  if (outcome.count < minResults) warnings.push(`expected at least ${minResults} result(s), got ${outcome.count}`);
+  if (maxResults !== null && outcome.count > maxResults) warnings.push(`expected at most ${maxResults} result(s), got ${outcome.count}`);
+  if (expectKind === 'empty' && outcome.count > 0) warnings.push(`expected empty but got ${outcome.count} result(s)`);
+  if (allContain) {
+    for (const item of allContain.offenders) {
+      warnings.push(`allContain miss: "${item.firstLine}"`);
+    }
+  }
+  if (quality) {
+    for (const row of quality.perSubstring) {
+      if (!row.hit) {
+        warnings.push(row.rank === null
+          ? `topNContains miss: "${row.needle}" not found in results`
+          : `topNContains miss: "${row.needle}" found at rank ${row.rank} > topN ${quality.n}`);
+      }
+    }
+  }
+  if (recency && !recency.ordered && recency.firstViolation) {
+    const violation = recency.firstViolation;
+    warnings.push(`recencyOrdered violation (${violation.scope || 'global'}): ${violation.cur} newer than prior ${violation.prev}`);
+  }
+  if (withinPeriod) {
+    for (const item of withinPeriod.offenders) {
+      warnings.push(`withinPeriod miss: "${item.firstLine}"`);
+    }
+  }
+  if (pageOrder) {
+    for (const header of pageOrder.duplicateGroups) {
+      warnings.push(`pageOrder duplicate session: "${header.label}"`);
+    }
+    if (pageOrder.inverted) {
+      warnings.push(`pageOrder inversion: page starts at ${pageOrder.currentFirst?.timestampText} after prior page ended at ${pageOrder.previousLast?.timestampText}`);
+    }
+  }
+  return { status: warnings.length ? 'WARN' : 'PASS', warnings };
+}

package/scripts/native-spawn-test-runtime.mjs

@@ -0,0 +1,16 @@
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { _setNativeSpawnBinaryForTest } from '../src/runtime/agent/orchestrator/tools/lib/native-spawn-client.mjs';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const binary = resolve(
+  root,
+  'native/mixdog-spawn/target/debug',
+  process.platform === 'win32' ? 'mixdog-spawn.exe' : 'mixdog-spawn',
+);
+
+if (!existsSync(binary)) {
+  throw new Error(`native spawn test binary missing: run npm run build:spawn:test (${binary})`);
+}
+_setNativeSpawnBinaryForTest(binary);

package/scripts/recall-bench-cases.json

@@ -1,11 +1,11 @@
 [
-  { "id": "browse-last", "label": "query-less recent browse (period=last)", "args": { "period": "last", "limit": 10 }, "expect": "browse" },
-  { "id": "last-query-topic", "label": "topic inside recent sessions (period=last + query)", "args": { "query": "last", "period": "last", "limit": 5 }, "expect": { "kind": "results", "topNContains": ["last"], "topN": 10, "recencyOrdered": true } },
-  { "id": "period-24h", "label": "period window 24h", "args": { "period": "24h", "limit": 10 }, "expect": "browse" },
-  { "id": "period-7d", "label": "period window 7d", "args": { "period": "7d", "limit": 10 }, "expect": "browse" },
+  { "id": "browse-last", "label": "query-less recent browse (period=last)", "args": { "period": "last", "projectScope": "mixdog", "limit": 10 }, "expect": { "kind": "browse", "recencyOrdered": true } },
+  { "id": "scope-common-exact", "label": "common-scope exact historical query", "args": { "query": "buildRecallFastTrackQuery", "period": "all", "projectScope": "common", "limit": 5 }, "expect": { "kind": "results", "topNContains": ["buildRecallFastTrackQuery"], "topN": 3 } },
+  { "id": "period-24h", "label": "period window 24h", "args": { "period": "24h", "projectScope": "mixdog", "limit": 10 }, "expect": { "kind": "browse", "recencyOrdered": true, "withinPeriod": true } },
+  { "id": "period-7d", "label": "period window 7d", "args": { "period": "7d", "projectScope": "mixdog", "limit": 10 }, "expect": { "kind": "browse", "recencyOrdered": true, "withinPeriod": true } },
   { "id": "scope-all", "label": "all-scope query", "args": { "query": "recall", "projectScope": "all", "limit": 10 }, "expect": "results" },
-  { "id": "recent-dryrun-delta", "label": "recent-work topical: dryrun delta sum", "args": { "query": "\uB4DC\uB77C\uC774\uB7F0 \uB378\uD0C0 \uD569\uC0B0", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uB4DC\uB77C\uC774\uB7F0"], "topN": 5 } },
-  { "id": "recent-remote-singleton", "label": "recent-work topical: remote singleton seat", "args": { "query": "remote \uC2F1\uAE00\uD1A4 \uC88C\uC11D", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uC2F1\uAE00\uD1A4"], "topN": 5 } },
-  { "id": "recency-today", "label": "query+period recency: today's work (24h)", "args": { "query": "\uC624\uB298 \uC9C4\uD589\uD55C \uC791\uC5C5", "period": "24h", "limit": 10 }, "expect": { "kind": "results", "recencyOrdered": true } },
+  { "id": "historical-dryrun-delta", "label": "common historical topic: dryrun delta sum", "args": { "query": "\uB4DC\uB77C\uC774\uB7F0 \uB378\uD0C0 \uD569\uC0B0", "period": "all", "projectScope": "common", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uB4DC\uB77C\uC774\uB7F0"], "topN": 5 } },
+  { "id": "historical-remote-singleton", "label": "common historical topic: remote singleton seat", "args": { "query": "remote \uC2F1\uAE00\uD1A4 \uC88C\uC11D", "period": "all", "projectScope": "common", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uC2F1\uAE00\uD1A4"], "topN": 5 } },
+  { "id": "recency-today", "label": "query+period recency: current RAG work", "args": { "query": "RAG recall", "period": "24h", "projectScope": "mixdog", "sort": "date", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["RAG"], "topN": 10, "recencyOrdered": true, "withinPeriod": true } },
   { "id": "xlang-embedding-crash", "label": "cross-language: embedding worker crash (strict topN)", "args": { "query": "embedding worker crash", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["embedding"], "topN": 3 } }
 ]