mixdog 0.9.38 → 0.9.39

package/scripts/internal-comms-bench.mjs

@@ -7,7 +7,7 @@
 //
 //   node scripts/internal-comms-bench.mjs
 //   node scripts/internal-comms-bench.mjs --run [--model grok] [--provider P] [--json]
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import {
   copyFileSync,
   cpSync,
@@ -31,11 +31,16 @@ const HEADLESS = pathToFileURL(resolve(__dir, '../src/headless-role.mjs')).href;
 const RULE_FILES = [
   'rules/agent/00-core.md',
   'rules/agent/00-common.md',
+  'rules/agent/20-skip-protocol.md',
   'agents/worker/AGENT.md',
   'agents/heavy-worker/AGENT.md',
   'agents/reviewer/AGENT.md',
   'agents/debugger/AGENT.md',
   'workflows/default/WORKFLOW.md',
+  'workflows/solo/WORKFLOW.md',
+  'workflows/bench/WORKFLOW.md',
+  'rules/lead/01-general.md',
+  'rules/lead/02-channels.md',
   'rules/lead/lead-tool.md',
   'rules/lead/lead-brief.md',
 ];
@@ -48,11 +53,12 @@ const DEFAULT_WORKER_PROMPT =
 // Identical across variants A/B; only the on-disk rule files differ.
 const DEFAULT_LEAD_PROMPT = [
   'You are the Lead in an automation benchmark. A file named math.js already exists in your working directory.',
-  'Do NOT edit any file yourself and do NOT call apply_patch yourself. You MUST delegate every implementation step.',
-  'Step 1: call the agent tool with agent "worker" and give it a brief to add an exported function add(a, b) that returns a + b to math.js, keeping the existing mul export unchanged, using apply_patch only.',
-  'Step 2: after the worker hands off, call the agent tool with agent "reviewer" and give it a brief to verify that math.js exports both add and mul.',
-  'Step 3: stop and reply with a one-line outcome plus math.js:line. Do exactly these three steps and nothing else.',
+  'This is the planning turn: give a concise plan only, then wait for a later explicit approval. Do not edit, mutate state, or delegate in this turn.',
+  'After approval, do NOT edit any file yourself or call apply_patch yourself. Delegate every implementation step: first a worker adds exported add(a, b) returning a + b to math.js while preserving mul, then a reviewer verifies both exports. Finally reply with a one-line outcome plus math.js:line.',
 ].join(' ');
+export const DEFAULT_LEAD_APPROVAL_PROMPT = 'Proceed with the latest plan.';
+export const CHILD_RESULT_START = '__INTERNAL_COMMS_BENCH_RESULT_START__';
+export const CHILD_RESULT_END = '__INTERNAL_COMMS_BENCH_RESULT_END__';
 
 const MODEL_ALIASES = {
   opus: { provider: 'anthropic-oauth', model: 'claude-opus-4-8' },
@@ -383,6 +389,18 @@ function emptyRoleSplit(dataDir) {
   };
 }
 
+function mathTaskCompleted(taskCwd) {
+  let source = '';
+  try {
+    source = readFileSync(join(taskCwd, 'math.js'), 'utf8');
+  } catch {
+    return false;
+  }
+  return source !== INITIAL_MATH_JS
+    && /export\s+function\s+add\s*\(\s*a\s*,\s*b\s*\)\s*\{\s*return\s+a\s*\+\s*b\s*;?\s*\}/.test(source)
+    && /export\s+function\s+mul\s*\(\s*a\s*,\s*b\s*\)\s*\{\s*return\s+a\s*\*\s*b\s*;?\s*\}/.test(source);
+}
+
 function splitTokensByRole(dataDir, rootSessionId) {
   const tracePath = join(dataDir, 'history', 'agent-trace.jsonl');
   const rows = readRows(tracePath);
@@ -420,6 +438,21 @@ function splitTokensByRole(dataDir, rootSessionId) {
   return { tracePath, session_ids: [...treeIds], byRole, total };
 }
 
+export function validateLeadRun({ taskCwd, run, split }) {
+  const reasons = [];
+  if (!run.ok) reasons.push('child did not return a successful benchmark result');
+  if (!mathTaskCompleted(taskCwd)) reasons.push('math.js does not contain the approved add and preserved mul implementation');
+  if ((split?.byRole?.worker?.usage_rows || 0) < 1) reasons.push('worker participation/usage is missing');
+  if ((split?.byRole?.reviewer?.usage_rows || 0) < 1) reasons.push('reviewer participation/usage is missing');
+  return { valid: reasons.length === 0, reasons };
+}
+
+export function leadModeExitCode(runsMeta, perVariant) {
+  const allValid = ['A', 'B'].every((variant) => runsMeta[variant].length > 0 && runsMeta[variant].every((run) => run.valid));
+  const anyUsage = ['A', 'B'].some((variant) => perVariant[variant].some((split) => split.total.usage_rows > 0));
+  return allValid && anyUsage ? 0 : 1;
+}
+
 function median(values) {
   const arr = values.filter((v) => Number.isFinite(v)).sort((a, b) => a - b);
   if (!arr.length) return 0;
@@ -443,54 +476,120 @@ function aggregateVariant(splits) {
   return out;
 }
 
-// Drives a REAL Lead session in the variant sandbox (createSession/askSession/
-// closeSession from the runtime manager — same pattern as output-style-bench).
-// The variant rule files take effect through MIXDOG_ROOT; the runtime modules
-// themselves are imported from the real PLUGIN_ROOT (identical across variants).
-function runLiveLeadDelegation({ pluginRoot, dataDir, taskCwd, prompt, provider, model, effort, fast }) {
-  const cfgUrl = pathToFileURL(join(PLUGIN_ROOT, 'runtime/agent/orchestrator/config.mjs')).href;
-  const regUrl = pathToFileURL(join(PLUGIN_ROOT, 'runtime/agent/orchestrator/providers/registry.mjs')).href;
-  const mgrUrl = pathToFileURL(join(PLUGIN_ROOT, 'runtime/agent/orchestrator/session/manager.mjs')).href;
-  const driver = [
-    `import * as cfgMod from ${JSON.stringify(cfgUrl)};`,
-    `import * as reg from ${JSON.stringify(regUrl)};`,
-    `import { createSession, askSession, closeSession } from ${JSON.stringify(mgrUrl)};`,
-    `const config = cfgMod.loadConfig({ secrets: true });`,
-    `await reg.initProviders(config.providers || {});`,
-    `const sessionOpts = { provider: ${JSON.stringify(provider)}, model: ${JSON.stringify(model)},`,
-    `  owner: 'cli', agent: 'lead', lane: 'cli', sourceType: 'lead', sourceName: 'internal-comms-bench-lead',`,
-    `  cwd: ${JSON.stringify(taskCwd)}, tools: 'full', fast: ${fast ? 'true' : 'false'} };`,
-    effort ? `sessionOpts.effort = ${JSON.stringify(effort)};` : '',
-    `const session = createSession(sessionOpts);`,
-    `let result;`,
-    `try { result = await askSession(session.id, ${JSON.stringify(prompt)}, null, null, ${JSON.stringify(taskCwd)}); }`,
-    `finally { try { closeSession(session.id, 'internal-comms-bench-lead'); } catch {} }`,
-    `process.stdout.write(JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId: session.id }));`,
+// Drives a REAL Lead session in the variant sandbox through the public session
+// runtime, including its deferred standalone tool surface.
+// The variant rule files and public runtime modules take effect through the
+// sandboxed MIXDOG_ROOT.
+export function buildLiveLeadDriver({
+  runtimeUrl,
+  traceUrl = pathToFileURL(join(PLUGIN_ROOT, 'runtime/agent/orchestrator/agent-trace-io.mjs')).href,
+  taskCwd,
+  prompt,
+  approvalPrompt = DEFAULT_LEAD_APPROVAL_PROMPT,
+  provider,
+  model,
+  effort,
+  fast,
+}) {
+  return [
+    `import { createMixdogSessionRuntime } from ${JSON.stringify(runtimeUrl)};`,
+    `import { drainAgentTrace } from ${JSON.stringify(traceUrl)};`,
+    `const rt = await createMixdogSessionRuntime({ provider: ${JSON.stringify(provider)}, model: ${JSON.stringify(model)},`,
+    `  cwd: ${JSON.stringify(taskCwd)}, toolMode: 'full' });`,
+    effort ? `await rt.setEffort(${JSON.stringify(effort)});` : '',
+    fast !== undefined ? `await rt.setFast(${JSON.stringify(fast)});` : '',
+    `const prePromptTools = rt.toolsStatus?.()?.activeTools || [];`,
+    `if (!prePromptTools.includes('agent')) throw new Error('Lead runtime agent tool is not active');`,
+    `let busy = false; let kickDeferred = false; let wake = null;`,
+    `rt.onNotification(() => { queueMicrotask(() => { kickDeferred = true; if (!busy && wake) wake(); }); return false; });`,
+    `const askOnce = async (msg) => { busy = true; try { const { result } = await rt.ask(msg); return result; } finally { busy = false; } };`,
+    `const agentsBusy = () => { const jobs = rt.agentStatus?.()?.agentJobs || []; return jobs.some((j) => /running|pending|spawn|queued/i.test(String(j?.status || j?.state || ''))); };`,
+    `let result; let sessionId = '';`,
+    `try {`,
+    `  await askOnce(${JSON.stringify(prompt)});`,
+    `  result = await askOnce(${JSON.stringify(approvalPrompt)});`,
+    `  const deadline = Date.now() + 30 * 60_000;`,
+    `  while (Date.now() < deadline) {`,
+    `    if (!kickDeferred) {`,
+    `      if (!agentsBusy()) break;`,
+    `      const kicked = await new Promise((resolve) => { wake = () => resolve(true); setTimeout(() => resolve(false), 10_000); });`,
+    `      wake = null;`,
+    `      if (!kicked && !kickDeferred && !agentsBusy()) break;`,
+    `    }`,
+    `    if (!kickDeferred && !agentsBusy()) break;`,
+    `    kickDeferred = false; result = (await askOnce('')) || result;`,
+    `  }`,
+    `  sessionId = rt.sessionId || rt.id || rt.session?.id || '';`,
+    `}`,
+    `finally { try { await rt.close('internal-comms-bench-lead'); } catch {} }`,
+    `await drainAgentTrace();`,
+    `const benchResult = JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId });`,
+    `process.stdout.write(${JSON.stringify(CHILD_RESULT_START)} + benchResult + ${JSON.stringify(CHILD_RESULT_END)} + '\\n', () => process.exit(0));`,
   ].filter(Boolean).join('\n');
-  const started = Date.now();
-  let raw = '';
-  let ok = false;
-  let sid = null;
+}
+
+export function parseLiveLeadResult(stdout) {
+  const source = String(stdout || '');
+  const start = source.lastIndexOf(CHILD_RESULT_START);
+  if (start < 0) return null;
+  const jsonStart = start + CHILD_RESULT_START.length;
+  const end = source.indexOf(CHILD_RESULT_END, jsonStart);
+  if (end < 0) return null;
   try {
-    raw = execFileSync('node', ['--input-type=module', '-e', driver], {
-      encoding: 'utf8',
-      maxBuffer: 64 * 1024 * 1024,
-      env: {
-        ...process.env,
-        MIXDOG_ROOT: pluginRoot,
-        MIXDOG_DATA_DIR: dataDir,
-      },
-    });
-    const j = raw.lastIndexOf('{');
-    if (j >= 0) { try { sid = JSON.parse(raw.slice(j)).sessionId || null; } catch { /* tail */ } }
-    ok = !!sid;
-  } catch (e) {
-    raw = String(e.stdout || '') + String(e.stderr || '');
-    const j = raw.lastIndexOf('{');
-    if (j >= 0) { try { sid = JSON.parse(raw.slice(j)).sessionId || null; } catch { /* tail */ } }
-    ok = false;
+    const result = JSON.parse(source.slice(jsonStart, end));
+    return typeof result?.sessionId === 'string' && result.sessionId ? result : null;
+  } catch {
+    return null;
   }
-  return { sessionId: sid || extractSessionId(raw), ms: Date.now() - started, ok, raw };
+}
+
+export function runLiveLeadDelegation({
+  pluginRoot,
+  dataDir,
+  taskCwd,
+  prompt,
+  provider,
+  model,
+  effort,
+  fast,
+  runtimeUrls = null,
+}) {
+  const runtimeUrl = runtimeUrls?.runtimeUrl || pathToFileURL(join(pluginRoot, 'mixdog-session-runtime.mjs')).href;
+  const traceUrl = runtimeUrls?.traceUrl || pathToFileURL(join(pluginRoot, 'runtime/agent/orchestrator/agent-trace-io.mjs')).href;
+  const driver = buildLiveLeadDriver({
+    runtimeUrl,
+    traceUrl,
+    taskCwd,
+    prompt,
+    provider,
+    model,
+    effort,
+    fast,
+  });
+  const started = Date.now();
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', driver], {
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+    env: {
+      ...process.env,
+      MIXDOG_ROOT: pluginRoot,
+      MIXDOG_DATA_DIR: dataDir,
+    },
+  });
+  const stdout = String(child.stdout || '');
+  const stderr = String(child.stderr || '');
+  const result = parseLiveLeadResult(stdout);
+  return {
+    sessionId: result?.sessionId || null,
+    ms: Date.now() - started,
+    ok: child.status === 0 && !child.error && !!result,
+    raw: stdout + stderr,
+    stdout,
+    stderr,
+    exitCode: child.status,
+    signal: child.signal || null,
+    error: child.error ? String(child.error.message || child.error) : null,
+  };
 }
 
 function fmtDeltaEntry(entry) {
@@ -505,12 +604,13 @@ function runLeadMode({ route, effort, fast, repeat, jsonMode, leadPrompt }) {
   const sandboxRoot = mkdtempSync(join(REPO_ROOT, '.tmp-internal-comms-bench-lead-'));
   const perVariant = { A: [], B: [] };
   const runsMeta = { A: [], B: [] };
+  let invalidRun = null;
   try {
     const pluginRoots = {
       A: materializePluginRoot('A', sandboxRoot),
       B: materializePluginRoot('B', sandboxRoot),
     };
-    for (let i = 0; i < repeat; i += 1) {
+    runLoop: for (let i = 0; i < repeat; i += 1) {
       for (const variant of ['A', 'B']) {
         const taskCwd = prepareTaskCwd(sandboxRoot);
         const dataDir = prepareDataDir(sandboxRoot, `${variant}-r${i}`, realDataDir, userUnified, route.provider);
@@ -526,15 +626,44 @@ function runLeadMode({ route, effort, fast, repeat, jsonMode, leadPrompt }) {
           fast,
         });
         const split = run.sessionId ? splitTokensByRole(dataDir, run.sessionId) : emptyRoleSplit(dataDir);
-        perVariant[variant].push(split);
-        runsMeta[variant].push({ ok: run.ok, ms: run.ms, sessionId: run.sessionId, total: split.total.total_tokens });
-        process.stderr.write(`[internal-comms-bench]   -> ${run.ok ? 'ok' : 'FAIL'} ${Math.round(run.ms / 1000)}s session=${run.sessionId || '(none)'} total=${split.total.total_tokens} lead=${split.byRole.lead.total_tokens} worker=${split.byRole.worker.total_tokens} reviewer=${split.byRole.reviewer.total_tokens} other=${split.byRole.other.total_tokens}\n`);
+        const validation = validateLeadRun({ taskCwd, run, split });
+        if (validation.valid) perVariant[variant].push(split);
+        const meta = {
+          ok: run.ok,
+          valid: validation.valid,
+          reasons: validation.reasons,
+          ms: run.ms,
+          sessionId: run.sessionId,
+          total: split.total.total_tokens,
+          diagnostics: {
+            stdout: run.stdout,
+            stderr: run.stderr,
+            exitCode: run.exitCode,
+            signal: run.signal,
+            error: run.error,
+          },
+        };
+        runsMeta[variant].push(meta);
+        process.stderr.write(`[internal-comms-bench]   -> ${validation.valid ? 'ok' : 'FAIL'} ${Math.round(run.ms / 1000)}s session=${run.sessionId || '(none)'} total=${split.total.total_tokens} lead=${split.byRole.lead.total_tokens} worker=${split.byRole.worker.total_tokens} reviewer=${split.byRole.reviewer.total_tokens} other=${split.byRole.other.total_tokens}${validation.valid ? '' : ` reasons=${validation.reasons.join('; ')}`}\n`);
+        if (!validation.valid && (run.stdout || run.stderr || run.error)) {
+          process.stderr.write(`[internal-comms-bench] child diagnostics variant=${variant} stdout=${JSON.stringify(run.stdout)} stderr=${JSON.stringify(run.stderr)} error=${JSON.stringify(run.error)}\n`);
+        }
+        if (!validation.valid) {
+          invalidRun = { variant, index: i, reasons: validation.reasons };
+          break runLoop;
+        }
       }
     }
   } finally {
     rmSync(sandboxRoot, { recursive: true, force: true });
   }
 
+  if (invalidRun) {
+    process.stderr.write(`[internal-comms-bench] aborting before aggregation: invalid variant=${invalidRun.variant} run=${invalidRun.index + 1} reasons=${invalidRun.reasons.join('; ')}\n`);
+    process.exit(1);
+    return;
+  }
+
   const aggA = aggregateVariant(perVariant.A);
   const aggB = aggregateVariant(perVariant.B);
   const deltaMedian = {};
@@ -574,9 +703,7 @@ function runLeadMode({ route, effort, fast, repeat, jsonMode, leadPrompt }) {
     console.log('delta B-vs-A (mean):   ' + [...ROLES, 'total'].map((r) => `${r}=${fmtDeltaEntry(deltaMean[r])}`).join(' '));
   }
 
-  const allOk = runsMeta.A.every((r) => r.ok) && runsMeta.B.every((r) => r.ok);
-  const anyUsage = perVariant.A.some((s) => s.total.usage_rows > 0) || perVariant.B.some((s) => s.total.usage_rows > 0);
-  process.exit(allOk && anyUsage ? 0 : 1);
+  process.exit(leadModeExitCode(runsMeta, perVariant));
 }
 
 function pctChange(b, a) {
@@ -724,4 +851,4 @@ function main() {
   process.exit(ok ? 0 : 1);
 }
 
-main();
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main();

package/scripts/internal-comms-smoke.mjs

@@ -19,38 +19,80 @@ function assert(condition, message) {
 function readSrc(...parts) {
   return readFileSync(join(root, 'src', ...parts), 'utf8');
 }
-// Rules wrap across lines; collapse whitespace so phrase asserts are line-agnostic.
-function flat(text) {
-  return String(text || '').replace(/\s+/g, ' ');
+function normalize(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+function rawBlock(text, start, end, label) {
+  const source = String(text);
+  const from = source.indexOf(start);
+  if (from < 0) throw new Error(`${label}: missing start marker ${start}`);
+  const finish = source.indexOf(end, from + start.length);
+  if (finish < 0) throw new Error(`${label}: missing end marker ${end}`);
+  return source.slice(from, finish);
+}
+function block(text, start, end, label) {
+  return normalize(rawBlock(text, start, end, label));
+}
+function bodyAfterFrontmatter(text, label) {
+  const source = String(text);
+  const opening = source.match(/^---[ \t]*\r?\n/);
+  if (!opening) throw new Error(`${label}: missing frontmatter opening fence`);
+  const closing = source.slice(opening[0].length).match(/^---[ \t]*(?:\r?\n|$)/m);
+  if (!closing) throw new Error(`${label}: missing frontmatter closing fence`);
+  return source.slice(opening[0].length + closing.index + closing[0].length);
+}
+function roleBody(text, label) {
+  return normalize(bodyAfterFrontmatter(text, label));
+}
+function frontmatter(text, label) {
+  const source = String(text);
+  const opening = source.match(/^---[ \t]*\r?\n/);
+  if (!opening) throw new Error(`${label}: missing frontmatter opening fence`);
+  const closing = source.slice(opening[0].length).match(/^---[ \t]*(?:\r?\n|$)/m);
+  if (!closing) throw new Error(`${label}: missing frontmatter closing fence`);
+  return source.slice(opening[0].length, opening[0].length + closing.index);
 }
 
-// --- Lead brief contract: canonical in lead-brief.md, referenced from WORKFLOW -
+// --- Compact rule contracts -------------------------------------------------
 const workflow = readSrc('workflows', 'default', 'WORKFLOW.md');
 const leadBrief = readSrc('rules', 'lead', 'lead-brief.md');
+const solo = readSrc('workflows', 'solo', 'WORKFLOW.md');
+const bench = readSrc('workflows', 'bench', 'WORKFLOW.md');
+const general = readSrc('rules', 'lead', '01-general.md');
+const leadTool = readSrc('rules', 'lead', 'lead-tool.md');
+const core = readSrc('rules', 'agent', '00-core.md');
+const common = readSrc('rules', 'agent', '00-common.md');
+const skip = readSrc('rules', 'agent', '20-skip-protocol.md');
 const BRIEF_FIELDS = ['Goal:', 'Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
-// Canonical brief contract lives in lead-brief.md (Lead brief contract).
-assert(/minimum characters, maximum information/i.test(flat(leadBrief)), 'lead-brief.md: brief must state min-char/max-info principle');
+const TOKEN_PRINCIPLE = /minimum (?:characters|chars), maximum (?:information|info)/i;
+function requireAll(text, label, patterns) {
+  for (const pattern of patterns) assert(pattern.test(normalize(text).toLowerCase()), `${label}: missing ${pattern}`);
+}
+assert(TOKEN_PRINCIPLE.test(normalize(leadBrief)), 'lead-brief.md: brief must state min-char/max-info principle');
 for (const field of BRIEF_FIELDS) assert(leadBrief.includes(field), `lead-brief.md: brief missing labeled field ${field}`);
 assert(leadBrief.includes('Stop:'), 'lead-brief.md: brief must add Stop: for heavy-worker bound');
-assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(flat(leadBrief)), 'lead-brief.md: brief must ban restating known rules/background as cost');
-assert(/authoritative/i.test(flat(leadBrief)), 'lead-brief.md: brief must state spec-file precedence over summary');
-// WORKFLOW.md must not duplicate the field list; it defers to the lead brief contract.
-assert(/lead brief contract/i.test(flat(workflow)), 'WORKFLOW.md: must defer to the lead brief contract');
+assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(normalize(leadBrief)), 'lead-brief.md: brief must ban restating known rules/background as cost');
+assert(/spec\/test beats its summary/i.test(normalize(leadBrief)), 'lead-brief.md: spec/test must beat summary');
+requireAll(leadBrief, 'Lead brief lifecycle', [
+  /full brief only for fresh spawn\/`respawned: true`/, /live follow-ups are delta/,
+  /dead-tag send is cold: re-supply anchors/, /never `send` mid-run/,
+  /batch one follow-up after completion/, /interrupt only to cancel/,
+  /agent communication is english/,
+]);
+assert(/lead brief contract/i.test(normalize(workflow)), 'WORKFLOW.md: must defer to the lead brief contract');
 assert(!BRIEF_FIELDS.every((field) => workflow.includes(field)), 'WORKFLOW.md: must not duplicate the full brief field list');
 
-// --- Agent handoff contract (00-core.md) -----------------------------------
-const core = readSrc('rules', 'agent', '00-core.md');
-assert(/minimum characters, maximum information/i.test(flat(core)), '00-core: handoff must state token-optimized principle');
 assert(/fragments/i.test(core), '00-core: handoff must require fragments');
 assert(/file:line/i.test(core), '00-core: handoff must anchor evidence to file:line');
-assert(/Banned as pure cost/i.test(flat(core)), '00-core: handoff must list banned cost items');
 for (const banned of ['headings', 'tables', 'narration', 'raw logs', 'next-checks']) {
   assert(core.toLowerCase().includes(banned), `00-core: banned list missing ${banned}`);
 }
-const common = readSrc('rules', 'agent', '00-common.md');
 assert(/Public Agent Constraints/i.test(common), '00-common: must be titled public-only constraints');
-assert(/git operations deferred to Lead/i.test(common), '00-common: must refuse git/Ship');
+assert(/git operations deferred to Lead/i.test(normalize(common)), '00-common: must refuse git/Ship');
 assert(/Overflow goes to a file/i.test(common), '00-common: must keep overflow-to-file rule');
+requireAll(common, 'Public-agent shell', [
+  /shell only verifies own edits/, /no exploration, install, or state change beyond brief/,
+]);
 
 // --- Per-role output contracts --------------------------------------------
 const roles = {
@@ -59,19 +101,125 @@ const roles = {
   'reviewer/AGENT.md': readSrc('agents', 'reviewer', 'AGENT.md'),
   'debugger/AGENT.md': readSrc('agents', 'debugger', 'AGENT.md'),
 };
-for (const [name, text] of Object.entries(roles)) {
-  assert(/file:line/i.test(text), `${name}: role output must anchor to file:line`);
-  assert(/fragments|no report bloat|no prose|no narration|no preamble/i.test(flat(text)), `${name}: role output must forbid prose bloat`);
+
+// Semantic contracts deliberately avoid prose snapshots.
+function snapshot(actual, expected, label) {
+  assert(normalize(actual) === normalize(expected), `${label}: canonical snapshot changed`);
+}
+assert(/^agents:\s*$/m.test(frontmatter(solo, 'Solo workflow')), 'Solo: agents frontmatter must be empty');
+requireAll(workflow, 'Default approval', [
+  /read-only investigation\/planning while consulting/, /later explicit user message after the latest plan/,
+  /initial\/additional\/changed requests reset planning/, /scope change needs a revised plan and fresh approval/,
+  /no edits, state mutation, or delegation/,
+]);
+requireAll(workflow, 'Default routing', [
+  /delegate by default/, /only coordinates, does git, or an obvious 1-edit\/ 1-check change/,
+  /implementation\/research\/debugging to its matching agent/, /indicators, not automatic categories/,
+  /worker: bounded established path, low local risk\/coupling\/verification, clear local check/,
+  /heavy worker: high risk\/coupling\/verification \(including any high-risk scope\), or coupled staged work needing coordinated verification/,
+  /reviewer verifies an implementation/, /debugger handles requested debugging or root cause after a failed fix/,
+]);
+requireAll(workflow, 'Default lifecycle', [
+  /draft before any implementation/, /parallel gain exceeds coordination\/merge cost/,
+  /all in one turn, with no count cap/, /real dependency, overlapping write, or inseparable coupling/,
+  /after async spawn, end the turn/, /every delegated implementation gets one reviewer/,
+  /lead integration\/cross-scope verification in parallel/, /high-risk scopes add distinct lenses/,
+  /original live session/, /loop fix -> re-verify \(same reviewer \+ lead re-check\) until clean/,
+  /bug surviving 2\+ fix cycles/, /agent reports relay.*as in-progress, never conclusions/,
+  /final \(not interim\) report/, /never forward raw agent output/,
+  /explicit user request after issue-free feedback/, /outcome\/direction change, pause and re-consult/,
+]);
+requireAll(solo, 'Solo lifecycle', [
+  /no edits or state mutation/, /never spawn, send, delegate, or ask agents to work/,
+  /read-only investigation\/planning while consulting/,
+  /later explicit user message after the latest plan/,
+  /initial\/additional\/changed requests reset planning/,
+  /scope change needs a revised plan and fresh approval/,
+  /checks\/fixes directly until clean or reports a blocker/, /final \(not interim\) report/,
+  /interim updates are in-progress, never conclusions/,
+  /issue-free user feedback/,
+]);
+requireAll(bench, 'Bench lifecycle', [
+  /never wait for approval or ask questions/, /verified complete or provably blocked/,
+  /maximum independent scopes/, /spawning every scope in one turn/,
+  /build\/test-green gate/, /no polling, guessing, or dependent work/,
+  /one reviewer per implementation scope/, /never deferred\/batched/,
+  /fact-check agent responses and cross-check implementation\/review yourself before acting/,
+  /return fixes to the original scope/, /loop verify -> fix -> re-verify until clean/,
+  /skip only simple, low-risk review/, /hard blocked/, /outcome and evidence/,
+]);
+requireAll(leadTool, 'Lead tools', [
+  /write-role agents self-verify/, /cross-scope verification.*benches.*all git/,
+  /workflow permits delegation/, /no-delegation workflow.*controls/,
+]);
+requireAll(general, 'General safety', [
+  /identify as mixdog\/current coding agent/, /destructive\/hard-to-reverse action needs explicit confirmation/,
+  /never push, build, deploy without explicit user request/, /implementation approval is not deploy approval/,
+]);
+requireAll(skip, 'Silent skip', [
+  /webhook-handler/, /scheduler-task/, /label-only, duplicate\/dedup, no action needed\/report/,
+  /whole response.*\[meta:silent\]/,
+]);
+
+const roleSnapshots = {
+  'worker/AGENT.md': `# Worker
+Scoped implementation agent.
+
+Own only the bounded responsibility assigned in the brief. Trust its
+\`file:line\` anchors; do only minimal targeted discovery, then make the
+smallest coherent patch. No drive-by cleanup or scope expansion.
+
+EDIT-FIRST DISCIPLINE. Patch promptly rather than repeating read-only turns;
+stop and report blocked when the assigned scope cannot be completed.
+
+Self-verify with a targeted check (for example, \`node --check\` or a focused
+test), then report the changed \`file:line\` and stop.`,
+  'heavy-worker/AGENT.md': `# Heavy Worker
+Own the assigned implementation slice through staged delivery.
+
+Break work into bounded, dependency-aware slices and execute them in sequence.
+At each checkpoint, run the narrowest relevant test or build before expanding
+the slice. Keep the smallest coherent change; control blast radius rather than
+rewriting adjacent systems.
+
+EDIT-FIRST DISCIPLINE. Patch incrementally and stop at the first explicit
+boundary: unclear ownership, a missing dependency, or growing blast radius.
+Do not cross that boundary without a new bounded assignment; report blocked
+work with the relevant file:line.
+
+Self-verify each checkpoint and the final slice with shell (targeted test/build).`,
+  'reviewer/AGENT.md': `# Reviewer
+Independent regression/risk review agent.
+
+Review the approved intent, diff, and tests with independent judgment. Prioritize
+actionable correctness, regression, security, and verification risks; inspect
+affected boundaries. Do not reimplement the change or report non-risky nits.
+Report findings first, severity-ordered, with one line per \`file:line\`. If clean,
+say so in one line and include only material residual risk.`,
+  'debugger/AGENT.md': `# Debugger
+Root-cause analysis agent.
+
+Smallest confirmed cause chain before fixes. Return likely cause, evidence
+(\`file:line\`), smallest next check/fix. Mark confirmed facts vs inferences;
+avoid broad speculation.
+
+Converge, don't sweep: when new evidence stops accruing, report the best
+cause chain so far.`,
+};
+for (const [name, expected] of Object.entries(roleSnapshots)) {
+  const text = roles[name];
+  const permission = text.match(/^permission:\s*(.+)$/m)?.[1];
+  assert(permission === (name === 'worker/AGENT.md' || name === 'heavy-worker/AGENT.md' ? 'read-write' : 'read'), `${name}: permission contract changed`);
+  snapshot(roleBody(text, name), expected, name);
 }
-assert(/severity-ordered/i.test(flat(roles['reviewer/AGENT.md'])), 'reviewer: must keep severity-ordered findings');
-assert(/confirmed[\s\S]*inferences/i.test(roles['debugger/AGENT.md']), 'debugger: must separate confirmed facts vs inferences');
-assert(/Stop:|how-to-verify|how to verify/i.test(flat(roles['heavy-worker/AGENT.md'])), 'heavy-worker: must bound scope / state how to verify');
+assert(/confirmed facts vs inferences/i.test(normalize(roles['debugger/AGENT.md'])), 'debugger: must separate confirmed facts from inferences');
+assert(/file:line/i.test(normalize(roles['debugger/AGENT.md'])), 'debugger: must anchor evidence to file:line');
 
 // --- Injection: Lead rules actually carry the brief contract ---------------
 const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-internal-comms-smoke-'));
 try {
   const leadRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
-  assert(/minimum characters, maximum information/i.test(flat(leadRules)), 'injected Lead rules must carry the brief token principle');
+  assert(TOKEN_PRINCIPLE.test(normalize(leadRules)), 'injected Lead rules must carry the brief token principle');
   for (const field of BRIEF_FIELDS) assert(leadRules.includes(field), `injected Lead rules missing brief field ${field}`);
 } finally {
   rmSync(dataDir, { recursive: true, force: true });

package/scripts/live-worker-smoke.mjs

@@ -35,8 +35,44 @@ function taskId(text) {
 async function main() {
   const leadToolRules = readFileSync('src/rules/lead/lead-tool.md', 'utf8');
   const workflowRules = readFileSync('src/workflows/default/WORKFLOW.md', 'utf8');
-  assert(/Use `agent` for scoped implementation/i.test(leadToolRules), 'lead rules must direct scoped work to agents');
-  assert(/PARALLEL across independent scopes/i.test(workflowRules), 'workflow rules must keep independent work parallel');
+  const soloRules = readFileSync('src/workflows/solo/WORKFLOW.md', 'utf8');
+  const compact = (text) => text.toLowerCase().replace(/\s+/g, ' ');
+  const hasAll = (text, ...terms) => terms.every((term) => text.includes(term));
+  const lead = compact(leadToolRules);
+  const workflow = compact(workflowRules);
+  const solo = compact(soloRules);
+  const reviewSkipViolation = (text) => compact(text)
+    .split(/[.!?]\s+|;|,\s+(?=(?:but|however|yet)\b)/)
+    .some((clause) => {
+      const hasReview = /\b(review|reviewer|verification)\b/.test(clause);
+      const hasSkip = /\b(skip|skipping|skipped|omit|omits|omitting|omitted)\b/.test(clause) ||
+        /\bwithout\s+(?:any\s+)?(?:a\s+)?(?:review|reviewer|verification)\b/.test(clause);
+      const negated = /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\b(?:skip|skipping|skipped|omit|omitting|omitted)\b/.test(clause) ||
+        /\b(?:skip|skipping|skipped|omit|omitting|omitted)\b[^;]{0,40}\b(?:not allowed|forbidden|prohibited)\b/.test(clause) ||
+        /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\bwithout\s+(?:any\s+)?(?:a\s+)?(?:review|reviewer|verification)\b/.test(clause);
+      const exception = /\b(?:unless|except(?:\s+when)?|only\s+if)\b/.test(clause);
+      return hasReview && hasSkip && (!negated || exception);
+    });
+  for (const [phrase, expected] of [
+    ['Never skip Reviewer verification', false],
+    ['Reviewer verification must not be skipped', false],
+    ['Must not proceed without review', false],
+    ['Never skip risky review, but may skip simple review', true],
+    ['Never skip review unless low-risk', true],
+    ['Never skip review except when low-risk', true],
+    ['Never skip review only if low-risk', true],
+    ['May omit review', true],
+    ['Proceed without review', true],
+  ]) assert(reviewSkipViolation(phrase) === expected, `review-skip detector case failed: ${phrase}`);
+  const skipsReview = reviewSkipViolation(workflow);
+  assert(hasAll(lead, 'workflow permits delegation', 'use `agent`', 'implementation', 'research', 'review', 'debugging'), 'lead rules must conditionally direct scoped work to agents');
+  assert(hasAll(workflow, 'after approval', 'delegate', 'by default'), 'default workflow must delegate after approval');
+  assert(hasAll(workflow, 'coordinates', 'git', '1-edit', '1-check'), 'default workflow must limit Lead direct work');
+  assert(hasAll(workflow, 'implementation/research/debugging', 'matching agent'), 'default workflow must route other work to matching agents');
+  assert(hasAll(workflow, 'parallel', 'independent', 'every delegated implementation'), 'workflow rules must keep independent work parallel');
+  assert(hasAll(workflow, 'every delegated implementation', 'reviewer', 'lead integration', 'fix', 're-verify'), 'default workflow must require review and the fix loop');
+  assert(!skipsReview, 'default workflow must not permit delegated-review skips');
+  assert(hasAll(solo, 'never spawn', 'send', 'delegate', 'ask agents'), 'Solo workflow must forbid delegation');
   assert(/always start background tasks/i.test(AGENT_TOOL.description || '') && /distinct tags?/i.test(AGENT_TOOL.description || '') && /completion notification/i.test(AGENT_TOOL.description || ''), 'agent tool description must expose async parallel tags');
 
   mkdirSync(dataDir, { recursive: true });