mixdog 0.9.62 → 0.9.64

package/scripts/openai-ws-early-settle-test.mjs

@@ -1,216 +0,0 @@
-// Regression: OpenAI OAuth WS early tool-call settle.
-//
-// A tool-call response can be fully formed (function_call_arguments.done +
-// output_item.done) yet the server never emits the terminal
-// response.completed/response.done frame. Before the fix _streamResponse
-// coasted on that silence until a stall error (gated out of the loop via
-// pendingToolUse) or the 30-min agent watchdog, and -- because the socket was
-// still pooled -- the missing terminal frame later leaked onto the NEXT request
-// as orphan bytes (http_status=0 wedge). The fix resolves early with the
-// captured tool call and flags `closeSocket` so the pool discards the socket.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { EventEmitter } from 'node:events';
-import { _streamResponse } from '../src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs';
-import { classifyMidstreamError, MIDSTREAM_RETRY_POLICY } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
-
-// Minimal fake WS: matches the .on/.off/.close/.ping surface _streamResponse
-// uses. close() is a no-op here -- the early-settle path sets done=true before
-// calling it, so the real closeHandler would short-circuit anyway.
-class FakeSocket extends EventEmitter {
-    constructor() {
-        super();
-        this.readyState = 1;
-        this.closed = null;
-    }
-    close(code, reason) { this.closed = { code, reason }; }
-    ping() {}
-    feed(events) { for (const e of events) this.emit('message', JSON.stringify(e)); }
-}
-
-const FAST_TIMEOUTS = { interChunkMs: 40, preResponseCreatedMs: 5000, firstMeaningfulMs: 5000 };
-
-const TOOL_CALL_EVENTS = [
-    { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
-    { type: 'response.output_item.added', item: { type: 'function_call', id: 'fc_1', name: 'explore', call_id: 'call_1' } },
-    { type: 'response.function_call_arguments.delta', item_id: 'fc_1', delta: '{"query"' },
-    { type: 'response.function_call_arguments.done', item_id: 'fc_1', arguments: '{"query":"x"}', call_id: 'call_1', name: 'explore' },
-    { type: 'response.output_item.done', item: { type: 'function_call', id: 'fc_1', name: 'explore', call_id: 'call_1', arguments: '{"query":"x"}' } },
-];
-
-test('ws early settle: complete tool call resolves without response.completed and flags closeSocket', async () => {
-    const socket = new FakeSocket();
-    const state = {};
-    const emitted = [];
-    const p = _streamResponse({
-        entry: { socket },
-        state,
-        onToolCall: (c) => emitted.push(c),
-        _timeouts: FAST_TIMEOUTS,
-    });
-    socket.feed(TOOL_CALL_EVENTS);
-    const result = await p;
-    assert.equal(result.closeSocket, true, 'socket must be dropped, not pooled');
-    assert.ok(Array.isArray(result.toolCalls) && result.toolCalls.length === 1);
-    assert.equal(result.toolCalls[0].id, 'call_1');
-    assert.equal(result.toolCalls[0].name, 'explore');
-    assert.deepEqual(result.toolCalls[0].arguments, { query: 'x' });
-    assert.equal(emitted.length, 1, 'tool call dispatched exactly once');
-    assert.equal(state.wsEarlySettle, 'inter_chunk');
-    assert.ok(socket.closed, 'socket.close() invoked so it is never reused');
-});
-
-test('ws early settle: normal response.completed path keeps the socket (no closeSocket)', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
-    socket.feed([
-        ...TOOL_CALL_EVENTS,
-        {
-            type: 'response.completed',
-            response: {
-                id: 'resp_1',
-                model: 'gpt-5.5',
-                output: [{ type: 'function_call', id: 'fc_1', name: 'explore', call_id: 'call_1', arguments: '{"query":"x"}' }],
-            },
-        },
-    ]);
-    const result = await p;
-    assert.equal(result.closeSocket, undefined, 'normal completion must not mark closeSocket');
-    assert.equal(result.toolCalls.length, 1);
-});
-
-test('ws early settle: deferred salvage still pending does NOT early-settle (fails as stall)', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
-    // No output_item.added -> pendingCalls empty; args.done carries no call_id/name
-    // -> a deferred placeholder that only response.completed could salvage.
-    socket.feed([
-        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
-        { type: 'response.function_call_arguments.delta', item_id: 'fc_1', delta: '{"query"' },
-        { type: 'response.function_call_arguments.done', item_id: 'fc_1', arguments: '{"query":"x"}' },
-    ]);
-    await assert.rejects(p, /inter-chunk inactivity/);
-});
-
-test('ws early settle: complete tool then partial second tool does NOT early-settle', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
-    socket.feed([
-        ...TOOL_CALL_EVENTS,
-        { type: 'response.output_item.added', item: { type: 'function_call', id: 'fc_2', name: 'grep', call_id: 'call_2' } },
-        { type: 'response.function_call_arguments.delta', item_id: 'fc_2', delta: '{"pattern"' },
-    ]);
-    await assert.rejects(p, /inter-chunk inactivity/);
-    assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'partial second tool must use stall path, not early settle');
-});
-
-test('ws early settle: complete tool_search_call clears in-flight and can early-settle', async () => {
-    const socket = new FakeSocket();
-    const state = {};
-    const p = _streamResponse({ entry: { socket }, state, _timeouts: FAST_TIMEOUTS });
-    socket.feed([
-        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
-        { type: 'response.output_item.added', item: { type: 'tool_search_call', id: 'ts_1' } },
-        { type: 'response.output_item.done', item: { type: 'tool_search_call', id: 'ts_1', arguments: '{"query":"fetch"}' } },
-    ]);
-    const result = await p;
-    assert.equal(result.closeSocket, true);
-    assert.equal(result.toolCalls[0].id, 'ts_1');
-    assert.equal(result.toolCalls[0].name, 'load_tool');
-    assert.deepEqual(result.toolCalls[0].arguments, { query: 'fetch' });
-    assert.equal(state.wsEarlySettle, 'inter_chunk');
-});
-
-test('ws early settle: complete tool_search_call plus partial custom tool does NOT early-settle', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
-    socket.feed([
-        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
-        { type: 'response.output_item.added', item: { type: 'tool_search_call', id: 'ts_1' } },
-        { type: 'response.output_item.done', item: { type: 'tool_search_call', id: 'ts_1', arguments: '{"query":"fetch"}' } },
-        { type: 'response.output_item.added', item: { type: 'custom_tool_call', id: 'ct_2', call_id: 'call_custom_2', name: 'apply_patch' } },
-        { type: 'response.custom_tool_call_input.delta', item_id: 'ct_2', delta: '*** Begin Patch' },
-    ]);
-    await assert.rejects(p, /inter-chunk inactivity/);
-    assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'partial custom tool must keep stall path');
-});
-
-test('ws early settle: output_item.done salvages deferred function_call and can early-settle', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
-    socket.feed([
-        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
-        { type: 'response.function_call_arguments.delta', item_id: 'fc_salvage', delta: '{"query"' },
-        { type: 'response.function_call_arguments.done', item_id: 'fc_salvage', arguments: '{"query":"x"}' },
-        { type: 'response.output_item.done', item: { type: 'function_call', id: 'fc_salvage', name: 'explore', call_id: 'call_salvage', arguments: '{"query":"x"}' } },
-    ]);
-    const result = await p;
-    assert.equal(result.closeSocket, true);
-    assert.equal(result.toolCalls[0].id, 'call_salvage');
-    assert.equal(result.toolCalls[0].name, 'explore');
-    assert.deepEqual(result.toolCalls[0].arguments, { query: 'x' });
-});
-
-test('ws early settle: call_id-only tool_search done clears id-tracked active item', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
-    socket.feed([
-        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
-        { type: 'response.output_item.added', item: { type: 'tool_search_call', id: 'ts_added', call_id: 'ts_call' } },
-        { type: 'response.output_item.done', item: { type: 'tool_search_call', call_id: 'ts_call', arguments: '{"query":"fetch"}' } },
-    ]);
-    const result = await p;
-    assert.equal(result.closeSocket, true);
-    assert.equal(result.toolCalls[0].id, 'ts_call');
-});
-
-test('ws early settle: function args.done without item.done does NOT early-settle', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({ entry: { socket }, state: {}, _timeouts: FAST_TIMEOUTS });
-    socket.feed([
-        { type: 'response.created', response: { id: 'resp_1', model: 'gpt-5.5' } },
-        { type: 'response.output_item.added', item: { type: 'function_call', id: 'fc_empty', name: 'explore', call_id: 'call_empty' } },
-        { type: 'response.function_call_arguments.done', item_id: 'fc_empty', arguments: '{}', call_id: 'call_empty', name: 'explore' },
-    ]);
-    await assert.rejects(p, /inter-chunk inactivity/);
-    assert.equal(socket.closed?.reason, 'inter_chunk_timeout', 'function item must stay active until output_item.done');
-});
-
-test('OpenAI WS rejects an oversized Buffer before UTF-8 conversion and marks it retryable', async () => {
-    const socket = new FakeSocket();
-    const state = { attemptIndex: 0 };
-    const payload = Buffer.alloc(33);
-    payload.toString = () => { throw new Error('oversized Buffer was decoded'); };
-    const p = _streamResponse({
-        entry: { socket },
-        state,
-        _timeouts: { ...FAST_TIMEOUTS, maxIncomingFrameBytes: 32 },
-    });
-    socket.emit('message', payload);
-    await assert.rejects(p, (error) => {
-        assert.equal(error.code, 'EOPENAIWSFRAMETOOLARGE');
-        assert.equal(error.retryable, true);
-        assert.match(error.message, /33 bytes; limit 32 bytes.*retryable/);
-        assert.equal(
-            classifyMidstreamError(error, state, MIDSTREAM_RETRY_POLICY.ws),
-            'ws_frame_too_large',
-        );
-        return true;
-    });
-    assert.deepEqual(socket.closed, { code: 1009, reason: 'frame_too_large' });
-});
-
-test('OpenAI WS preserves normal-size Buffer handling', async () => {
-    const socket = new FakeSocket();
-    const p = _streamResponse({
-        entry: { socket },
-        state: {},
-        _timeouts: { ...FAST_TIMEOUTS, maxIncomingFrameBytes: 1024 },
-    });
-    socket.emit('message', Buffer.from(JSON.stringify({
-        type: 'response.completed',
-        response: { id: 'resp_normal', model: 'gpt-5.5', output: [] },
-    })));
-    const result = await p;
-    assert.equal(result.responseId, 'resp_normal');
-});

