mixdog 0.9.99 → 0.9.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.99",
+  "version": "0.9.101",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/agent-shard-spread-perf.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+// Agent shard spread PERF harness (manual, real provider turns).
+//
+// Measures the Lead-process event-loop impact of an 8-agent fanout in both
+// modes against the SAME real provider route:
+//   OFF — workers run in-process (this process plays the Lead shard).
+//   ON  — workers run as daemon-hosted sessions on other shards
+//         (MIXDOG_AGENT_SHARD_SPREAD=1), daemon isolated via MIXDOG_RUNTIME_ROOT.
+//
+// Run: node scripts/agent-shard-spread-perf.mjs [provider model effort]
+// Defaults to grok-oauth/grok-4.3 low. Uses the REAL user config/keychain for
+// provider auth; worker-index/statusline writes go to a temp dataDir.
+import { copyFileSync, existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { performance } from 'node:perf_hooks';
+
+const ROOT = mkdtempSync(join(tmpdir(), 'mixdog-spread-perf-'));
+process.env.MIXDOG_RUNTIME_ROOT = ROOT;            // isolated perf daemon
+process.env.MIXDOG_DAEMON_SKIP_MEMORY = '1';       // no memory runtime for perf
+// Shard prewarm/creates must not boot a per-root Postgres either: an isolated
+// perf root's postmaster outlives the daemon and leaks (observed: six temp
+// roots holding ~60-100MB PG trees each after a perf session).
+process.env.MIXDOG_BOOT_CORE_MEMORY = '0';
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+process.env.MIXDOG_AGENT_SHARD_SPREAD = '0';       // phase-controlled below
+
+// Isolated DATA_DIR: the daemon owner lock lives in the data dir, so sharing
+// the user's data dir would collide with the LIVE daemon (and revision-2
+// clients must never trigger a replacement drain on it). Copy only the config
+// and the provider credential files the perf route needs.
+const DATA_DIR = join(ROOT, 'data');
+mkdirSync(DATA_DIR, { recursive: true });
+const REAL_DATA_DIR = join(homedir(), '.mixdog', 'data');
+for (const file of [
+  'mixdog-config.json',
+  'grok-oauth.json',
+  'grok-oauth-models.json',
+  'openai-oauth.json',
+  'openai-oauth-models.json',
+  'anthropic-oauth-credentials.json',
+  'anthropic-oauth-models.json',
+]) {
+  const from = join(REAL_DATA_DIR, file);
+  if (existsSync(from)) copyFileSync(from, join(DATA_DIR, file));
+}
+process.env.MIXDOG_DATA_DIR = DATA_DIR;
+
+const PROVIDER = process.argv[2] || 'grok-oauth';
+const MODEL = process.argv[3] || 'grok-4.3';
+const EFFORT = process.argv[4] || 'low';
+const FANOUT = Math.max(1, Number(process.env.SPREAD_PERF_FANOUT) || 8);
+const PHASES = (process.env.SPREAD_PERF_PHASE || 'both').toLowerCase();
+const KEEP = process.env.SPREAD_PERF_KEEP === '1';
+const JOB_TIMEOUT_MS = Math.max(30_000, Number(process.env.SPREAD_PERF_TIMEOUT_MS) || 240_000);
+const WARM_WAIT_MS = Math.max(0, Number(process.env.SPREAD_PERF_WARM_WAIT_MS) || 0);
+const EVICT_WAIT_MS = Math.max(0, Number(process.env.SPREAD_PERF_EVICT_WAIT_MS) || 0);
+const REPO = 'C:/Project/mixdog';
+const PROBE_INTERVAL_MS = 25;
+
+const cfgMod = await import('../src/runtime/agent/orchestrator/config.mjs');
+const reg = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+const mgr = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
+const {
+  attachSession,
+  ensureDaemon,
+  probeSessionHealth,
+  readSessionDiscovery,
+  shutdownDaemon,
+} = await import('../src/standalone/session-client.mjs');
+
+function sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+function taskId(text) { return String(text).match(/agent task: (\S+)/)?.[1] || null; }
+
+function startLagProbe() {
+  const samples = [];
+  let last = performance.now();
+  const timer = setInterval(() => {
+    const now = performance.now();
+    samples.push(Math.max(0, now - last - PROBE_INTERVAL_MS));
+    last = now;
+  }, PROBE_INTERVAL_MS);
+  return {
+    stop() {
+      clearInterval(timer);
+      const sorted = [...samples].sort((a, b) => a - b);
+      const at = (q) => sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * q))] ?? 0;
+      const mean = sorted.length ? sorted.reduce((s, v) => s + v, 0) / sorted.length : 0;
+      return {
+        samples: sorted.length,
+        meanMs: mean,
+        p95Ms: at(0.95),
+        p99Ms: at(0.99),
+        maxMs: sorted[sorted.length - 1] ?? 0,
+        over50ms: sorted.filter((v) => v > 50).length,
+        over250ms: sorted.filter((v) => v > 250).length,
+      };
+    },
+  };
+}
+
+async function waitJob(agent, out, label, timeoutMs = JOB_TIMEOUT_MS) {
+  const id = taskId(out);
+  if (!id) throw new Error(`missing task id for ${label}: ${out}`);
+  const startedAt = Date.now();
+  let last = '';
+  while (Date.now() - startedAt < timeoutMs) {
+    last = await agent.execute({ type: 'read', task_id: id }, { invocationSource: 'model-tool', cwd: REPO });
+    if (/status: (completed|failed|error|cancelled)/.test(last)) return last;
+    await sleep(500);
+  }
+  return `status: timeout\n${last}`;
+}
+
+async function runPhase(name) {
+  const dataDir = join(ROOT, `data-${name}`);
+  mkdirSync(dataDir, { recursive: true });
+  const agent = createStandaloneAgent({
+    cfgMod, reg, mgr, dataDir, cwd: REPO,
+  });
+  const probe = startLagProbe();
+  const t0 = Date.now();
+  const outs = await Promise.all(Array.from({ length: FANOUT }, (_, index) => agent.execute({
+    type: 'spawn',
+    agent: 'worker',
+    provider: PROVIDER,
+    model: MODEL,
+    effort: EFFORT,
+    tag: `${name}-w${index}`,
+    cwd: REPO,
+    prompt: `Read the file package.json in the current repo and reply with exactly the value of its "name" field plus the token #${index}. One short line. Do not edit anything.`,
+  }, { invocationSource: 'model-tool', cwd: REPO })));
+  const results = await Promise.all(outs.map((out, index) => waitJob(agent, out, `${name}-w${index}`)));
+  const wallMs = Date.now() - t0;
+  const lag = probe.stop();
+  const ok = results.filter((r) => /status: completed/.test(r) && /mixdog/i.test(r)).length;
+  try { agent.closeAll(`spread-perf-${name}-end`); } catch { /* teardown */ }
+  return { name, wallMs, lag, ok, results };
+}
+
+function report(phase) {
+  const { lag } = phase;
+  process.stdout.write(
+    `[${phase.name}] ok=${phase.ok}/${FANOUT} wall=${(phase.wallMs / 1000).toFixed(1)}s `
+    + `loopLag mean=${lag.meanMs.toFixed(2)}ms p95=${lag.p95Ms.toFixed(1)}ms `
+    + `p99=${lag.p99Ms.toFixed(1)}ms max=${lag.maxMs.toFixed(0)}ms `
+    + `>50ms=${lag.over50ms} >250ms=${lag.over250ms} (n=${lag.samples})\n`,
+  );
+}
+
+function processRssMb(pids) {
+  const rss = new Map();
+  const wanted = pids.filter((pid) => Number.isInteger(pid) && pid > 0);
+  if (!wanted.length) return rss;
+  try {
+    const out = execFileSync('powershell', [
+      '-NoProfile', '-Command',
+      `Get-Process -Id ${wanted.join(',')} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id) $($_.WorkingSet64)" }`,
+    ], { encoding: 'utf8' });
+    for (const line of out.split(/\r?\n/)) {
+      const [pid, bytes] = line.trim().split(/\s+/);
+      if (pid && bytes) rss.set(Number(pid), Number(bytes) / (1024 * 1024));
+    }
+  } catch { /* best-effort */ }
+  return rss;
+}
+
+async function printShardLoad(discovery) {
+  const health = await probeSessionHealth({ port: discovery.port, token: discovery.token, timeoutMs: 3_000 });
+  const shards = health?.sessionShards?.shards || [];
+  const rss = processRssMb([health?.pid, ...shards.map((shard) => shard.pid)]);
+  const daemonRss = rss.get(Number(health?.pid));
+  process.stdout.write(`[load] daemon pid=${health?.pid} sessions=${health?.sessions} busy=${health?.busy}`
+    + `${daemonRss ? ` rss=${daemonRss.toFixed(0)}MB` : ''}\n`);
+  for (const shard of shards) {
+    if (!shard.pid) continue;
+    const mb = rss.get(Number(shard.pid));
+    process.stdout.write(`[load] shard ${shard.index}: pid=${shard.pid} runtimes=${shard.runtimes}`
+      + ` pending=${shard.pending}${mb ? ` rss=${mb.toFixed(0)}MB` : ''}\n`);
+  }
+}
+
+try {
+  // Phase 1 — spread OFF: workers share this process's event loop.
+  const off = PHASES !== 'on' ? await runPhase('off') : null;
+  if (off) report(off);
+
+  // Phase 2 — spread ON: isolated daemon + shard pool host the workers.
+  let on = null;
+  if (PHASES !== 'off') {
+    process.env.MIXDOG_AGENT_SHARD_SPREAD = '1';
+    const discovery = await ensureDaemon({ cwd: REPO, log: (line) => process.stdout.write(`[daemon-spawn] ${line}\n`) });
+    const health = await probeSessionHealth({ port: discovery.port, token: discovery.token });
+    process.stdout.write(`[on] perf daemon pid=${discovery.pid} rev=${health?.revision}\n`);
+    if (WARM_WAIT_MS > 0) {
+      // Warm-daemon scenario: the spread-prewarm starts on client REGISTRATION,
+      // so attach once, then give it time to boot the peer shards before the
+      // fanout — mirroring a daemon that has been serving a client for a while.
+      await attachSession({
+        discovery,
+        lifecycle: false,
+        cwd: REPO,
+        onFrame: () => {},
+        onFatal: () => {},
+      }).catch(() => {});
+      await sleep(WARM_WAIT_MS);
+      await printShardLoad(discovery).catch(() => {});
+    }
+    on = await runPhase('on');
+    report(on);
+    await printShardLoad(discovery).catch(() => {});
+    if (EVICT_WAIT_MS > 0) {
+      // Reclamation probe: idle+unwatched worker runtimes should be evicted
+      // (service sweep) and their shard RSS returned after this window.
+      await sleep(EVICT_WAIT_MS);
+      process.stdout.write(`[load] after ${(EVICT_WAIT_MS / 1000).toFixed(0)}s idle:\n`);
+      await printShardLoad(discovery).catch(() => {});
+    }
+  }
+
+  for (const phase of [off, on].filter(Boolean)) {
+    for (const [index, result] of phase.results.entries()) {
+      if (!/status: completed/.test(result) || !/mixdog/i.test(result)) {
+        process.stdout.write(`--- ${phase.name}-w${index} ---\n${result.slice(0, 600)}\n`);
+      }
+    }
+  }
+  const gate = on || off;
+  const verdict = gate.ok === FANOUT ? 'PASS' : 'FAIL';
+  process.stdout.write(`verdict: ${verdict} (${gate.name}.ok=${gate.ok}/${FANOUT})\n`);
+  process.exitCode = gate.ok === FANOUT ? 0 : 1;
+} finally {
+  if (KEEP) {
+    process.stdout.write(`kept root: ${ROOT}\n`);
+  } else {
+    try { await shutdownDaemon(readSessionDiscovery()); } catch { /* teardown */ }
+    await sleep(300);
+    try { rmSync(ROOT, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }); } catch { /* temp */ }
+  }
+}
+process.exit(process.exitCode || 0);
+

