mixdog 0.8.1 → 0.9.1

package/scripts/live-worker-smoke.mjs

@@ -2,7 +2,7 @@
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { BRIDGE_TOOL, createStandaloneBridge } from '../src/standalone/bridge-tool.mjs';
+import { AGENT_TOOL, createStandaloneAgent } from '../src/standalone/agent-tool.mjs';
 import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
 import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
 import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
@@ -28,27 +28,19 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function jobId(text) {
-  return String(text).match(/bridge job: (\S+)/)?.[1] || null;
+function taskId(text) {
+  return String(text).match(/agent task: (\S+)/)?.[1] || null;
 }
 
 async function main() {
-  const leadToolRules = readFileSync('src/rules/lead/00-tool-lead.md', 'utf8');
-  const workflowRules = readFileSync('src/defaults/user-workflow.md', 'utf8');
-  assert(/Use `bridge` to delegate actual scoped work/i.test(leadToolRules), 'lead rules must direct scoped work to bridge');
-  assert(/parallelize independent files\/concerns/i.test(leadToolRules), 'lead rules must keep independent work parallel');
-  assert(/Use bridge workers/i.test(workflowRules) && /parallelizes useful work/i.test(workflowRules), 'workflow rules must recommend bridge parallelism');
-  assert(/Prefer async by default/i.test(BRIDGE_TOOL.description || '') && /distinct tags/i.test(BRIDGE_TOOL.description || '') && /completion notification/i.test(BRIDGE_TOOL.description || ''), 'bridge tool description must expose async parallel tags');
+  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(/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 });
   await initProviders({ 'openai-oauth': { enabled: true } });
-  writeFileSync(join(dataDir, 'user-workflow.json'), JSON.stringify({
-    roles: [
-      { name: 'worker', preset: 'fake-worker', permission: 'full', maxLoopIterations: 3, idleTimeoutMs: 5000 },
-      { name: 'reviewer', preset: 'fake-reviewer', permission: 'read' },
-      { name: 'debugger', preset: 'fake-debugger', permission: 'read' },
-    ],
-  }));
   writeFileSync(join(root, 'feature.txt'), 'alpha\nbeta\n', 'utf8');
   writeFileSync(join(root, 'notes.txt'), 'TODO investigate timeout\n', 'utf8');
 
@@ -56,6 +48,11 @@ async function main() {
     loadConfig() {
       return {
         providers: { 'openai-oauth': { enabled: true } },
+        agents: {
+          worker: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'medium', fast: true },
+          reviewer: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low' },
+          debugger: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low' },
+        },
         presets: [
           { id: 'fake-worker', name: 'Fake Worker', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'full', effort: 'medium', fast: true },
           { id: 'fake-reviewer', name: 'Fake Reviewer', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
@@ -64,7 +61,7 @@ async function main() {
       };
     },
     resolveRuntimeSpec(preset, ctx) {
-      return { lane: 'bridge', scopeKey: `smoke:${ctx.agentId}`, provider: preset.provider, model: preset.model };
+      return { lane: 'agent', scopeKey: `smoke:${ctx.agentId}`, provider: preset.provider, model: preset.model };
     },
   };
   const reg = { initProviders };
@@ -130,14 +127,14 @@ async function main() {
     getSessionLastProgressAt,
     askSession: fakeAskSession,
   };
-  const bridge = createStandaloneBridge({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
+  const agentRunner = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
 
   async function waitJob(out, pattern, label) {
-    const id = jobId(out);
-    assert(id, `missing job id for ${label}: ${out}`);
+    const id = taskId(out);
+    assert(id, `missing task ID for ${label}: ${out}`);
     let last = '';
     for (let i = 0; i < 40; i += 1) {
-      last = await bridge.execute({ type: 'read', jobId: id }, { invocationSource: 'model-tool', cwd: root });
+      last = await agentRunner.execute({ type: 'read', task_id: id }, { invocationSource: 'model-tool', cwd: root });
       if (pattern.test(last)) return last;
       if (/^Error[\s:[]/.test(last) || /status: error/.test(last)) break;
       await sleep(100);
@@ -145,7 +142,15 @@ async function main() {
     throw new Error(`${label} did not finish with ${pattern}: ${last}`);
   }
 
-  const spawnOut = await bridge.execute({
+  async function waitAgentTag(tag, label) {
+    for (let i = 0; i < 20; i += 1) {
+      if (listSessions().some((session) => session?.agentTag === tag && !session.closed)) return;
+      await sleep(25);
+    }
+    throw new Error(`${label} did not register agent tag ${tag}`);
+  }
+
+  const spawnOut = await agentRunner.execute({
     type: 'spawn',
     role: 'worker',
     tag: 'impl1',
@@ -154,22 +159,22 @@ async function main() {
   }, { invocationSource: 'model-tool', cwd: root });
   await waitJob(spawnOut, /worker wrote feature/, 'worker write');
 
-  const sendOut = await bridge.execute({
+  const sendOut = await agentRunner.execute({
     type: 'send',
     tag: 'impl1',
     message: 'run verification: inspect feature.txt using bash',
   }, { invocationSource: 'model-tool', cwd: root });
-  assert(/bridge job:/.test(sendOut), `completed worker send should be async job, got ${sendOut}`);
+  assert(/agent task:/.test(sendOut), `completed worker send should be async task, got ${sendOut}`);
   await waitJob(sendOut, /beta from worker/, 'worker verify');
 
-  const reviewOut = await bridge.execute({
+  const reviewOut = await agentRunner.execute({
     type: 'spawn',
     role: 'reviewer',
     tag: 'rev1',
     cwd: root,
     prompt: 'review feature.txt for the worker change',
   }, { invocationSource: 'model-tool', cwd: root });
-  const debugOut = await bridge.execute({
+  const debugOut = await agentRunner.execute({
     type: 'spawn',
     role: 'debugger',
     tag: 'dbg1',
@@ -180,21 +185,21 @@ async function main() {
   await waitJob(debugOut, /debugger TODO/, 'debugger');
 
   const parallelSpawns = await Promise.all([
-    bridge.execute({
+    agentRunner.execute({
       type: 'spawn',
       role: 'worker',
       tag: 'parWorker',
       cwd: root,
       prompt: 'parallel slow worker task',
     }, { invocationSource: 'model-tool', cwd: root }),
-    bridge.execute({
+    agentRunner.execute({
       type: 'spawn',
       role: 'reviewer',
       tag: 'parReviewer',
       cwd: root,
       prompt: 'parallel slow review task',
     }, { invocationSource: 'model-tool', cwd: root }),
-    bridge.execute({
+    agentRunner.execute({
       type: 'spawn',
       role: 'debugger',
       tag: 'parDebugger',
@@ -202,33 +207,34 @@ async function main() {
       prompt: 'parallel slow debug task',
     }, { invocationSource: 'model-tool', cwd: root }),
   ]);
-  assert(parallelSpawns.every((out) => /bridge job:/.test(out)), `parallel spawns must return jobs: ${parallelSpawns.join('\n---\n')}`);
+  assert(parallelSpawns.every((out) => /agent task:/.test(out)), `parallel spawns must return tasks: ${parallelSpawns.join('\n---\n')}`);
   await Promise.all([
     waitJob(parallelSpawns[0], /ack worker/, 'parallel worker'),
     waitJob(parallelSpawns[1], /reviewer ok/, 'parallel reviewer'),
     waitJob(parallelSpawns[2], /debugger TODO/, 'parallel debugger'),
   ]);
-  assert(maxActiveAsks >= 2, `bridge workers did not overlap; maxActiveAsks=${maxActiveAsks}`);
+  assert(maxActiveAsks >= 2, `agents did not overlap; maxActiveAsks=${maxActiveAsks}`);
 
-  const busyOut = await bridge.execute({
+  const busyOut = await agentRunner.execute({
     type: 'spawn',
     role: 'worker',
     tag: 'busy1',
     cwd: root,
     prompt: 'long busy worker task',
   }, { invocationSource: 'model-tool', cwd: root });
-  const queued = await bridge.execute({
+  await waitAgentTag('busy1', 'busy worker');
+  const queued = await agentRunner.execute({
     type: 'send',
     tag: 'busy1',
     message: 'follow-up while still busy',
   }, { invocationSource: 'model-tool', cwd: root });
-  assert(/bridge message queued/.test(queued), `busy send should queue, got ${queued}`);
+  assert(/agent message queued/.test(queued), `busy send should queue, got ${queued}`);
   await waitJob(busyOut, /ack worker/, 'busy worker');
 
-  const missing = await bridge.execute({ type: 'read', jobId: 'job_missing_live_smoke' }, { invocationSource: 'model-tool', cwd: root });
-  assert(/^Error[\s:[]/.test(missing), 'missing bridge job should be Error result');
+  const missing = await agentRunner.execute({ type: 'read', task_id: 'task_missing_live_smoke' }, { invocationSource: 'model-tool', cwd: root });
+  assert(/^Error[\s:[]/.test(missing), 'missing agent task should be Error result');
   assert(readFileSync(join(root, 'feature.txt'), 'utf8').includes('beta from worker'), 'final file missing worker edit');
-  bridge.closeAll('live-worker-smoke-end');
+  agentRunner.closeAll('live-worker-smoke-end');
   process.stdout.write('live worker smoke passed\n');
 }
 

package/scripts/llm-trace-summary.mjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+
+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((arg) => arg.startsWith(pref));
+  return hit ? hit.slice(pref.length) : fallback;
+}
+
+function intArg(name, fallback) {
+  const n = Number.parseInt(argValue(name, String(fallback)), 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+const pathArg = argValue('--path', null);
+const dataDir = argValue('--data-dir', null);
+const sinceArg = argValue('--since', null);
+const kindFilter = argValue('--kind', null);
+const last = intArg('--last', 5000);
+const limit = intArg('--limit', 20);
+const slowMs = intArg('--slow-ms', 3000);
+const jsonMode = process.argv.includes('--json');
+
+const mixdogHome = process.env.MIXDOG_HOME || resolve(homedir(), '.mixdog');
+const mixdogDataDir = process.env.MIXDOG_DATA_DIR || resolve(mixdogHome, 'data');
+
+function unique(values) {
+  const seen = new Set();
+  const out = [];
+  for (const value of values) {
+    const key = String(value || '');
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(value);
+  }
+  return out;
+}
+
+function defaultTraceFiles() {
+  if (pathArg) return [resolve(pathArg)];
+  const dirs = dataDir
+    ? [resolve(dataDir)]
+    : [resolve(process.cwd(), '.mixdog', 'data'), mixdogDataDir];
+  return unique(dirs.flatMap((dir) => [
+    resolve(dir, 'history', 'agent-trace.jsonl.1'),
+    resolve(dir, 'history', 'agent-trace.jsonl'),
+    resolve(dir, 'history', 'agent-trace.jsonl.1'),
+    resolve(dir, 'history', 'agent-trace.jsonl'),
+  ]));
+}
+
+function parseSince(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+  if (/^now$/i.test(raw)) return Date.now();
+  if (/^\d+$/.test(raw)) {
+    const n = Number(raw);
+    return n > 10_000_000_000 ? n : n * 1000;
+  }
+  const rel = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/i);
+  if (rel) {
+    const n = Number(rel[1]);
+    const unit = rel[2].toLowerCase();
+    const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60_000 : unit === 'h' ? 3_600_000 : 86_400_000;
+    return Date.now() - n * mult;
+  }
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function readRows(file) {
+  if (!existsSync(file)) return [];
+  return readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return { file, ...JSON.parse(line) };
+      } catch {
+        return { file, kind: 'parse_error', payload: { line: line.slice(0, 300) } };
+      }
+    });
+}
+
+function payload(row) {
+  return row && row.payload && typeof row.payload === 'object' ? row.payload : {};
+}
+
+function field(row, name) {
+  if (row && row[name] != null) return row[name];
+  const p = payload(row);
+  return p[name] != null ? p[name] : null;
+}
+
+function numberField(row, name) {
+  const n = Number(field(row, name));
+  return Number.isFinite(n) ? n : null;
+}
+
+function countBy(rows, fn) {
+  const map = new Map();
+  for (const row of rows) {
+    const key = String(fn(row) ?? '(none)');
+    map.set(key, (map.get(key) || 0) + 1);
+  }
+  return Object.fromEntries([...map.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])));
+}
+
+function values(rows, name) {
+  return rows.map((row) => numberField(row, name)).filter((n) => n != null);
+}
+
+function percentile(sorted, p) {
+  if (sorted.length === 0) return null;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+  return sorted[idx];
+}
+
+function stats(nums) {
+  const arr = nums.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+  if (arr.length === 0) return null;
+  const sum = arr.reduce((a, b) => a + b, 0);
+  return {
+    n: arr.length,
+    sum,
+    avg: Math.round(sum / arr.length),
+    p50: percentile(arr, 50),
+    p90: percentile(arr, 90),
+    p99: percentile(arr, 99),
+    max: arr[arr.length - 1],
+  };
+}
+
+function formatStats(s) {
+  if (!s) return 'n=0';
+  return `n=${s.n} avg=${s.avg}ms p50=${s.p50}ms p90=${s.p90}ms p99=${s.p99}ms max=${s.max}ms`;
+}
+
+function short(value, max = 140) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+
+function timeLabel(ts) {
+  const n = Number(ts);
+  if (!Number.isFinite(n) || n <= 0) return '-';
+  try {
+    return new Date(n).toISOString();
+  } catch {
+    return String(ts);
+  }
+}
+
+function topStatsBy(rows, groupName, valueName, minValue = null) {
+  const groups = new Map();
+  for (const row of rows) {
+    const value = numberField(row, valueName);
+    if (value == null) continue;
+    if (minValue != null && value < minValue) continue;
+    const key = String(field(row, groupName) || '(none)');
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(value);
+  }
+  return [...groups.entries()]
+    .map(([key, nums]) => ({ key, ...stats(nums) }))
+    .sort((a, b) => b.max - a.max || b.p90 - a.p90 || b.n - a.n);
+}
+
+function topStatsByTotal(rows, groupName, valueName, minValue = null) {
+  return topStatsBy(rows, groupName, valueName, minValue)
+    .sort((a, b) => b.sum - a.sum || b.max - a.max || b.p90 - a.p90 || b.n - a.n);
+}
+
+function printCounts(label, obj, max = 12) {
+  const parts = Object.entries(obj).slice(0, max).map(([k, v]) => `${k}:${v}`);
+  console.log(`${label}: ${parts.join(', ') || '(none)'}`);
+}
+
+const files = defaultTraceFiles();
+const sinceTs = parseSince(sinceArg);
+const allRows = files.flatMap(readRows)
+  .filter((row) => sinceTs == null || Number(row.ts || 0) >= sinceTs)
+  .filter((row) => !kindFilter || String(row.kind || '') === kindFilter)
+  .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
+const rows = allRows.slice(-last);
+
+const kindCounts = countBy(rows, (row) => row.kind || 'unknown');
+const transportRows = rows.filter((row) => row.kind === 'transport');
+const sseRows = rows.filter((row) => row.kind === 'sse');
+const fetchRows = rows.filter((row) => row.kind === 'fetch');
+const toolRows = rows.filter((row) => row.kind === 'tool');
+const toolSlowRows = rows.filter((row) => row.kind === 'tool_slow' || (row.kind === 'tool' && (numberField(row, 'tool_ms') || 0) >= slowMs));
+const cacheSlowRows = rows.filter((row) => row.kind === 'cache_lane_slow');
+const explicitCacheBreakRows = rows.filter((row) => row.kind === 'cache_break');
+const explicitCacheBreakKeys = new Set(explicitCacheBreakRows.map((row) => `${row.session_id || ''}:${row.iteration ?? ''}`));
+const cacheBreakRows = explicitCacheBreakRows
+  .concat(transportRows.filter((row) => field(row, 'chain_delta_reason') && !explicitCacheBreakKeys.has(`${row.session_id || ''}:${row.iteration ?? ''}`)));
+const fallbackRows = rows.filter((row) => row.kind === 'transport_fallback');
+
+const report = {
+  analyzed: rows.length,
+  matched: allRows.length,
+  since: sinceTs ? new Date(sinceTs).toISOString() : null,
+  filters: {
+    kind: kindFilter,
+    last,
+    slow_ms: slowMs,
+  },
+  sources: files.filter(existsSync),
+  kinds: kindCounts,
+  transport: {
+    modes: countBy(transportRows, (row) => field(row, 'ws_mode') || field(row, 'transport') || '(unknown)'),
+    rate_policies: countBy(transportRows.filter((row) => field(row, 'cache_lane_rate_policy')), (row) => field(row, 'cache_lane_rate_policy')),
+    delta_reasons: countBy(transportRows.filter((row) => field(row, 'chain_delta_reason')), (row) => field(row, 'chain_delta_reason')),
+    cache_lane_rate_wait_ms: stats(values(transportRows, 'cache_lane_rate_wait_ms')),
+    cache_lane_rate_reacquire_wait_ms: stats(values(transportRows, 'cache_lane_rate_reacquire_wait_ms')),
+    cache_lane_wait_ms: stats(values(transportRows, 'cache_lane_wait_ms')),
+    cache_lane_slow: cacheSlowRows.length,
+    fallback: countBy(fallbackRows, (row) => field(row, 'reason') || field(row, 'fallback_reason') || '(unknown)'),
+  },
+  sse: {
+    ttft_ms: stats(values(sseRows, 'ttft_ms')),
+    sse_parse_ms: stats(values(sseRows, 'sse_parse_ms')),
+  },
+  fetch: {
+    headers_ms: stats(values(fetchRows, 'headers_ms')),
+  },
+  tools: {
+    slow_ms: slowMs,
+    by_tool: topStatsBy(toolRows, 'tool_name', 'tool_ms'),
+    by_tool_total: topStatsByTotal(toolRows, 'tool_name', 'tool_ms'),
+    slow_by_tool: topStatsBy(toolRows, 'tool_name', 'tool_ms', slowMs),
+  },
+  cache_breaks: {
+    count: cacheBreakRows.length,
+    reasons: countBy(cacheBreakRows, (row) => field(row, 'reason') || field(row, 'chain_delta_reason') || '(unknown)'),
+  },
+  samples: {
+    slow_tools: toolSlowRows
+      .slice()
+      .sort((a, b) => Number(numberField(b, 'tool_ms') || 0) - Number(numberField(a, 'tool_ms') || 0))
+      .slice(0, limit)
+      .map((row) => ({
+        ts: timeLabel(row.ts),
+        session_id: row.session_id || null,
+        iteration: row.iteration ?? null,
+        tool_name: field(row, 'tool_name'),
+        tool_ms: numberField(row, 'tool_ms'),
+        role: field(row, 'role'),
+        model: field(row, 'model'),
+        args: payload(row).tool_args || row.tool_args || null,
+      })),
+    cache_lane_slow: cacheSlowRows.slice(-limit).map((row) => ({
+      ts: timeLabel(row.ts),
+      session_id: row.session_id || null,
+      iteration: row.iteration ?? null,
+      event: field(row, 'event'),
+      provider: field(row, 'provider'),
+      model: field(row, 'model'),
+      payload: payload(row),
+    })),
+    cache_breaks: cacheBreakRows.slice(-limit).map((row) => ({
+      ts: timeLabel(row.ts),
+      session_id: row.session_id || null,
+      iteration: row.iteration ?? null,
+      reason: field(row, 'reason') || field(row, 'chain_delta_reason'),
+      provider: field(row, 'provider'),
+      model: field(row, 'model'),
+      payload: payload(row),
+    })),
+  },
+};
+
+if (jsonMode) {
+  console.log(JSON.stringify(report, null, 2));
+  process.exit(0);
+}
+
+console.log(`llm trace: ${rows.length}/${allRows.length} rows analyzed`);
+if (sinceTs) console.log(`since: ${new Date(sinceTs).toISOString()}`);
+if (kindFilter) console.log(`filter: kind=${kindFilter}`);
+console.log(`sources: ${report.sources.join(', ') || '(none)'}`);
+printCounts('kinds', report.kinds);
+printCounts('transport modes', report.transport.modes);
+printCounts('cache lane rate policies', report.transport.rate_policies);
+printCounts('delta/full reasons', report.transport.delta_reasons);
+printCounts('transport fallback', report.transport.fallback);
+console.log(`cache lane rate wait: ${formatStats(report.transport.cache_lane_rate_wait_ms)}`);
+console.log(`cache lane rate reacquire wait: ${formatStats(report.transport.cache_lane_rate_reacquire_wait_ms)}`);
+console.log(`cache lane queue wait: ${formatStats(report.transport.cache_lane_wait_ms)}`);
+console.log(`cache lane slow rows: ${report.transport.cache_lane_slow}`);
+console.log(`ttft: ${formatStats(report.sse.ttft_ms)}`);
+console.log(`sse parse: ${formatStats(report.sse.sse_parse_ms)}`);
+console.log(`fetch headers: ${formatStats(report.fetch.headers_ms)}`);
+console.log(`cache breaks: ${report.cache_breaks.count}`);
+printCounts('cache break reasons', report.cache_breaks.reasons);
+console.log('tools by total time:');
+for (const row of report.tools.by_tool_total.slice(0, 12)) {
+  console.log(`- ${row.key}: n=${row.n} total=${Math.round(row.sum)}ms avg=${row.avg}ms p90=${row.p90}ms max=${row.max}ms`);
+}
+if (report.tools.by_tool_total.length === 0) console.log('- (none)');
+console.log('slow tools:');
+for (const row of report.tools.slow_by_tool.slice(0, 12)) {
+  console.log(`- ${row.key}: n=${row.n} avg=${row.avg}ms p90=${row.p90}ms max=${row.max}ms`);
+}
+if (report.tools.slow_by_tool.length === 0) console.log('- (none)');
+console.log('slow tool samples:');
+for (const row of report.samples.slow_tools) {
+  console.log(`- ${row.ts} ${row.tool_name} ${row.tool_ms}ms role=${row.role || '-'} args=${short(JSON.stringify(row.args || {}), 180)}`);
+}
+if (report.samples.slow_tools.length === 0) console.log('- (none)');

package/scripts/memory-meta-concurrency-test.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Regression: mergeMetaValue uses jsonb shallow merge (not full replace).
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mergeMetaValue } from '../src/runtime/memory/lib/memory.mjs'
+
+test('mergeMetaValue issues INSERT ... ON CONFLICT DO UPDATE with jsonb ||', async () => {
+  const calls = []
+  const db = {
+    async query(sql, params) {
+      calls.push({ sql, params })
+    },
+  }
+  await mergeMetaValue(db, 'state.cycle_last_run', { cycle1: 100, cycle2_last_error: '' })
+  assert.equal(calls.length, 1)
+  assert.match(calls[0].sql, /COALESCE\(meta\.value/)
+  assert.match(calls[0].sql, /\|\| EXCLUDED\.value/)
+  assert.deepEqual(calls[0].params, ['state.cycle_last_run', '{"cycle1":100,"cycle2_last_error":""}'])
+})
+

package/scripts/output-style-smoke.mjs

@@ -13,14 +13,19 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
-function assertCleanOutput(name, value, { maxLines = 2, maxBullets = 3 } = {}) {
+const DEFAULT_REPORT_LABELS = new Set(['바뀐 점', '확인한 것', '남은 리스크/다음 단계', '다음 단계']);
+
+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`);
-  assert(!/^\s*[\p{L}\p{N}][\p{L}\p{N} _-]{0,30}:\s/um.test(text), `${name}: report label 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(!/^(?:네|예|맞아요|좋아요|알겠습니다|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
@@ -43,15 +48,42 @@ function assertCleanOutput(name, value, { maxLines = 2, maxBullets = 3 } = {}) {
 const defaultStyle = readFileSync(join(root, 'src', 'output-styles', 'default.md'), 'utf8');
 for (const required of [
   'name: default',
-  'Uniformity beats local cleverness.',
-  'One answer only.',
-  'Hard cap user-visible replies at 2 short sentences',
-  'Explore/retrieval results are evidence only',
-  'Do not use label prefixes',
+  'Concise engineering summaries',
+  'Mixdog default — concise engineering summaries',
+  'Use labels such as',
+  '`바뀐 점`, `확인한 것`,',
+  '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'), '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',
+  'if verification was',
+]) {
+  assert(simpleStyle.includes(required), `simple.md missing: ${required}`);
+}
+assert(!simpleStyle.includes('Mixdog default — concise engineering summaries'), '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'),
+})) {
+  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 {
@@ -62,23 +94,31 @@ try {
   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({ outputStyle: 'custom-smoke' }));
+  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({
+    agent: { profile: { title: '재영님', 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('Default concise engineering replies'), 'custom outputStyle should not append default style');
+  assert(!customRules.includes('Mixdog default — concise engineering summaries'), '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');
+  assert(/Default user-facing response language from system locale/.test(profileMeta), 'system profile language must resolve from system locale');
+  assert(profileMeta.includes('including pre-tool preambles'), 'profile language must cover pre-tool preambles');
 } finally {
   rmSync(dataDir, { recursive: true, force: true });
 }
 
 const goodOutputs = {
-  explanation: '기본 출력은 한 문장으로 결론만 말하고, 추가 설명은 사용자가 요청할 때만 붙입니다.',
-  implementation: 'default 출력 스타일을 한 문장 우선으로 조였고 `npm run smoke:output`으로 확인했습니다.',
-  crowded: '- default 스타일은 한 문장 우선입니다.\n- 상세/후보 요청이 있을 때만 목록을 펼칩니다.',
+  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`를 다듬었고; 출력 스모크가 예시 응답 모양을 검증합니다.',
+  semicolon: '`default.md`를 갱신했고; 출력 스모크가 예시 응답 모양을 검증합니다.',
 };
-for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output);
+for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output, { allowedLabels: DEFAULT_REPORT_LABELS });
 
 const badOutputs = {
   heading: '## Summary\nDone.',
@@ -91,10 +131,11 @@ const badOutputs = {
   timing: 'Mapped for 2m 32s\n\ndefault 스타일을 수정했습니다.',
   tooManySentences: '수정했습니다. 검증했습니다. 보고했습니다.',
   mixed: '수정했습니다.\n- 검증했습니다.',
+  tooManyBullets: '- 바뀐 점: A\n- 확인한 것: B\n- 다음 단계: C\n- 남은 리스크/다음 단계: D',
 };
 for (const [name, output] of Object.entries(badOutputs)) {
   let failed = false;
-  try { assertCleanOutput(`bad:${name}`, output); } catch { failed = true; }
+  try { assertCleanOutput(`bad:${name}`, output, { allowedLabels: DEFAULT_REPORT_LABELS }); } catch { failed = true; }
   assert(failed, `bad sample unexpectedly passed: ${name}`);
 }