package/scripts/output-style-bench.mjs

@@ -1,292 +0,0 @@
-#!/usr/bin/env node
-// Lead output-style verbosity bench (default >= simple >= minimal >= extreme-minimal).
-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', 'extreme-minimal'];
-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 style',
-    simple: 'Practical concise',
-    minimal: 'a very short summary',
-    'extreme-minimal': '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 {} }`,
-    // Pooled provider sockets (e.g. openai-oauth WS, 20-min idle TTL) keep the
-    // child alive after the turn; flush JSON then force-exit so execFileSync
-    // returns as soon as the turn completes.
-    `const payload = JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId: session.id });`,
-    `await new Promise((r) => process.stdout.write(payload, r));`,
-    `process.exit(0);`,
-  ].filter(Boolean).join('\n');
-  const raw = execFileSync('node', ['--input-type=module', '-e', driver], {
-    encoding: 'utf8',
-    maxBuffer: 64 * 1024 * 1024,
-    timeout: Number(process.env.OUTPUT_STYLE_BENCH_TURN_TIMEOUT_MS || 10 * 60_000),
-    killSignal: 'SIGKILL',
-    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 >= extreme-minimal).
-
-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

@@ -1,145 +0,0 @@
-#!/usr/bin/env node
-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);
-}
-
-const DEFAULT_REPORT_LABELS = new Set(['Changes', 'Verification', 'Risks / next steps', '\uBC14\uB010 \uC810', '\uD655\uC778\uD55C \uAC83', '\uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4', '\uB2E4\uC74C \uB2E8\uACC4']);
-
-function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedLabels = new Set() } = {}) {
-  const text = String(value || '').trim();
-  assert(text, `${name}: empty output`);
-  assert(!/\n\s*\n/.test(text), `${name}: multiple paragraphs are not compact`);
-  assert(!/^\s*#{1,6}\s/m.test(text), `${name}: heading found`);
-  assert(!/^\s*\d+[.)]\s/m.test(text), `${name}: numbered list found`);
-  assert(!/^\s{2,}[-*]\s/m.test(text), `${name}: nested bullet found`);
-  for (const line of text.split(/\r?\n/)) {
-    const match = line.match(/^\s*(?:[-*]\s+)?([\p{L}\p{N}][\p{L}\p{N} _/-]{0,30}):\s/u);
-    if (match) assert(allowedLabels.has(match[1]), `${name}: disallowed report label found`);
-  }
-  assert(!/\b(?:tool trace|session metadata|model metadata|searched-path list)\b/i.test(text), `${name}: tool/meta trace found`);
-  assert(!/\b(?:Mapped|Searched|Read|Called) for \d/i.test(text), `${name}: timing/tool status found`);
-  assert(!/^(?:\uB124|\uC608|\uB9DE\uC544\uC694|\uC88B\uC544\uC694|\uC54C\uACA0\uC2B5\uB2C8\uB2E4|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
-  assert(!/(.+)(?:\n|\s{2,})\1/.test(text), `${name}: repeated conclusion found`);
-
-  const lines = text.split(/\r?\n/).filter((line) => line.trim());
-  const bulletLines = lines.filter((line) => /^\s*[-*]\s+/.test(line));
-  if (bulletLines.length > 0) {
-    assert(bulletLines.length === lines.length, `${name}: mixed prose and bullets`);
-    assert(bulletLines.length <= maxBullets, `${name}: too many bullets`);
-    return;
-  }
-  assert(lines.length <= maxLines, `${name}: too many lines`);
-
-  const withoutCode = text.replace(/`[^`]*`/g, '');
-  const sentenceMarks = withoutCode.match(/[.!?。！？]|\uB2E4\.|\uC694\./g) || [];
-  assert(sentenceMarks.length <= 2, `${name}: too many sentences`);
-}
-
-const defaultStyle = readFileSync(join(root, 'src', 'output-styles', 'default.md'), 'utf8');
-for (const required of [
-  'name: default',
-  'Concise engineering summaries',
-  'Mixdog default — the most detailed style',
-  'State conclusions, not reasoning',
-  'Use labels such as',
-  '`Changes`, `Verification`,',
-  'Synthesize agent or retrieval results',
-  'Do not hide blockers',
-]) {
-  assert(defaultStyle.includes(required), `default.md missing: ${required}`);
-}
-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 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 [
-  'name: simple',
-  'Outcome-first concise handoffs for coding work',
-  'Practical concise — outcome-first handoffs',
-  'file_path:line_number',
-  'Controlled detail',
-  'Synthesize agent or retrieval results',
-  'Do not hide blockers',
-  'verification was not run, say so once',
-]) {
-  assert(simpleStyle.includes(required), `simple.md missing: ${required}`);
-}
-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,
-  minimal: readFileSync(join(root, 'src', 'output-styles', 'minimal.md'), 'utf8'),
-  'extreme-minimal': readFileSync(join(root, 'src', 'output-styles', 'extreme-minimal.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`);
-}
-
-const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-output-style-smoke-'));
-try {
-  writeFileSync(join(dataDir, 'user-workflow.md'), 'workflow context should not override output style\n');
-  const leadRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
-  const outputStyleIndex = leadRules.lastIndexOf('# Output Style');
-  assert(outputStyleIndex >= 0, 'Lead output style missing');
-  assert(outputStyleIndex > leadRules.lastIndexOf('# User Workflow'), 'Lead output style must be injected after workflow/user context');
-
-  mkdirSync(join(dataDir, 'output-styles'), { recursive: true });
-  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({
-    agent: { profile: { title: '\uD64D\uAE38\uB3D9\uB2D8', language: 'system' } },
-    outputStyle: 'custom-smoke',
-  }));
-  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 — 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 "\uD64D\uAE38\uB3D9\uB2D8" 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');
-  assert(/Default user-facing response language from system locale/.test(profileMeta), 'system profile language must resolve from system locale');
-  assert(profileMeta.includes('pre-tool preambles (even single-line)'), 'profile language must cover pre-tool preambles');
-} finally {
-  rmSync(dataDir, { recursive: true, force: true });
-}
-
-// assertCleanOutput encodes the Simple style compact contract (not Default, which may be longer).
-const goodOutputs = {
-  explanation: 'Simple \uC2A4\uD0C0\uC77C\uC740 \uACB0\uACFC \uD55C \uC904\uACFC \uADFC\uAC70 \uD55C \uAC00\uC9C0\uB85C \uB05D\uB0B4\uACE0, \uCD5C\uC885 handoff\uB9CC \uC9E7\uC740 bullet \uB77C\uBCA8\uC744 \uC501\uB2C8\uB2E4.',
-  implementation: '- \uBC14\uB010 \uC810: `scripts/output-style-smoke.mjs`\uC758 default/simple \uBB38\uC790\uC5F4 \uAC80\uC99D\uC744 \uD604\uC7AC \uD504\uB9AC\uC14B\uC5D0 \uB9DE\uCDC4\uC2B5\uB2C8\uB2E4.\n- \uD655\uC778\uD55C \uAC83: `node scripts/output-style-smoke.mjs`\uB97C \uC2E4\uD589\uD588\uC2B5\uB2C8\uB2E4.',
-  crowded: '- \uBC14\uB010 \uC810: compact guardrail\uC740 Simple handoff\uC6A9 controlled detail\uC744 \uAC80\uC99D\uD569\uB2C8\uB2E4.\n- \uD655\uC778\uD55C \uAC83: bad \uC0D8\uD50C \uAC70\uBD80 \uADDC\uCE59\uC740 \uADF8\uB300\uB85C\uC785\uB2C8\uB2E4.',
-  blocker: '`scripts/output-style-smoke.mjs`\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC5B4 \uBCC0\uACBD\uC774 \uB9C9\uD614\uC2B5\uB2C8\uB2E4.',
-  semicolon: '\uC2A4\uBAA8\uD06C \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uAC31\uC2E0\uD588\uACE0; Simple \uACC4\uC57D\uC5D0 \uB9DE\uB294 \uC608\uC2DC \uC751\uB2F5\uB9CC \uD1B5\uACFC\uD569\uB2C8\uB2E4.',
-};
-for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output, { allowedLabels: DEFAULT_REPORT_LABELS });
-
-const badOutputs = {
-  heading: '## Summary\nDone.',
-  label: 'Changed: updated default style.',
-  koreanLabel: '\uBCC0\uACBD: default \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.\n\uAC80\uC99D: \uC2A4\uBAA8\uD06C\uB97C \uD1B5\uACFC\uD588\uC2B5\uB2C8\uB2E4.',
-  numbered: '1. Updated style\n2. Ran smoke',
-  paragraphs: 'Done.\n\nDone again.',
-  nested: '- Updated\n  - Nested detail',
-  ack: '\uB124, default \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.',
-  timing: 'Mapped for 2m 32s\n\ndefault \uC2A4\uD0C0\uC77C\uC744 \uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.',
-  tooManySentences: '\uC218\uC815\uD588\uC2B5\uB2C8\uB2E4. \uAC80\uC99D\uD588\uC2B5\uB2C8\uB2E4. \uBCF4\uACE0\uD588\uC2B5\uB2C8\uB2E4.',
-  mixed: '\uC218\uC815\uD588\uC2B5\uB2C8\uB2E4.\n- \uAC80\uC99D\uD588\uC2B5\uB2C8\uB2E4.',
-  tooManyBullets: '- \uBC14\uB010 \uC810: A\n- \uD655\uC778\uD55C \uAC83: B\n- \uB2E4\uC74C \uB2E8\uACC4: C\n- \uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4: D',
-};
-for (const [name, output] of Object.entries(badOutputs)) {
-  let failed = false;
-  try { assertCleanOutput(`bad:${name}`, output, { allowedLabels: DEFAULT_REPORT_LABELS }); } catch { failed = true; }
-  assert(failed, `bad sample unexpectedly passed: ${name}`);
-}
-
-process.stdout.write(`output style smoke passed samples=${Object.keys(goodOutputs).length}\n`);