mixdog 0.9.0 → 0.9.2

package/scripts/internal-comms-smoke.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// Static smoke for internal-comms token-optimization rules (min chars / max
+// info). Asserts the Lead brief contract and the agent handoff contract are
+// present and injected, without any model call. Live token A/B is a separate
+// bench (scripts/internal-comms-bench.mjs).
+import { createRequire } from 'node:module';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+const rulesBuilder = require('../src/lib/rules-builder.cjs');
+
+function assert(condition, message) {
+  if (!condition) throw new Error(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, ' ');
+}
+
+// --- Lead brief contract: canonical in lead-tool.md, referenced from WORKFLOW -
+const workflow = readSrc('workflows', 'default', 'WORKFLOW.md');
+const leadTool = readSrc('rules', 'lead', 'lead-tool.md');
+const BRIEF_FIELDS = ['Goal:', 'Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
+// Canonical brief contract lives in lead-tool.md (Lead tool-use rules).
+assert(/minimum characters, maximum information/i.test(flat(leadTool)), 'lead-tool.md: brief must state min-char/max-info principle');
+for (const field of BRIEF_FIELDS) assert(leadTool.includes(field), `lead-tool.md: brief missing labeled field ${field}`);
+assert(leadTool.includes('Stop:'), 'lead-tool.md: brief must add Stop: for heavy-worker bound');
+assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(flat(leadTool)), 'lead-tool.md: brief must ban restating known rules/background as cost');
+// WORKFLOW.md must not duplicate the field list; it defers to the lead-tool contract.
+assert(/lead-tool brief contract/i.test(flat(workflow)), 'WORKFLOW.md: must defer to the lead-tool brief contract');
+assert(!BRIEF_FIELDS.every((field) => workflow.includes(field)), 'WORKFLOW.md: must not duplicate the full brief field list');
+
+// --- Agent handoff contract (00-common.md) ---------------------------------
+const common = readSrc('rules', 'agent', '00-common.md');
+assert(/minimum characters, maximum information/i.test(flat(common)), '00-common: handoff must state token-optimized principle');
+assert(/fragments/i.test(common), '00-common: handoff must require fragments');
+assert(/file:line/i.test(common), '00-common: handoff must anchor evidence to file:line');
+assert(/Banned as pure cost/i.test(flat(common)), '00-common: handoff must list banned cost items');
+for (const banned of ['headings', 'tables', 'narration', 'raw logs', 'next-checks']) {
+  assert(common.toLowerCase().includes(banned), `00-common: banned list missing ${banned}`);
+}
+
+// --- Per-role output contracts --------------------------------------------
+const roles = {
+  'worker/AGENT.md': readSrc('agents', 'worker', 'AGENT.md'),
+  'heavy-worker/AGENT.md': readSrc('agents', 'heavy-worker', 'AGENT.md'),
+  '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`);
+}
+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');
+
+// --- 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');
+  for (const field of BRIEF_FIELDS) assert(leadRules.includes(field), `injected Lead rules missing brief field ${field}`);
+} finally {
+  rmSync(dataDir, { recursive: true, force: true });
+}
+
+process.stdout.write('internal comms smoke passed\n');

package/scripts/lead-workflow-smoke.mjs

@@ -315,7 +315,7 @@ function agentSummary(call) {
     id: call?.id || call?.callId || null,
     name: call?.name || call?.toolName || 'tool',
     type: input?.type || input?.action || null,
-    role: input?.role || null,
+    agent: input?.agent || null,
     tag: input?.tag || null,
     mode: input?.mode || null,
     wait: input?.wait ?? null,
@@ -491,15 +491,15 @@ async function runScenario(name) {
     .filter(Number.isFinite);
   const firstMutationIter = mutationIters.length ? Math.min(...mutationIters) : null;
   const implementationSpawnCalls = spawnCalls.filter((call) => {
-    const role = String(call.role || '').toLowerCase();
+    const agent = String(call.agent || '').toLowerCase();
     const tag = String(call.tag || '').toLowerCase();
-    if (!['worker', 'heavy-worker', 'debugger'].includes(role)) return false;
+    if (!['worker', 'heavy-worker', 'debugger'].includes(agent)) return false;
     return !/(verify|smoke|review|policy)/.test(tag);
   });
   const preEditImplementationSpawns = firstMutationIter == null
     ? implementationSpawnCalls.length
     : implementationSpawnCalls.filter((call) => Number(call.iter) < firstMutationIter).length;
-  const distinctRoles = [...new Set(agentCalls.map((call) => call.role).filter(Boolean))];
+  const distinctRoles = [...new Set(agentCalls.map((call) => call.agent).filter(Boolean))];
   const distinctTags = [...new Set(agentCalls.map((call) => call.tag).filter(Boolean))];
   const firstAgentIter = Math.min(...agentCalls.map((call) => Number(call.iter)).filter(Number.isFinite));
   const firstIterAgentCount = Number.isFinite(firstAgentIter)

package/scripts/live-worker-smoke.mjs

@@ -36,7 +36,7 @@ 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(/delegat(?:es|ing) them concurrently/i.test(workflowRules), 'workflow rules must keep independent work parallel');
+  assert(/PARALLEL across independent scopes/i.test(workflowRules), 'workflow rules must keep independent work parallel');
   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 });