package/scripts/agent-turn-trace-probe.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// Turn-loop stage probe (manual, real provider turns).
+//
+// Runs ONE spread worker through a deliberately sequential multi-round task
+// with the agent trace enabled, then prints the per-iteration stage rows:
+//   loop        — send_ms / pre_send_ms / tool_resume_ms / message_count
+//   sse         — ttft_ms / stream_total_ms per provider request
+//   turn_timing — queue/route/preflight/provider attribution
+//   usage       — input/cached tokens per request (prefix-cache hit signal)
+//
+// Run: node scripts/agent-turn-trace-probe.mjs [provider model effort]
+import { copyFileSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import { join } from 'node:path';
+
+const ROOT = mkdtempSync(join(tmpdir(), 'mixdog-turn-trace-'));
+process.env.MIXDOG_RUNTIME_ROOT = ROOT;
+process.env.MIXDOG_DAEMON_SKIP_MEMORY = '1';
+process.env.MIXDOG_BOOT_CORE_MEMORY = '0';
+process.env.MIXDOG_AGENT_SHARD_SPREAD = '1';
+// The probe's whole point is the trace: explicit path (shared by daemon and
+// shard children via env inheritance) + timing rows.
+const TRACE_PATH = join(ROOT, 'agent-trace.jsonl');
+delete process.env.MIXDOG_AGENT_TRACE_DISABLE;
+process.env.MIXDOG_AGENT_TRACE_PATH = TRACE_PATH;
+process.env.MIXDOG_AGENT_TRACE_TIMING = '1';
+
+const DATA_DIR = join(ROOT, 'data');
+mkdirSync(DATA_DIR, { recursive: true });
+const REAL_DATA_DIR = join(homedir(), '.mixdog', 'data');
+for (const file of [
+  'mixdog-config.json',
+  'grok-oauth.json',
+  'grok-oauth-models.json',
+  'openai-oauth.json',
+  'openai-oauth-models.json',
+  'anthropic-oauth-credentials.json',
+  'anthropic-oauth-models.json',
+]) {
+  const from = join(REAL_DATA_DIR, file);
+  if (existsSync(from)) copyFileSync(from, join(DATA_DIR, file));
+}
+process.env.MIXDOG_DATA_DIR = DATA_DIR;
+
+const PROVIDER = process.argv[2] || 'grok-oauth';
+const MODEL = process.argv[3] || 'grok-4.3';
+const EFFORT = process.argv[4] || 'low';
+const REPO = 'C:/Project/mixdog';
+const JOB_TIMEOUT_MS = 240_000;
+
+const cfgMod = await import('../src/runtime/agent/orchestrator/config.mjs');
+const reg = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+const mgr = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
+const { ensureDaemon, readSessionDiscovery, shutdownDaemon } = await import('../src/standalone/session-client.mjs');
+
+function sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+
+try {
+  await ensureDaemon({ cwd: REPO, log: () => {} });
+  const agent = createStandaloneAgent({ cfgMod, reg, mgr, dataDir: join(ROOT, 'data-probe'), cwd: REPO });
+  const t0 = Date.now();
+  const out = await agent.execute({
+    type: 'spawn',
+    agent: 'worker',
+    provider: PROVIDER,
+    model: MODEL,
+    effort: EFFORT,
+    tag: 'turn-trace',
+    cwd: REPO,
+    prompt: [
+      'Execute these steps strictly IN ORDER, exactly ONE tool call per assistant message',
+      '(never batch two calls in one message — this measures sequential rounds):',
+      '1) read package.json',
+      '2) read README.md (first 40 lines)',
+      '3) run the shell command: node -v',
+      '4) read apps/desktop/package.json',
+      '5) grep the string "createSessionRuntimePool" under src/standalone (files list only)',
+      'Then reply with one line: DONE <package name> <node version>. Do not edit anything.',
+    ].join('\n'),
+  }, { invocationSource: 'model-tool', cwd: REPO });
+  const id = String(out).match(/agent task: (\S+)/)?.[1];
+  if (!id) throw new Error(`no task id: ${out}`);
+  let last = '';
+  while (Date.now() - t0 < JOB_TIMEOUT_MS) {
+    last = await agent.execute({ type: 'read', task_id: id }, { invocationSource: 'model-tool', cwd: REPO });
+    if (/status: (completed|failed|error|cancelled)/.test(last)) break;
+    await sleep(500);
+  }
+  process.stdout.write(`wall=${((Date.now() - t0) / 1000).toFixed(1)}s\n--- result ---\n${last.slice(0, 400)}\n`);
+  try { agent.closeAll('turn-trace probe end'); } catch { /* teardown */ }
+
+  // Shard children flush their local trace buffers on a short timer.
+  await sleep(9_000);
+  const rows = existsSync(TRACE_PATH)
+    ? readFileSync(TRACE_PATH, 'utf8').split('\n').filter(Boolean).flatMap((line) => {
+      try { return [JSON.parse(line)]; } catch { return []; }
+    })
+    : [];
+  process.stdout.write(`--- trace (${rows.length} rows) ---\n`);
+  for (const row of rows) {
+    if (row.kind === 'loop') {
+      process.stdout.write(`[loop] iter=${row.iteration ?? row.payload?.iteration} send=${row.send_ms ?? row.payload?.send_ms}ms`
+        + ` preSend=${row.pre_send_ms ?? row.payload?.pre_send_ms}ms toolResume=${row.tool_resume_ms ?? row.payload?.tool_resume_ms}ms`
+        + ` msgs=${row.message_count ?? row.payload?.message_count}\n`);
+    } else if (row.kind === 'sse') {
+      process.stdout.write(`[sse] ttft=${row.ttft_ms}ms streamTotal=${row.stream_total_ms}ms\n`);
+    } else if (row.kind === 'turn_timing') {
+      process.stdout.write(`[turn] status=${row.status} ttft=${row.ttft_ms}ms e2eTtft=${row.end_to_end_ttft_ms}ms`
+        + ` queue=${row.queue_ms}ms route=${row.route_ms}ms preflight=${row.preflight_ms}ms provider=${row.provider_ms}ms\n`);
+    } else if (row.kind === 'usage_raw') {
+      process.stdout.write(`[usage] iter=${row.iteration} input=${row.input_tokens} cached=${row.cached_tokens}`
+        + ` cacheWrite=${row.cache_write_tokens} uncached=${row.uncached_input_tokens} output=${row.output_tokens}`
+        + ` chain=${row.chain_continuous ?? '-'}\n`);
+    } else if (row.kind === 'tool') {
+      const p = row.payload || row;
+      process.stdout.write(`[tool] ${row.tool || row.tool_name || p.tool || p.tool_name || ''}`
+        + ` ${row.duration_ms ?? row.tool_ms ?? p.duration_ms ?? p.tool_ms ?? '?'}ms\n`);
+    } else {
+      process.stdout.write(`[${row.kind}] ${JSON.stringify(row).slice(0, 220)}\n`);
+    }
+  }
+} finally {
+  try { await shutdownDaemon(readSessionDiscovery()); } catch { /* teardown */ }
+  await sleep(300);
+  try { rmSync(ROOT, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }); } catch { /* temp */ }
+}
+process.exit(0);

