mixdog 0.9.49 → 0.9.50

package/README.md

@@ -152,12 +152,12 @@ current Anthropic models.
 ## Scripts
 
 ```bash
-npm run smoke          # basic smoke check
-npm run smoke:all      # core smoke suite
-npm run smoke:tui      # TUI render smoke
-npm run smoke:tools    # tool smoke suite
-npm run build:tui      # build the bundled Ink TUI
-npm run audit:models   # inspect model catalog metadata
+npm run smoke                # fast core feature smoke
+npm run smoke:all            # feature-surface smoke suite
+npm run smoke:tui            # TUI feature smoke
+npm run test:tool-contracts  # optional tool contract suite
+npm run build:tui            # build the bundled Ink TUI
+npm run audit:models         # inspect model catalog metadata
 ```
 
 Additional diagnostics and benchmarks live under `scripts/`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.49",
+  "version": "0.9.50",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -36,14 +36,14 @@
     "prepack": "npm run build:tui",
     "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run npm run release:patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
-    "smoke": "node scripts/smoke.mjs && node --test scripts/ship-mode-test.mjs && npm run test:memory-routing && node --test scripts/explore-prompt-policy-test.mjs && node --test scripts/routing-corpus-test.mjs",
-    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars && npm run smoke:logguard && npm run smoke:live-worker && npm run test:session",
+    "smoke": "node scripts/smoke.mjs",
+    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:live-worker",
     "smoke:boot": "node scripts/boot-smoke.mjs",
     "smoke:compact": "node scripts/compact-smoke.mjs",
     "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 boot-smoke.mjs=8000 --max-step-ms tool-smoke.mjs=4000 --max-rss-mb 140 --max-rss-growth-mb 50",
+    "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",
-    "smoke:tools": "node scripts/tool-smoke.mjs",
+    "test:tool-contracts": "node scripts/tool-smoke.mjs",
     "smoke:patch": "node scripts/apply-patch-edit-smoke.mjs",
     "smoke:output": "node scripts/output-style-smoke.mjs",
     "smoke:tui": "node scripts/tui-render-smoke.mjs && npm run test:tui-input-render && npm run test:tui-streaming-window && npm run test:tui-queue",
@@ -62,14 +62,14 @@
     "test:anthropic-oauth-race": "node --test scripts/anthropic-oauth-refresh-race-test.mjs",
     "test:grok-oauth-race": "node --test scripts/grok-oauth-refresh-race-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
-    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/memory-rule-contract-test.mjs scripts/maintenance-default-routes-test.mjs",
+    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/maintenance-default-routes-test.mjs scripts/embedding-worker-exit-test.mjs",
     "test:code-graph-dispatch": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:code-graph-clean-cache": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
     "test:tui-input-render": "node --test scripts/prompt-immediate-render-test.mjs",
     "test:tui-streaming-window": "node --test scripts/streaming-tail-window-test.mjs",
     "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/verify-release-assets-test.mjs && node --test scripts/verify-release-assets-test.mjs",
-    "test:release-focused": "npm run test:release-assets && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && npm run smoke:tools && node --test scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && node --test scripts/tui-transcript-perf-test.mjs",
     "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
     "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
     "test:session": "node --test scripts/session-orphan-sweep-test.mjs",