@@ -107,7 +107,7 @@ async function main() {
       if (/debug/i.test(prompt)) {
         return { content: `debugger ${readFileSync(join(cwdOverride, 'notes.txt'), 'utf8').trim()}` };
       }
-      return { content: `ack ${session?.role || 'worker'}` };
+      return { content: `ack ${session?.agent || 'worker'}` };
     } finally {
       activeAsks -= 1;
       if (session) {
@@ -152,7 +152,7 @@ async function main() {
 
   const spawnOut = await agentRunner.execute({
     type: 'spawn',
-    role: 'worker',
+    agent: 'worker',
     tag: 'impl1',
     cwd: root,
     prompt: 'write implementation: update feature.txt with apply_patch',
@@ -169,14 +169,14 @@ async function main() {
 
   const reviewOut = await agentRunner.execute({
     type: 'spawn',
-    role: 'reviewer',
+    agent: 'reviewer',
     tag: 'rev1',
     cwd: root,
     prompt: 'review feature.txt for the worker change',
   }, { invocationSource: 'model-tool', cwd: root });
   const debugOut = await agentRunner.execute({
     type: 'spawn',
-    role: 'debugger',
+    agent: 'debugger',
     tag: 'dbg1',
     cwd: root,
     prompt: 'debug notes.txt timeout clue',
@@ -187,21 +187,21 @@ async function main() {
   const parallelSpawns = await Promise.all([
     agentRunner.execute({
       type: 'spawn',
-      role: 'worker',
+      agent: 'worker',
       tag: 'parWorker',
       cwd: root,
       prompt: 'parallel slow worker task',
     }, { invocationSource: 'model-tool', cwd: root }),
     agentRunner.execute({
       type: 'spawn',
-      role: 'reviewer',
+      agent: 'reviewer',
       tag: 'parReviewer',
       cwd: root,
       prompt: 'parallel slow review task',
     }, { invocationSource: 'model-tool', cwd: root }),
     agentRunner.execute({
       type: 'spawn',
-      role: 'debugger',
+      agent: 'debugger',
       tag: 'parDebugger',
       cwd: root,
       prompt: 'parallel slow debug task',
@@ -217,7 +217,7 @@ async function main() {
 
   const busyOut = await agentRunner.execute({
     type: 'spawn',
-    role: 'worker',
+    agent: 'worker',
     tag: 'busy1',
     cwd: root,
     prompt: 'long busy worker task',

package/scripts/output-style-bench.mjs

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+// Lead output-style verbosity bench (default >= simple >= minimal >= oneline).
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dir, '..');
+const PLUGIN_ROOT = join(REPO_ROOT, 'src');
+const STYLES = ['default', 'simple', 'minimal', 'oneline'];
+const DEFAULT_PROMPT =
+  'Reply in plain English only. What is 2+2? Give a short summary suitable for a status report (no tools, no file reads).';
+const MODEL_ALIASES = {
+  opus: { provider: 'anthropic-oauth', model: 'claude-opus-4-8' },
+  sonnet: { provider: 'anthropic-oauth', model: 'claude-sonnet-5' },
+  gpt: { provider: 'openai-oauth', model: 'gpt-5.5' },
+  'gpt-5.5': { provider: 'openai-oauth', model: 'gpt-5.5' },
+  grok: { provider: 'grok-oauth', model: 'grok-composer-2.5-fast' },
+};
+// Filenames verified in provider ensureAuth / token paths (resolvePluginData / getPluginData).
+const AUTH_ARTIFACT_BY_PROVIDER = {
+  'grok-oauth': ['grok-oauth.json', 'grok-oauth-models.json'],
+  'anthropic-oauth': ['anthropic-oauth-credentials.json', 'anthropic-oauth-models.json'],
+  'openai-oauth': ['openai-oauth.json', 'openai-oauth-models.json'],
+};
+
+function argValue(name, fallback = null) {
+  const idx = process.argv.indexOf(name);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  const pref = `${name}=`;
+  const hit = process.argv.find((a) => a.startsWith(pref));
+  return hit ? hit.slice(pref.length) : fallback;
+}
+function hasFlag(name) { return process.argv.includes(name); }
+function resolveModelOpts(modelArg, providerArg) {
+  const key = String(modelArg || '').trim().toLowerCase();
+  if (MODEL_ALIASES[key] && !providerArg) return { ...MODEL_ALIASES[key] };
+  return { provider: providerArg || null, model: modelArg || null };
+}
+function defaultUserDataDir() {
+  return process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data');
+}
+function readUnifiedConfig(dataDir) {
+  try {
+    const unified = JSON.parse(readFileSync(join(dataDir, 'mixdog-config.json'), 'utf8'));
+    return unified && typeof unified === 'object' ? unified : {};
+  } catch { return {}; }
+}
+function outputStyleBodyFromMeta(meta) {
+  const marker = '# Output Style';
+  const idx = String(meta || '').lastIndexOf(marker);
+  return idx < 0 ? '' : String(meta).slice(idx).trim();
+}
+function measureOutputText(text) {
+  const trimmed = String(text || '').trim();
+  const lines = trimmed ? trimmed.split(/\r?\n/) : [];
+  const bullets = lines.filter((l) => /^\s*[-*•]\s+/.test(l)).length;
+  const withoutCode = trimmed.replace(/`[^`]*`/g, '');
+  const sentenceMarks = withoutCode.match(/[.!?。！？]+(?=\s|$)/g) || [];
+  return {
+    chars: trimmed.length,
+    lines: lines.length,
+    bullets,
+    sentences: sentenceMarks.length || (trimmed ? 1 : 0),
+    text: trimmed,
+  };
+}
+function runInjectionScaffold() {
+  const rulesBuilder = createRequire(import.meta.url)(join(PLUGIN_ROOT, 'lib', 'rules-builder.cjs'));
+  const baseDir = mkdtempSync(join(REPO_ROOT, '.tmp-output-style-bench-'));
+  const templatePath = join(PLUGIN_ROOT, 'defaults', 'mixdog-config.template.json');
+  const baseConfig = existsSync(templatePath)
+    ? JSON.parse(readFileSync(templatePath, 'utf8'))
+    : { outputStyle: 'default' };
+  const markers = {
+    default: 'most detailed of the three',
+    simple: 'Practical concise',
+    minimal: 'a very short summary',
+    oneline: 'exactly one sentence',
+  };
+  const snippets = {};
+  try {
+    for (const styleId of STYLES) {
+      const dataDir = join(baseDir, styleId);
+      mkdirSync(dataDir, { recursive: true });
+      writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({ ...baseConfig, outputStyle: styleId }, null, 2));
+      snippets[styleId] = outputStyleBodyFromMeta(rulesBuilder.buildLeadMetaContent({ PLUGIN_ROOT, DATA_DIR: dataDir }));
+      if (!snippets[styleId].includes(markers[styleId])) throw new Error(`${styleId} injection marker missing`);
+    }
+    if (new Set(STYLES.map((id) => snippets[id])).size !== STYLES.length) throw new Error('injection bodies not distinct');
+    return { snippets };
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+}
+function authArtifactNamesForSandbox(realDataDir, provider) {
+  const names = new Set();
+  for (const file of AUTH_ARTIFACT_BY_PROVIDER[provider] || []) names.add(file);
+  try {
+    for (const entry of readdirSync(realDataDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+      if (/oauth/i.test(entry.name) || /credentials/i.test(entry.name)) names.add(entry.name);
+    }
+  } catch { /* missing real data dir */ }
+  return [...names];
+}
+function copyAuthArtifacts(realDataDir, sandboxDataDir, provider) {
+  const copied = [];
+  const skipped = [];
+  for (const name of authArtifactNamesForSandbox(realDataDir, provider)) {
+    const src = join(realDataDir, name);
+    const dest = join(sandboxDataDir, name);
+    if (!existsSync(src)) {
+      skipped.push(name);
+      continue;
+    }
+    try {
+      copyFileSync(src, dest);
+      copied.push(name);
+    } catch {
+      skipped.push(name);
+    }
+  }
+  return { copied, skipped };
+}
+function prepareStyleSandbox(baseSandbox, styleId, userUnified, realDataDir, provider) {
+  const dataDir = join(baseSandbox, styleId);
+  mkdirSync(dataDir, { recursive: true });
+  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({ ...userUnified, outputStyle: styleId }, null, 2));
+  copyAuthArtifacts(realDataDir, dataDir, provider);
+  return dataDir;
+}
+function findPresetRoute(config, key) {
+  const wanted = String(key || '').trim().toLowerCase();
+  if (!wanted) return null;
+  const presets = Array.isArray(config?.presets) ? config.presets : [];
+  return presets.find((p) => {
+    const id = String(p?.id || '').trim().toLowerCase();
+    const name = String(p?.name || '').trim().toLowerCase();
+    return id === wanted || name === wanted;
+  }) || null;
+}
+function resolveLeadProviderModel(userUnified, cli) {
+  if (cli.provider && cli.model) return { provider: cli.provider, model: cli.model };
+  const leadPreset = findPresetRoute(userUnified, 'workflow-lead')
+    || findPresetRoute(userUnified, userUnified.default)
+    || findPresetRoute(userUnified, 'gpt-5.5');
+  if (leadPreset?.provider && leadPreset?.model) return { provider: leadPreset.provider, model: leadPreset.model };
+  const alias = MODEL_ALIASES.gpt;
+  return { provider: cli.provider || alias.provider, model: cli.model || alias.model };
+}
+function runLiveLeadTurn({ dataDir, prompt, provider, model, cwd, 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: 'output-style-bench',`,
+    `  cwd: ${JSON.stringify(cwd)}, 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(cwd)}); }`,
+    `finally { try { closeSession(session.id, 'output-style-bench'); } catch {} }`,
+    `process.stdout.write(JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId: session.id }));`,
+  ].filter(Boolean).join('\n');
+  const raw = execFileSync('node', ['--input-type=module', '-e', driver], {
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+    env: { ...process.env, MIXDOG_ROOT: PLUGIN_ROOT, MIXDOG_DATA_DIR: dataDir },
+  });
+  const jsonStart = raw.lastIndexOf('{');
+  if (jsonStart < 0) throw new Error(`live driver failed: ${raw.slice(0, 400)}`);
+  return JSON.parse(raw.slice(jsonStart));
+}
+function styleCharCountsFromResults(results) {
+  return Object.fromEntries(
+    STYLES.map((id) => [id, results.find((r) => r.style === id)?.metrics.chars ?? 0]),
+  );
+}
+function evaluateVerbosityOrdering(results) {
+  const counts = STYLES.map((id) => results.find((r) => r.style === id)?.metrics.chars ?? 0);
+  let orderingOk = true;
+  for (let i = 1; i < counts.length; i += 1) {
+    if (counts[i - 1] < counts[i]) orderingOk = false;
+  }
+  const chain = STYLES.map((id, i) => `${id}=${counts[i]}`).join(' ');
+  const passLabel = STYLES.map((id) => `chars(${id})`).join(' >= ');
+  const verdict = orderingOk
+    ? `PASS ${passLabel}`
+    : `WARN ordering violated: ${chain}`;
+  return { orderingOk, verdict, counts: styleCharCountsFromResults(results) };
+}
+function printUsage() {
+  process.stdout.write(`output-style-bench — Lead verbosity ladder (default >= simple >= minimal >= oneline).
+
+Output style is Lead-only (buildLeadMetaContent when owner is not agent).
+runHeadlessRole worker paths (owner=agent) do NOT inject outputStyle.
+
+Usage:
+  node scripts/output-style-bench.mjs [--json]
+  node scripts/output-style-bench.mjs --run [--model gpt] [--provider P] [--effort E] [--fast] [--prompt "..."] [--json]
+
+--run required for live calls. Temp MIXDOG_DATA_DIR: outputStyle override + read-only copy of OAuth/credential JSON from your real data dir.
+`);
+}
+function main() {
+  const jsonMode = hasFlag('--json');
+  const doRun = hasFlag('--run');
+  const prompt = argValue('--prompt', DEFAULT_PROMPT);
+  const cli = resolveModelOpts(argValue('--model', null), argValue('--provider', null));
+  const effort = argValue('--effort', null);
+  const fast = hasFlag('--fast');
+  const cwd = process.cwd();
+  let scaffold;
+  try { scaffold = runInjectionScaffold(); }
+  catch (e) { process.stderr.write(`[output-style-bench] scaffold FAILED: ${e.message}\n`); process.exit(1); }
+  if (!doRun) {
+    printUsage();
+    const charCounts = Object.fromEntries(STYLES.map((id) => [id, scaffold.snippets[id].length]));
+    if (jsonMode) {
+      console.log(JSON.stringify({ mode: 'scaffold', role: 'lead', owner: 'cli', charCounts, liveCommand: 'node scripts/output-style-bench.mjs --run --model gpt' }, null, 2));
+    } else {
+      process.stdout.write(`[output-style-bench] scaffold ok: ${STYLES.map((id) => `${id}=${charCounts[id]}`).join(', ')}\n`);
+    }
+    process.exit(0);
+  }
+  const realDataDir = defaultUserDataDir();
+  const userUnified = readUnifiedConfig(realDataDir);
+  const route = resolveLeadProviderModel(userUnified, cli);
+  const baseSandbox = mkdtempSync(join(REPO_ROOT, '.tmp-output-style-bench-live-'));
+  const results = [];
+  try {
+    for (const styleId of STYLES) {
+      const dataDir = prepareStyleSandbox(baseSandbox, styleId, userUnified, realDataDir, route.provider);
+      process.stderr.write(`[output-style-bench] style=${styleId} ${route.provider}/${route.model}\n`);
+      try {
+        const live = runLiveLeadTurn({ dataDir, prompt, ...route, cwd, effort, fast });
+        const metrics = measureOutputText(live.text);
+        results.push({ style: styleId, ok: true, sessionId: live.sessionId, metrics, raw: metrics.text });
+      } catch (err) {
+        results.push({
+          style: styleId,
+          ok: false,
+          error: String(err.stdout || err.stderr || err.message).slice(0, 2000),
+          metrics: measureOutputText(''),
+        });
+      }
+    }
+  } finally {
+    rmSync(baseSandbox, { recursive: true, force: true });
+  }
+  const { orderingOk, verdict } = evaluateVerbosityOrdering(results);
+  if (jsonMode) {
+    console.log(JSON.stringify({ mode: 'live', role: 'lead', prompt, route, results, verdict, orderingOk }, null, 2));
+  } else {
+    console.log(`live role=lead ${route.provider}/${route.model}`);
+    for (const r of results) {
+      const m = r.metrics;
+      console.log(`- ${r.style}: ${r.ok ? 'ok' : 'FAIL'} chars=${m.chars} lines=${m.lines} bullets=${m.bullets} sentences=${m.sentences}`);
+      if (r.ok) console.log(`  ${m.text}`);
+      else console.log(`  error: ${String(r.error || '').slice(0, 300)}`);
+    }
+    console.log(verdict);
+  }
+  process.exit(results.every((r) => r.ok) ? 0 : 1);
+}
+main();

package/scripts/output-style-smoke.mjs

@@ -49,7 +49,8 @@ const defaultStyle = readFileSync(join(root, 'src', 'output-styles', 'default.md
 for (const required of [
   'name: default',
   'Concise engineering summaries',
-  'Mixdog default — concise engineering summaries',
+  'Mixdog default — the most detailed of the three styles',
+  'match length to the work',
   'Use labels such as',
   '`바뀐 점`, `확인한 것`,',
   'Synthesize agent or retrieval results',
@@ -60,7 +61,7 @@ for (const required of [
 assert(!defaultStyle.includes('Claude Code-compact'), 'default.md must not reference the old compact style name');
 assert(!defaultStyle.includes('Hard cap user-visible replies'), 'default.md must not hard-cap replies to two short sentences');
 assert(!defaultStyle.includes('Be short and direct.'), 'default.md must not keep the old generic concise preset');
-assert(!defaultStyle.includes('Practical concise — outcome-first'), 'default.md must not use the simple preset body');
+assert(!defaultStyle.includes('Practical concise — outcome-first handoffs'), 'default.md must not use the simple preset body');
 
 const simpleStyle = readFileSync(join(root, 'src', 'output-styles', 'simple.md'), 'utf8');
 for (const required of [
@@ -75,11 +76,12 @@ for (const required of [
 ]) {
   assert(simpleStyle.includes(required), `simple.md missing: ${required}`);
 }
-assert(!simpleStyle.includes('Mixdog default — concise engineering summaries'), 'simple.md must not duplicate default preset body');
+assert(!simpleStyle.includes('Mixdog default — the most detailed of the three styles'), 'simple.md must not duplicate default preset body');
 for (const [name, style] of Object.entries({
   default: defaultStyle,
   simple: simpleStyle,
-  extreme: readFileSync(join(root, 'src', 'output-styles', 'extreme-simple.md'), 'utf8'),
+  minimal: readFileSync(join(root, 'src', 'output-styles', 'minimal.md'), 'utf8'),
+  oneline: readFileSync(join(root, 'src', 'output-styles', 'oneline.md'), 'utf8'),
 })) {
   assert(!style.includes('pre-tool preamble'), `${name} output style must not own language preamble rules`);
   assert(!style.includes('selected/default user language'), `${name} output style must not duplicate profile language rules`);
@@ -101,7 +103,7 @@ try {
   writeFileSync(join(dataDir, 'output-styles', 'custom-smoke.md'), '---\nname: custom-smoke\n---\n\n# Custom Output Style\n\ncustom smoke style\n');
   const customRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
   assert(customRules.includes('# Custom Output Style'), 'configured outputStyle must select custom style');
-  assert(!customRules.includes('Mixdog default — concise engineering summaries'), 'custom outputStyle should not append default style');
+  assert(!customRules.includes('Mixdog default — the most detailed of the three styles'), 'custom outputStyle should not append default style');
   const profileMeta = rulesBuilder.buildLeadMetaContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
   assert(profileMeta.includes('Use "재영님" when directly addressing the user'), 'profile title must inject into Lead BP3 meta');
   assert(profileMeta.includes('Do not repeat it in routine progress updates or pre-tool preambles'), 'profile title must not encourage title in preambles');
@@ -111,12 +113,13 @@ try {
   rmSync(dataDir, { recursive: true, force: true });
 }
 
+// assertCleanOutput encodes the Simple style compact contract (not Default, which may be longer).
 const goodOutputs = {
-  explanation: '기본 출력은 결과 한 줄과 근거 한 가지로 끝내고, 최종 보고만 짧은 bullet 라벨을 씁니다.',
-  implementation: '- 바뀐 점: `src/output-styles/default.md`에 이전 simple 프리셋을 반영했습니다.\n- 확인한 것: `node scripts/output-style-smoke.mjs`를 실행했습니다.',
-  crowded: '- 바뀐 점: default는 요약 라벨 보고, simple은 handoff용 controlled detail을 씁니다.\n- 확인한 것: smoke 예시가 compact guardrail을 유지합니다.',
-  blocker: '`src/output-styles/default.md`를 찾을 수 없어 변경이 막혔습니다.',
-  semicolon: '`default.md`를 갱신했고; 출력 스모크가 예시 응답 모양을 검증합니다.',
+  explanation: 'Simple 스타일은 결과 한 줄과 근거 한 가지로 끝내고, 최종 handoff만 짧은 bullet 라벨을 씁니다.',
+  implementation: '- 바뀐 점: `scripts/output-style-smoke.mjs`의 default/simple 문자열 검증을 현재 프리셋에 맞췄습니다.\n- 확인한 것: `node scripts/output-style-smoke.mjs`를 실행했습니다.',
+  crowded: '- 바뀐 점: compact guardrail은 Simple handoff용 controlled detail을 검증합니다.\n- 확인한 것: bad 샘플 거부 규칙은 그대로입니다.',
+  blocker: '`scripts/output-style-smoke.mjs`를 찾을 수 없어 변경이 막혔습니다.',
+  semicolon: '스모크 스크립트를 갱신했고; Simple 계약에 맞는 예시 응답만 통과합니다.',
 };
 for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output, { allowedLabels: DEFAULT_REPORT_LABELS });
 

package/scripts/patch-replay.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// patch-replay.mjs — re-run captured apply_patch FAILURES against current code.
+// Failures frozen by patch.mjs (MIXDOG_PATCH_REPLAY_CAPTURE=1) into
+// <data>/history/patch-replays/*.json with original args + target file snapshots.
+// Replays into a throwaway temp copy (never touches the repo) and reports pass/fail.
+//   node scripts/patch-replay.mjs --list
+//   node scripts/patch-replay.mjs --replay <id>
+//   node scripts/patch-replay.mjs --replay-all [--json]
+import { existsSync, readFileSync, readdirSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+
+function argValue(name, fallback = null) {
+  const idx = process.argv.indexOf(name);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  const pref = `${name}=`;
+  const hit = process.argv.find((a) => a.startsWith(pref));
+  return hit ? hit.slice(pref.length) : fallback;
+}
+function hasFlag(name) { return process.argv.includes(name); }
+
+function replayDir() {
+  if (process.env.MIXDOG_PATCH_REPLAY_DIR) return resolve(process.env.MIXDOG_PATCH_REPLAY_DIR);
+  const data = process.env.MIXDOG_DATA_DIR || resolve(homedir(), '.mixdog', 'data');
+  return resolve(data, 'history', 'patch-replays');
+}
+
+function loadRecords() {
+  const dir = replayDir();
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith('.json')).map((f) => {
+    try { return { file: join(dir, f), ...JSON.parse(readFileSync(join(dir, f), 'utf8')) }; }
+    catch { return null; }
+  }).filter(Boolean).sort((a, b) => Number(b.ts || 0) - Number(a.ts || 0));
+}
+
+function isErr(text) { return /^Error[\s:[]/.test(String(text || '').trimStart()); }
+
+async function replayOne(rec) {
+  const tmp = mkdtempSync(join(tmpdir(), 'mixdog-patch-replay-'));
+  try {
+    for (const [rel, content] of Object.entries(rec.file_snapshots || {})) {
+      if (content == null) continue;
+      const abs = join(tmp, rel);
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, content);
+    }
+    const args = { ...(rec.args || {}), base_path: tmp };
+    let result;
+    try { result = await executePatchTool('apply_patch', args, tmp, {}); }
+    catch (e) { result = `Error: ${e?.message || String(e)}`; }
+    return { id: rec.id, ok: !isErr(result), before: rec.error_first_line, after: String(result).split('\n')[0].slice(0, 200) };
+  } finally {
+    try { rmSync(tmp, { recursive: true, force: true }); } catch {}
+  }
+}
+
+const jsonMode = hasFlag('--json');
+const records = loadRecords();
+
+if (hasFlag('--list') || (!hasFlag('--replay-all') && !argValue('--replay'))) {
+  if (jsonMode) { console.log(JSON.stringify(records.map(({ file_snapshots, args, ...m }) => m), null, 2)); process.exit(0); }
+  console.log(`captured apply_patch failures: ${records.length}  (dir: ${replayDir()})`);
+  for (const r of records.slice(0, 50)) {
+    console.log(`- ${r.id}  targets=${(r.targets || []).length}  ${new Date(r.ts).toISOString()}`);
+    console.log(`    ${String(r.error_first_line || '').slice(0, 140)}`);
+  }
+  if (!records.length) console.log('(none - set MIXDOG_PATCH_REPLAY_CAPTURE=1 to capture)');
+  process.exit(0);
+}
+
+const one = argValue('--replay', null);
+const targets = one ? records.filter((r) => r.id === one || r.id.startsWith(one)) : records;
+if (!targets.length) { console.error(one ? `no replay matched: ${one}` : 'no captured failures'); process.exit(1); }
+
+const results = [];
+for (const rec of targets) results.push(await replayOne(rec));
+const passed = results.filter((r) => r.ok).length;
+
+if (jsonMode) {
+  console.log(JSON.stringify({ total: results.length, passed, failed: results.length - passed, results }, null, 2));
+} else {
+  console.log(`patch-replay: ${passed}/${results.length} now succeed`);
+  for (const r of results) {
+    console.log(`- ${r.id}: ${r.ok ? 'PASS' : 'still fails'}`);
+    if (!r.ok) console.log(`    after: ${r.after}`);
+  }
+}
+process.exitCode = passed === results.length ? 0 : 1;