package/scripts/dependency-lock-cache-key.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto'
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { normalizeRuntimeLockfile } from './runtime-dependency-cache-key.mjs'
+
+export const DEPENDENCY_LOCK_CACHE_SCHEMA = 1
+
+export function dependencyLockCacheKey(lockfile) {
+  const normalized = normalizeRuntimeLockfile(lockfile)
+  const fingerprint = createHash('sha256')
+    .update(JSON.stringify(normalized))
+    .digest('hex')
+  return `dependency-lock-v${DEPENDENCY_LOCK_CACHE_SCHEMA}-${fingerprint}`
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : ''
+if (invokedPath === import.meta.url) {
+  const lockfilePath = process.argv[2]
+  if (!lockfilePath) throw new Error('Usage: dependency-lock-cache-key.mjs <package-lock.json>')
+  readFile(resolve(lockfilePath))
+    .then((lockfile) => process.stdout.write(`${dependencyLockCacheKey(lockfile)}\n`))
+    .catch((error) => {
+      process.stderr.write(`Dependency lock cache key failed: ${error?.message || error}\n`)
+      process.exitCode = 1
+    })
+}

package/scripts/fixtures/session-shard-fixture-worker.mjs

@@ -0,0 +1,13 @@
+// Minimal session-shard stand-in for pool placement tests: acknowledges the
+// shard IPC surface (create/call/snapshot/prewarm/workload/shutdown) without
+// booting the real session runtime graph, so placement is observable fast.
+process.on('message', (message) => {
+  if (!message || typeof message !== 'object' || !message.requestId) return;
+  process.send({
+    type: 'response',
+    requestId: message.requestId,
+    ok: true,
+    value: message.type === 'create' ? { created: true } : { ready: true },
+  });
+  if (message.type === 'shutdown') setImmediate(() => process.exit(0));
+});

package/scripts/fixtures/spawn-lease-child-harness.mjs

@@ -0,0 +1,8 @@
+// Child-side gate harness: runs child-spawn-gate acquire() in shard mode so a
+// forked test parent can play the pool's role in the lease protocol.
+const { acquire } = await import(new URL('../../src/runtime/shared/child-spawn-gate.mjs', import.meta.url));
+const release = await acquire(null, 'search', { ownerKey: 'harness' });
+process.send({ type: 'harness-event', event: 'granted' });
+release();
+process.send({ type: 'harness-event', event: 'released' });
+setTimeout(() => process.exit(0), 200);

package/scripts/fixtures/spawn-lease-fixture-worker.mjs

@@ -0,0 +1,33 @@
+// Minimal shard stand-in for the machine spawn-budget protocol test. Replies
+// ok to any requestId message (prewarm/shutdown) and drives the lease
+// protocol on a fixed clock; grants are recorded as marker files so the test
+// can observe ordering without extra IPC surface.
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const outDir = process.env.SPAWN_LEASE_FIXTURE_DIR || process.cwd();
+const record = (name) => {
+  try { writeFileSync(join(outDir, name), String(Date.now())); } catch { /* test observes absence */ }
+};
+
+process.on('message', (message) => {
+  if (!message || typeof message !== 'object') return;
+  if (message.type === 'spawn-lease-result') {
+    record(`${message.leaseId}-${message.ok === true ? 'granted' : 'rejected'}`);
+    return;
+  }
+  if (message.requestId) {
+    process.send({ type: 'response', requestId: message.requestId, ok: true, value: { ready: true } });
+    if (message.type === 'shutdown') setImmediate(() => process.exit(0));
+  }
+});
+
+process.send({ type: 'spawn-lease', leaseId: 'lease-a', lane: 'search', ownerKey: 'fixture-a' });
+setTimeout(() => {
+  process.send({ type: 'spawn-lease', leaseId: 'lease-b', lane: 'search', ownerKey: 'fixture-b' });
+}, 150);
+// Release A well after the test has observed that B stays queued behind the
+// machine cap of 1.
+setTimeout(() => {
+  process.send({ type: 'spawn-release', leaseId: 'lease-a' });
+}, 1_800);

package/scripts/prune-embedding-runtime.mjs

@@ -29,7 +29,11 @@ async function removeChildrenExcept(directory, keep) {
   }
   await Promise.all(entries
     .filter((entry) => !keep.has(entry.name))
-    .map((entry) => rm(join(directory, entry.name), { recursive: true, force: true })))
+    // Windows: pruning a freshly-installed npm tree races AV scans; bounded
+    // retries absorb the transient ENOTEMPTY/EPERM rmdir failures.
+    .map((entry) => rm(join(directory, entry.name), {
+      recursive: true, force: true, maxRetries: 10, retryDelay: 250,
+    })))
 }
 
 async function packageName(directory) {

package/src/app.mjs

@@ -87,6 +87,9 @@ export async function run(argv = [], classifiedInvocation = null) {
       model: opts.model,
       effort: opts.effort,
       fast: opts.fast,
+      explore: opts.explore,
+      webSearch: opts.webSearch,
+      memory: opts.memory,
       cwd: process.cwd(),
     });
   }