package/scripts/embedding-worker-exit-test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const providerUrl = new URL('../src/runtime/memory/lib/embedding-provider.mjs', import.meta.url)
+const CHILD_DEADLINE_MS = 3_000
+
+async function createExitWorkerFixture() {
+  const tempDir = await mkdtemp(join(tmpdir(), 'mixdog-embed-worker-exit-'))
+  const workerPath = join(tempDir, 'exit-before-reply.mjs')
+  await writeFile(workerPath, `
+    import { parentPort } from 'node:worker_threads'
+    parentPort.once('message', () => process.exit(0))
+  `)
+  const source = await readFile(providerUrl, 'utf8')
+  const instrumented = source
+    .replace("'./model-profile.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/model-profile.mjs', import.meta.url).href))
+    .replace("'./embedding-model-config.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/embedding-model-config.mjs', import.meta.url).href))
+    .replace(/^const WORKER_PATH = .*$/m, `const WORKER_PATH = ${JSON.stringify(workerPath)}`)
+  const providerModule = `data:text/javascript;base64,${Buffer.from(instrumented).toString('base64')}#${Date.now()}`
+  const fixturePath = join(tempDir, 'run-exit-test.mjs')
+  await writeFile(fixturePath, `
+    import { embedText } from ${JSON.stringify(providerModule)}
+    const started = Date.now()
+    const settled = await Promise.allSettled([embedText('first'), embedText('second')])
+    if (Date.now() - started >= 2_000) throw new Error('worker exit did not reject pending embeds promptly')
+    if (settled.some(({ status }) => status !== 'rejected')) throw new Error('worker exit resolved a pending embed')
+    for (const result of settled) {
+      if (result.reason?.message !== 'Worker exited with code 0') throw result.reason
+    }
+    process.stdout.write('ok')
+  `)
+  return { fixturePath, tempDir }
+}
+
+function runFixture(fixturePath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [fixturePath], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+    const deadline = setTimeout(() => {
+      timedOut = true
+      child.kill()
+    }, CHILD_DEADLINE_MS)
+    child.stdout.on('data', (chunk) => { stdout += chunk })
+    child.stderr.on('data', (chunk) => { stderr += chunk })
+    child.once('error', (error) => {
+      clearTimeout(deadline)
+      reject(error)
+    })
+    child.once('close', (code, signal) => {
+      clearTimeout(deadline)
+      if (timedOut) {
+        reject(new Error(`exit-worker fixture exceeded ${CHILD_DEADLINE_MS}ms and was killed`))
+        return
+      }
+      resolve({ code, signal, stdout, stderr })
+    })
+  })
+}
+
+test('code-zero worker exit before reply promptly rejects every pending embed', async () => {
+  const { fixturePath, tempDir } = await createExitWorkerFixture()
+  try {
+    const result = await runFixture(fixturePath)
+    assert.equal(result.code, 0, result.stderr)
+    assert.equal(result.signal, null, result.stderr)
+    assert.equal(result.stdout, 'ok')
+  } finally {
+    await rm(tempDir, { recursive: true, force: true })
+  }
+})

package/scripts/smoke-loop.mjs