package/src/headless-command.mjs

@@ -1,6 +1,7 @@
 const VALUE_OPTIONS = new Set(['--provider', '--model', '--effort', '--workflow']);
 const FLAG_OPTIONS = new Set([
   '--readonly', '--help', '-h', '--plain', '--react', '--remote', '--onboarding', '--fast',
+  '--explore', '--web-search', '--memory',
 ]);
 const HEADLESS_ROLE_ALIASES = new Map([
   ['explorer', 'explore'], ['explore', 'explore'],
@@ -108,6 +109,9 @@ export function classifyCliInvocation(argv = []) {
     model: parsed.values['--model'],
     effort: parsed.values['--effort'],
     fast: argv.includes('--fast'),
+    explore: argv.includes('--explore'),
+    webSearch: argv.includes('--web-search'),
+    memory: argv.includes('--memory'),
     toolMode: argv.includes('--readonly') ? 'readonly' : 'full',
     remote: argv.includes('--remote'),
     forceOnboarding: argv.includes('--onboarding'),

package/src/headless-role.mjs

@@ -83,6 +83,9 @@ export async function runHeadlessRole({
   model,
   effort,
   fast,
+  explore = false,
+  webSearch = false,
+  memory = false,
   cwd = process.cwd(),
   write = (text) => stdout.write(text),
   writeErr = (text) => stderr.write(text),
@@ -90,6 +93,16 @@ export async function runHeadlessRole({
 } = {}) {
   const cleanAgent = clean(agent);
   const cleanMessage = clean(message);
+  // Classic headless surface: explorer, web search, and memory tools start OFF
+  // and opt back in per run (--explore / --web-search / --memory). An explicit
+  // MIXDOG_FEATURE_* value from the caller environment always wins.
+  for (const [key, enabled] of [
+    ['MIXDOG_FEATURE_EXPLORE', explore],
+    ['MIXDOG_FEATURE_WEB_SEARCH', webSearch],
+    ['MIXDOG_FEATURE_MEMORY', memory],
+  ]) {
+    if (!clean(process.env[key])) process.env[key] = enabled === true ? '1' : '0';
+  }
   if (!cleanAgent) {
     writeErr('mixdog: agent is required\n');
     return 1;

package/src/rules/agent/00-core.md

@@ -2,13 +2,10 @@
 
 - Agent communication is English.
 - Call tools immediately: no preamble/progress; text only in final handoff.
-- Final handoff is fragments: outcome, key `file:line`, verification
-  command+result, material risk/blocker. Never repeat the brief, process,
-  search path, or facts; never retrieve only to report.
-- Limit the handoff to 30 lines unless `Deliver:` sets another limit. Never use
-  unrequested headings/tables, prose narration, raw logs/tool traces,
-  speculative next checks, restated briefs, articles, or politeness.
-- Follow stricter role contracts and runtime wrap-up requirements.
-- Your final message ends the task: emit the handoff text only when the work is
+- Final handoff: outcome, key `file:line`, material risk/blocker, and one
+  batched verification result when files were edited — fragments, max 30
+  lines unless `Deliver:` overrides; never raw logs, process narration, or
+  brief restatement.
+- Your final message ends the task: emit the handoff only when the work is
   done. If a tool failed and stays unresolved, fix and re-run it, or say so
   explicitly in the handoff.