@@ -58,7 +58,7 @@ function runNode(args, label, timeoutMs = 180_000) {
 function runSmokeAll(iteration) {
   let totalMs = 0;
   const steps = [];
-  for (const script of ['scripts/boot-smoke.mjs', 'scripts/tool-smoke.mjs']) {
+  for (const script of ['scripts/smoke.mjs', 'scripts/boot-smoke.mjs']) {
     const result = runNode([script], `${script} iteration ${iteration}`);
     totalMs += result.ms;
     steps.push({
@@ -161,8 +161,14 @@ while (Date.now() < deadline && iteration < maxIterations) {
   const iterStartedAt = Date.now();
   const smoke = runSmokeAll(iteration);
   smokeTimes.push(smoke.ms);
-  const failure = runNode(['scripts/tool-failures.mjs', '--since', since, '--limit', '1'], `failures iteration ${iteration}`, 60_000);
-  if (!/tool failures:\s+0\/0 shown/.test(failure.stdout)) {
+  const failure = runNode(['scripts/tool-failures.mjs', '--since', since, '--limit', '1', '--json'], `failures iteration ${iteration}`, 60_000);
+  let failureSummary;
+  try {
+    failureSummary = JSON.parse(failure.stdout);
+  } catch {
+    throw new Error(`tool failures returned malformed JSON:\n${failure.stdout}`);
+  }
+  if (failureSummary?.actionable_failures?.matched !== 0) {
     throw new Error(`tool failures appeared after loop start:\n${failure.stdout}`);
   }
   const currentRss = rssMb();

package/scripts/smoke.mjs

@@ -19,120 +19,19 @@ function runNode(args, label, options = {}) {
   return child;
 }
 
-const child = runNode(['src/cli.mjs', '--help'], 'help smoke');
-const isolatedStatuslineEnv = {
-  MIXDOG_DATA_DIR: resolve(root, '.mixdog-smoke-data-empty'),
-  MIXDOG_HOME: resolve(root, '.mixdog-smoke-home-empty'),
-  MIXDOG_CONFIG_DIR: resolve(root, '.mixdog-smoke-config-empty'),
-};
-
-if (!child.stdout.includes('standalone mixdog CLI/TUI coding agent')) {
-  process.stderr.write(`unexpected help output:\n${child.stdout}`);
-  process.exit(1);
-}
+runNode(['src/cli.mjs', '--help'], 'help smoke');
 
 runNode(['--input-type=module', '-e', `
   const mod = await import('./src/tui/dist/index.mjs');
   if (typeof mod.runTui !== 'function') throw new Error('runTui export missing');
 `], 'tui bundle import smoke');
 
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 1000000,
-    stats: { currentContextTokens: 999 },
-  });
-  if (/▓/.test(line) || !line.includes('░') || !line.includes('0.1%')) throw new Error('sub-1% context bar should stay empty: ' + JSON.stringify(line));
-`], 'statusline sub-percent context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    rawContextWindow: 1000000,
-    stats: { currentContextTokens: 900000 },
-  });
-  if (!line.includes('94%') || line.includes('100%')) throw new Error('statusline context% should use effective compact capacity, not the 90% auto-compact trigger: ' + JSON.stringify(line));
-`], 'statusline compact-capacity context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 350000, currentContextSource: 'estimated' },
-  });
-  if (line.includes('37%') || !line.includes('0%')) throw new Error('statusline must not show local estimated context as session usage: ' + JSON.stringify(line));
-`], 'statusline estimated-context isolation smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 360000, currentContextSource: 'post_compact_estimate' },
-  });
-  if (!line.includes('37%')) throw new Error('statusline must show post-compact estimated context after stale API usage: ' + JSON.stringify(line));
-`], 'statusline post-compact context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 0 },
-    agentJobs: [{ task_id: 'task_statusline_smoke', status: 'running', tag: 'bench-agent', startedAt: new Date().toISOString() }],
-  });
-  if (!line.includes('Running 1 Agent') || line.includes('bench-agent')) throw new Error('statusline must render live agent count without task tags: ' + JSON.stringify(line));
-`], 'statusline live agent task smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  const { mkdtempSync, mkdirSync, writeFileSync } = await import('node:fs');
-  const { tmpdir } = await import('node:os');
-  const { join } = await import('node:path');
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-status-smoke-'));
-  mkdirSync(join(root, 'runtime'), { recursive: true });
-  writeFileSync(join(root, 'runtime', 'active-instance.json'), JSON.stringify({
-    gateway_port: 3468,
-    gateway_server_pid: process.pid,
-    gateway_provider: 'openai',
-    gateway_model: 'gpt-5.5',
-    gateway_context_window: 950000,
-    gateway_raw_context_window: 1000000,
-    gateway_auto_compact_token_limit: 950000,
-    gateway_context_used_pct: 37,
-    gateway_cc_session_id: 'other-session',
-    gateway_updated_at: Date.now()
-  }));
-  process.env.MIXDOG_RUNTIME_ROOT = join(root, 'runtime');
-  const { loadGatewayStatus } = await import('./src/vendor/statusline/bin/statusline-route.mjs');
-  const status = loadGatewayStatus({ sessionId: 'fresh-session', clientHostPid: process.pid, activeContextTokens: 0 });
-  if (status?.contextUsedPct === 37) throw new Error('statusline leaked active-instance context from another session');
-`], 'statusline session metrics isolation smoke', { env: isolatedStatuslineEnv });
-
-const boot = spawnSync(process.execPath, ['src/cli.mjs', '--help'], {
-  cwd: root,
-  env: { ...process.env, MIXDOG_BOOT_PROFILE: '1' },
-  encoding: 'utf8',
-  stdio: ['ignore', 'pipe', 'pipe'],
-  timeout: 10000,
+const boot = runNode(['src/cli.mjs', '--help'], 'boot profile smoke', {
+  env: { MIXDOG_BOOT_PROFILE: '1' },
 });
-
-if (boot.status !== 0 || !boot.stderr.includes('[mixdog-boot]') || !boot.stderr.includes('app:run:start')) {
+if (!boot.stderr.includes('[mixdog-boot]')) {
   process.stderr.write(boot.stderr || boot.stdout || 'boot profile smoke failed\n');
-  process.exit(boot.status || 1);
+  process.exit(1);
 }
 
 process.stdout.write('smoke passed ✓\n');

package/scripts/verify-release-assets-test.mjs

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { createHash } from 'node:crypto';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
@@ -59,303 +59,6 @@ function graphFixture() {
   };
 }
 
-function yamlScalar(value) {
-  const trimmed = value.trim();
-  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1).replaceAll("''", "'");
-  }
-  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-    return JSON.parse(trimmed);
-  }
-  return trimmed.replace(/\s+#.*$/, '').trim();
-}
-
-function yamlBlockEnd(lines, start, indent) {
-  for (let index = start + 1; index < lines.length; index += 1) {
-    const text = lines[index];
-    if (/^\s*(?:#.*)?$/.test(text)) continue;
-    if (text.match(/^\s*/)[0].length <= indent) return index;
-  }
-  return lines.length;
-}
-
-function yamlMappingEntry(text, indent) {
-  if (text.match(/^\s*/)[0].length !== indent) return undefined;
-  const match = text.slice(indent).match(/^("(?:\\.|[^"])*"|'(?:''|[^'])*'|[A-Za-z0-9_-]+):\s*(.*)$/);
-  if (!match) return undefined;
-  return { key: yamlScalar(match[1]), rawValue: match[2] };
-}
-
-function yamlChildren(lines, start, end, parentIndent) {
-  let childIndent;
-  const children = [];
-  for (let index = start + 1; index < end; index += 1) {
-    const text = lines[index];
-    if (/^\s*(?:#.*)?$/.test(text)) continue;
-    const indent = text.match(/^\s*/)[0].length;
-    if (indent <= parentIndent) break;
-    childIndent ??= indent;
-    if (indent !== childIndent) continue;
-    const entry = yamlMappingEntry(text, indent);
-    if (entry) children.push({
-      ...entry,
-      index,
-      indent,
-      end: yamlBlockEnd(lines, index, indent),
-    });
-  }
-  return children;
-}
-
-function yamlEnvironment(lines, parent) {
-  const env = {};
-  for (const entry of yamlChildren(lines, parent.index, parent.end, parent.indent)) {
-    env[entry.key] = yamlScalar(entry.rawValue);
-  }
-  return env;
-}
-
-function yamlSteps(lines, parent) {
-  const itemIndexes = [];
-  let itemIndent;
-  for (let index = parent.index + 1; index < parent.end; index += 1) {
-    const match = lines[index].match(/^(\s*)-\s+(.*)$/);
-    if (!match || /^\s*(?:#.*)?$/.test(lines[index])) continue;
-    const indent = match[1].length;
-    if (itemIndent === undefined) itemIndent = indent;
-    if (indent === itemIndent) itemIndexes.push(index);
-  }
-
-  return itemIndexes.map((start, position) => {
-    const end = itemIndexes[position + 1] ?? parent.end;
-    const fieldIndent = itemIndent + 2;
-    const fields = { env: {} };
-    for (let index = start; index < end; index += 1) {
-      const source = index === start
-        ? lines[index].replace(/^\s*-\s+/, '')
-        : lines[index].slice(fieldIndent);
-      if (index !== start && lines[index].match(/^\s*/)[0].length !== fieldIndent) continue;
-      const field = source.match(/^(name|run|uses|env):\s*(.*)$/);
-      if (!field) continue;
-      const [, key, rawValue] = field;
-      if (key === 'env' && /^(?:#.*)?$/.test(rawValue)) {
-        fields.env = yamlEnvironment(lines, {
-          index,
-          indent: fieldIndent,
-          end: yamlBlockEnd(lines, index, fieldIndent),
-        });
-      } else if (key === 'run' && /^[|>][-+0-9]*\s*(?:#.*)?$/.test(rawValue)) {
-        const commands = [];
-        for (let blockIndex = index + 1; blockIndex < end; blockIndex += 1) {
-          const blockLine = lines[blockIndex];
-          if (blockLine.trim() === '' || /^\s*#/.test(blockLine)) continue;
-          if (blockLine.match(/^\s*/)[0].length <= fieldIndent) break;
-          commands.push(blockLine.trim());
-        }
-        fields.run = commands.join('\n');
-      } else {
-        fields[key] = yamlScalar(rawValue);
-      }
-    }
-    return fields;
-  });
-}
-
-function parseWorkflowSubset(workflow) {
-  const lines = workflow.replaceAll('\r\n', '\n').split('\n');
-  const roots = lines
-    .map((line, index) => ({ line, index }))
-    .filter(({ line }) => yamlMappingEntry(line, 0)?.key === 'jobs');
-  assert.equal(roots.length, 1, 'workflow must define exactly one jobs mapping');
-  const jobsBlock = {
-    index: roots[0].index,
-    indent: 0,
-    end: yamlBlockEnd(lines, roots[0].index, 0),
-  };
-  const jobs = yamlChildren(lines, jobsBlock.index, jobsBlock.end, jobsBlock.indent).map((entry) => {
-    const children = yamlChildren(lines, entry.index, entry.end, entry.indent);
-    const envEntry = children.find((child) => child.key === 'env');
-    const stepsEntry = children.find((child) => child.key === 'steps');
-    const strategyEntry = children.find((child) => child.key === 'strategy');
-    const matrixEntry = strategyEntry
-      ? yamlChildren(lines, strategyEntry.index, strategyEntry.end, strategyEntry.indent)
-        .find((child) => child.key === 'matrix')
-      : undefined;
-    const matrixLines = matrixEntry
-      ? lines.slice(matrixEntry.index + 1, matrixEntry.end)
-        .filter((line) => !/^\s*(?:#.*)?$/.test(line))
-        .map((line) => line.trim())
-      : [];
-    const includeEntry = matrixEntry
-      ? yamlChildren(lines, matrixEntry.index, matrixEntry.end, matrixEntry.indent)
-        .find((child) => child.key === 'include')
-      : undefined;
-    const matrixInclude = includeEntry
-      ? lines.slice(includeEntry.index + 1, includeEntry.end)
-        .filter((line) => /^\s*-\s+/.test(line) && !/^\s*-\s*#/.test(line))
-        .map((line) => line.replace(/^\s*-\s+/, '').trim())
-      : [];
-    return {
-      name: entry.key,
-      env: envEntry ? yamlEnvironment(lines, envEntry) : {},
-      matrix: matrixEntry ? { lines: matrixLines, include: matrixInclude } : undefined,
-      steps: stepsEntry ? yamlSteps(lines, stepsEntry) : [],
-    };
-  });
-  return { jobs };
-}
-
-function workflowJob(workflow, name) {
-  const matches = parseWorkflowSubset(workflow).jobs.filter((job) => job.name === name);
-  assert.equal(matches.length, 1, `workflow must define exactly one jobs.${name}`);
-  return matches[0];
-}
-
-function namedStep(job, name) {
-  const matches = job.steps.filter((step) => step.name === name);
-  assert.equal(matches.length, 1, `jobs.${job.name} must contain exactly one "${name}" step`);
-  return matches[0];
-}
-
-function extractReleaseSteps(workflow) {
-  return workflowJob(workflow, 'release').steps;
-}
-
-function runLines(step) {
-  return step.run?.split('\n') ?? [];
-}
-
-function assertRunLine(step, line, message) {
-  assert.ok(runLines(step).includes(line), message);
-}
-
-function matrixRowsWithKey(matrix, key) {
-  return matrix.include.filter((row) => {
-    const fields = row.match(/^\{(.*)\}$/)?.[1] ?? row;
-    return new RegExp(`(?:^|,)\\s*${key}\\s*:`).test(fields);
-  });
-}
-
-function effectiveStepEnv(job, step, key) {
-  if (Object.hasOwn(step.env, key)) return step.env[key];
-  return job.env[key];
-}
-
-function cargoBuildCommands(step) {
-  return runLines(step).filter((line) => /\bcargo\s+build(?:\s|$)/.test(line));
-}
-
-function assertRepeatedCommand(commands, expected, count, message) {
-  assert.equal(commands.length, count, message);
-  for (const command of commands) {
-    assert.equal(command, expected, message);
-  }
-}
-
-function assertProvenanceDigestLinkage(step) {
-  for (const line of [
-    'FIRST=$(sha256 "_asset/$ASSET")',
-    'SECOND=$(sha256 "$BIN")',
-    'cmp "_asset/$ASSET" "$BIN"',
-    'test "$FIRST" = "$SECOND"',
-    'ASSET_DIGEST=$FIRST \\',
-    'assetDigest: process.env.ASSET_DIGEST,',
-  ]) {
-    assertRunLine(step, line, `reproducibility step must preserve digest/provenance linkage: ${line}`);
-  }
-}
-
-function assertMatrixRustflags(job) {
-  assert.ok(job.matrix, 'jobs.build must define a strategy matrix');
-  assert.ok(job.matrix.include.length > 0, 'jobs.build matrix must define include rows');
-  assert.equal(
-    matrixRowsWithKey(job.matrix, 'rustflags').length,
-    job.matrix.include.length,
-    'every jobs.build matrix include row must define rustflags',
-  );
-  assert.equal(
-    job.env.RUSTFLAGS,
-    '${{ matrix.rustflags }}',
-    'jobs.build must set RUSTFLAGS from matrix.rustflags',
-  );
-}
-
-function assertProtocolStep(job) {
-  const protocol = namedStep(job, 'Test protocol');
-  assert.equal(
-    protocol.env.RUSTFLAGS,
-    '',
-    'protocol tests must explicitly clear RUSTFLAGS for loadable host proc-macro dylibs',
-  );
-  assertRunLine(
-    protocol,
-    'cargo test --locked --manifest-path native/mixdog-graph/Cargo.toml',
-    'Test protocol step must own the locked graph protocol test command',
-  );
-}
-
-function assertReproducibilityStep(job) {
-  const reproducibility = namedStep(job, 'Build twice and compare');
-  assert.equal(
-    effectiveStepEnv(job, reproducibility, 'RUSTFLAGS'),
-    '${{ matrix.rustflags }}',
-    'reproducibility builds must preserve matrix RUSTFLAGS',
-  );
-  assertRepeatedCommand(
-    cargoBuildCommands(reproducibility),
-    'cargo build --locked --release --target "${{ matrix.target }}" --manifest-path native/mixdog-graph/Cargo.toml',
-    2,
-    'Build twice and compare must own exactly two targeted locked release cargo build commands',
-  );
-  assertProvenanceDigestLinkage(reproducibility);
-}
-
-function assertGraphReleaseRustflagsContract(workflow) {
-  const build = workflowJob(workflow, 'build');
-  assertMatrixRustflags(build);
-  assertProtocolStep(build);
-  assertReproducibilityStep(build);
-}
-
-function assertReleaseWorkflowOrdering(workflow) {
-  const steps = extractReleaseSteps(workflow);
-  const required = [
-    ['Verify bundled release assets', 'node scripts/verify-release-assets.mjs'],
-    ['Install', 'npm ci'],
-    ['Execute code graph from a clean cache', 'npm run test:code-graph-clean-cache'],
-    ['Focused release regressions', 'npm run test:release-focused'],
-    ['Smoke', 'npm run smoke'],
-    ['Publish', 'npm publish --provenance --access public'],
-  ];
-  const indexes = {};
-  for (const [name, command] of required) {
-    const matches = steps
-      .map((step, index) => ({ step, index }))
-      .filter(({ step }) => step.name === name);
-    assert.equal(matches.length, 1, `release workflow must contain exactly one "${name}" step`);
-    assert.ok(
-      matches[0].step.run?.split('\n').includes(command),
-      `"${name}" step must run ${command}`,
-    );
-    indexes[name] = matches[0].index;
-  }
-
-  const asset = indexes['Verify bundled release assets'];
-  const install = indexes.Install;
-  const cleanCache = indexes['Execute code graph from a clean cache'];
-  const focused = indexes['Focused release regressions'];
-  const smoke = indexes.Smoke;
-  const publish = indexes.Publish;
-  assert.ok(asset < install, 'release asset blocker must run before Install');
-  assert.ok(asset < cleanCache, 'release asset blocker must run before clean-cache graph execution');
-  assert.ok(install < cleanCache, 'Install must run before clean-cache graph execution');
-  assert.ok(cleanCache < focused, 'clean-cache graph execution must run before Focused release regressions');
-  assert.ok(focused < smoke, 'Focused release regressions must run before Smoke');
-  assert.ok(smoke < publish, 'Smoke must run before Publish');
-  assert.ok(asset < publish, 'release asset blocker must run before Publish');
-  assert.ok(cleanCache < publish, 'clean-cache graph execution must run before Publish');
-}
-
 test('accepts independent strict patch, runtime, app, and graph versions', () => {
   assert.equal(validatePatchManifest(patchFixture(), `[package]\nversion = "${VERSION}"\n`).version, VERSION);
   assert.equal(validateRuntimeManifest(runtimeFixture()).release_tag, 'runtime-v1.2.3');
@@ -534,6 +237,13 @@ test('cancels immediately when a stream exceeds its declared size below the abso
 
 test('full guard reads deterministic fixtures and downloads every declared asset', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'mixdog-release-assets-'));
+  const patch = patchFixture();
+  const runtime = runtimeFixture();
+  const graph = graphFixture();
+  const expectedUrls = new Set(
+    [...Object.values(patch.assets), ...Object.values(runtime.assets), ...Object.values(graph.assets)]
+      .map(({ url }) => url),
+  );
   const paths = {
     patchManifestPath: join(dir, 'patch.json'),
     cargoPath: join(dir, 'Cargo.toml'),
@@ -542,21 +252,23 @@ test('full guard reads deterministic fixtures and downloads every declared asset
     packagePath: join(dir, 'package.json'),
   };
   await Promise.all([
-    writeFile(paths.patchManifestPath, JSON.stringify(patchFixture())),
+    writeFile(paths.patchManifestPath, JSON.stringify(patch)),
     writeFile(paths.cargoPath, `[package]\nversion = "${VERSION}"\n`),
-    writeFile(paths.runtimeManifestPath, JSON.stringify(runtimeFixture())),
-    writeFile(paths.graphManifestPath, JSON.stringify(graphFixture())),
+    writeFile(paths.runtimeManifestPath, JSON.stringify(runtime)),
+    writeFile(paths.graphManifestPath, JSON.stringify(graph)),
     writeFile(paths.packagePath, JSON.stringify({ version: APP_VERSION })),
   ]);
   let downloads = 0;
+  const requestedUrls = [];
   try {
     await verifyReleaseAssets({
       ...paths,
       downloadOptions: {
         attempts: 1,
         timeoutMs: 1000,
-        fetchImpl: async () => {
+        fetchImpl: async (url) => {
           downloads += 1;
+          requestedUrls.push(url);
           return new Response(bytes);
         },
       },
@@ -565,83 +277,5 @@ test('full guard reads deterministic fixtures and downloads every declared asset
     await rm(dir, { recursive: true, force: true });
   }
   assert.equal(downloads, 15);
-});
-
-test('release workflow orders the asset and clean-cache blockers before consumers', async () => {
-  const workflow = await readFile(new URL('../.github/workflows/release.yml', import.meta.url), 'utf8');
-  assertReleaseWorkflowOrdering(workflow);
-
-  const quotedNames = workflow
-    .replace('- name: Install', '- name: "Install"')
-    .replace('- name: Smoke', "- name: 'Smoke'");
-  assertReleaseWorkflowOrdering(quotedNames);
-
-  const wrongStep = workflow
-    .replace('run: npm run smoke', 'run: echo smoke')
-    .replace('run: npm run test:release-focused', 'run: npm run test:release-focused\n      # npm run smoke');
-  assert.throws(() => assertReleaseWorkflowOrdering(wrongStep), /"Smoke" step must run npm run smoke/);
-
-  const otherJob = workflow
-    .replace('run: npm run smoke', 'run: echo smoke')
-    .replace(
-      '\n  release:',
-      '\n  decoy:\n    steps:\n      - name: Smoke\n        run: npm run smoke\n  release:',
-    );
-  assert.throws(() => assertReleaseWorkflowOrdering(otherJob), /"Smoke" step must run npm run smoke/);
-});
-
-test('graph release clears test RUSTFLAGS but keeps targeted reproducibility builds', async () => {
-  const workflow = await readFile(new URL('../.github/workflows/graph-release.yml', import.meta.url), 'utf8');
-  assertGraphReleaseRustflagsContract(workflow);
-
-  const quotedNames = workflow
-    .replace('- name: Test protocol', '- name: "Test protocol"')
-    .replace('- name: Build twice and compare', "- name: 'Build twice and compare'");
-  assertGraphReleaseRustflagsContract(quotedNames);
-
-  assert.throws(
-    () => assertGraphReleaseRustflagsContract(workflow.replace('          RUSTFLAGS: ""', '          RUSTFLAGS: "-C unsafe-for-host"')),
-    /protocol tests must explicitly clear RUSTFLAGS/,
-  );
-  assert.throws(
-    () => assertGraphReleaseRustflagsContract(workflow.replace('--release --target', '--release')),
-    /exactly two targeted locked release cargo build commands/,
-  );
-
-  const renamedBuild = workflow
-    .replace('\n  build:\n', '\n  renamed-build:\n')
-    .replace(
-      '\n  gate:',
-      '\n  decoy-build:\n    env:\n      RUSTFLAGS: ${{ matrix.rustflags }}\n'
-        + '    steps:\n      - name: Test protocol\n'
-        + '        run: cargo test --locked --manifest-path native/mixdog-graph/Cargo.toml\n  gate:',
-    );
-  assert.throws(
-    () => assertGraphReleaseRustflagsContract(renamedBuild),
-    /exactly one jobs\.build/,
-  );
-
-  const commentedBuild = workflow.replace(
-    '          cargo build --locked --release --target "${{ matrix.target }}" --manifest-path native/mixdog-graph/Cargo.toml',
-    '          # cargo build --locked --release --target "${{ matrix.target }}" --manifest-path native/mixdog-graph/Cargo.toml',
-  );
-  assert.throws(
-    () => assertGraphReleaseRustflagsContract(commentedBuild),
-    /exactly two targeted locked release cargo build commands/,
-  );
-
-  const commandInWrongStep = workflow
-    .replace(
-      '        run: cargo test --locked --manifest-path native/mixdog-graph/Cargo.toml',
-      '        run: echo protocol command moved',
-    )
-    .replace(
-      '          test "$(git rev-parse HEAD)" = "${{ needs.gate.outputs.source_sha }}"',
-      '          cargo test --locked --manifest-path native/mixdog-graph/Cargo.toml\n'
-        + '          test "$(git rev-parse HEAD)" = "${{ needs.gate.outputs.source_sha }}"',
-    );
-  assert.throws(
-    () => assertGraphReleaseRustflagsContract(commandInWrongStep),
-    /Test protocol step must own/,
-  );
+  assert.deepEqual(new Set(requestedUrls), expectedUrls);
 });

package/src/runtime/memory/lib/embedding-provider.mjs

@@ -104,14 +104,15 @@ function ensureWorker() {
     _restartCount++
   })
   worker.on('exit', (code) => {
+    const exitError = new Error(`Worker exited with code ${code}`)
     if (code !== 0) {
       __mixdogMemoryLog(`[embed] worker exited with code ${code}\n`)
-      for (const [, p] of _pending) p.reject(new Error(`Worker exited with code ${code}`))
-      _pending.clear()
       _restartCount++
     } else {
       _restartCount = 0
     }
+    for (const [, p] of _pending) p.reject(exitError)
+    _pending.clear()
     worker = null
     _modelReady = false
   })