mixdog 0.9.174 → 0.9.175

package/scripts/lib/session-bench-render.mjs

@@ -0,0 +1,394 @@
+// Text renderer for the session-bench report. Pure: the CLI options are passed in.
+import { compactText, fmtKindCounts, fmtMs, fmtPct, fmtSec, fmtTok, padTable, shortId } from './session-bench-fmt.mjs';
+
+function renderHeader(report, lines) {
+  lines.push(`Session bench (${report.selected_sessions.map(shortId).join(', ')})`);
+  lines.push(
+    `range: ${report.time_range.start || '-'} → ${report.time_range.end || '-'} (${fmtSec(report.time_range.span_ms)})`
+  );
+  lines.push(
+    `turns=${report.summary.turns} tools=${report.summary.tool_calls} llm_stream=${fmtMs(report.summary.llm_stream_ms)} tool_time=${fmtMs(report.summary.total_tool_ms)} cache=${fmtPct((report.summary.cache_ratio ?? 0) * 100)}`
+  );
+  lines.push('');
+}
+
+function renderExecutiveSummary(report, lines, opts) {
+  lines.push('Executive summary');
+  for (const line of report.executive_summary || []) lines.push(`- ${line}`);
+  if (report.rankings?.length) {
+    lines.push('why slow / risk ranking:');
+    for (const r of report.rankings.slice(0, Math.min(opts.limit, 8))) lines.push(`- [${r.type}] ${r.message}`);
+  }
+  lines.push('');
+}
+
+function compactBreakLine(b) {
+  return `- ${shortId(b.session_id)} it=${b.iteration ?? '-'} phase=${b.phase || '-'} reason=${b.reason || '-'} prompt=${fmtTok(b.prompt_tokens)} out=${fmtTok(b.output_tokens)}`;
+}
+
+function renderCompactMeta(report, lines, opts) {
+  lines.push('compact meta:');
+  for (const m of report.compact.recent_meta.slice(0, Math.min(opts.limit, 10))) {
+    const pipe = m.handoff_pipeline;
+    const fit = m.fit;
+    const parts = [
+      `- ${shortId(m.session_id)} it=${m.iteration ?? '-'} ${fmtMs(m.duration_ms)} ${fmtTok(m.before_tokens)}→${fmtTok(m.after_tokens)}`,
+      `pressure=${fmtTok(m.pressure_tokens)}/${fmtTok(m.trigger_tokens)}/${fmtTok(m.boundary_tokens)}`,
+      `target=${fmtTok(m.target_budget_tokens)} changed=${m.changed}`,
+    ];
+    if (m.error) parts.push(`error=${compactText(m.error, 120)}`);
+    lines.push(parts.join(' '));
+    if (pipe) {
+      lines.push(
+        `  handoff pipeline: ingest=${fmtMs(pipe.ingest_ms)} dump=${fmtMs(pipe.initial_dump_ms)} raw=${pipe.initial_raw_pending ?? '-'} cycle1=${fmtMs(pipe.cycle1_ms)} passes=${pipe.cycle1_passes ?? '-'} rawLeft=${pipe.cycle1_raw_remaining ?? '-'} handoff=${pipe.final_handoff_kb ?? '-'}KB`
+      );
+    }
+    if (fit) {
+      const handoffPart =
+        fit.handoff_chars != null ? ` handoffChars=${fit.handoff_chars} tailTrunc=${fit.tail_truncated}` : '';
+      lines.push(
+        `  fit: head=${fit.head_messages ?? '-'} tail=${fit.tail_messages ?? '-'} mandatory=${fmtTok(fit.mandatory_cost)} remain=${fmtTok(fit.remaining_tokens)} final=${fmtTok(fit.final_tokens)} raised=${fit.budget_raised}${handoffPart}`
+      );
+    }
+  }
+}
+
+function renderCompactDiagnostics(report, lines, opts) {
+  if (
+    !(report.compact?.sessions?.length || report.compact?.recent_meta?.length || report.compact?.cache_breaks?.length)
+  ) {
+    lines.push('compact diagnostics: none');
+    return;
+  }
+  lines.push('compact diagnostics:');
+  if (report.compact.sessions.length) {
+    const ctable = [['session', 'turns', 'stream', 'prompt', 'out', 'cache', 'breaks', 'WS']];
+    for (const c of report.compact.sessions.slice(0, 5)) {
+      ctable.push([
+        shortId(c.session_id),
+        c.turns,
+        fmtMs(c.stream_ms),
+        fmtTok(c.prompt_tokens),
+        fmtTok(c.output_tokens + c.thinking_tokens),
+        fmtPct((c.cache_ratio ?? 0) * 100),
+        `${c.breaks}${c.no_anchor ? `/no_anchor×${c.no_anchor}` : ''}`,
+        `${c.delta_ws}Δ/${c.full_ws}F`,
+      ]);
+    }
+    lines.push(...padTable(ctable));
+  }
+  if (report.compact.recent_meta?.length) renderCompactMeta(report, lines, opts);
+  const intentionalCompactBreaks = report.compact.cache_breaks.filter((b) => !b.actionable);
+  const actionableCompactBreaks = report.compact.cache_breaks.filter((b) => b.actionable);
+  if (intentionalCompactBreaks.length) {
+    lines.push('compact cache resets (intentional):');
+    for (const b of intentionalCompactBreaks.slice(0, 5)) lines.push(compactBreakLine(b));
+  }
+  if (actionableCompactBreaks.length) {
+    lines.push('compact cache breaks (actionable):');
+    for (const b of actionableCompactBreaks.slice(0, 5)) lines.push(compactBreakLine(b));
+  }
+}
+
+function renderRouteTimeline(report, lines) {
+  lines.push('Route timeline');
+  const table = [['agent', 'model', 'turns', 'wall', 'LLM', 'tools', 'tool_ms', 'cache', 'WS', 'reused', 'session']];
+  for (const g of report.routeGroups) {
+    table.push([
+      g.agent || '-',
+      `${g.provider || '?'}:${g.model || '?'}`,
+      g.turns,
+      fmtSec((g.max_ts || 0) - (g.min_ts || 0)),
+      fmtMs(g.llm_stream_ms),
+      g.tool_calls,
+      fmtMs(g.tool_ms),
+      fmtPct((g.cache_ratio ?? 0) * 100),
+      `${g.ws_delta}Δ/${g.ws_full}F`,
+      `${g.reused_connection}/${g.transport_rows}`,
+      shortId(g.session_id),
+    ]);
+  }
+  lines.push(...padTable(table));
+  lines.push('');
+}
+
+function renderCacheTransport(report, lines, opts) {
+  lines.push('Cache / transport');
+  lines.push(
+    `cache: ${fmtTok(report.cache.cached_tokens)} / ${fmtTok(report.cache.prompt_tokens)} (${fmtPct((report.cache.usage_cache_ratio ?? 0) * 100)})`
+  );
+  lines.push(
+    `ws: delta=${report.cache.ws_delta}, full=${report.cache.ws_full}, previous_response_id=${report.cache.previous_response_id}, reused=${report.cache.reused_connection}/${report.cache.transport_count}`
+  );
+  if (report.cache.cache_key_hashes.length)
+    lines.push(
+      `cache keys: ${report.cache.cache_key_hashes
+        .slice(0, 5)
+        .map((k) => `${k.key}×${k.count}`)
+        .join(', ')}`
+    );
+  if (report.cache.cache_breaks.length) {
+    lines.push(
+      `cache breaks (raw=${report.cache.cache_breaks.length}, actionable=${report.cache.actionable_cache_breaks.length}):`
+    );
+    for (const b of report.cache.cache_breaks.slice(0, 10)) {
+      lines.push(
+        `- ${shortId(b.session_id)} it=${b.iteration ?? '-'} ${b.actionable ? 'actionable' : `intentional:${b.intentional_transition}`} phase=${b.phase || '-'} reason=${b.reason || '-'} (${b.explanation || '-'}) ws=${b.ws_mode || '-'} tool_choice=${b.request_tool_choice ?? '-'} prev=${b.request_has_previous_response_id} cache=${fmtPct((b.cache_ratio ?? 0) * 100)} prompt=${fmtTok(b.prompt_tokens)} out=${fmtTok(b.output_tokens)} body/frame=${b.body_input_items ?? '-'}/${b.frame_input_items ?? '-'}`
+      );
+    }
+  }
+  if (report.cache.actual_cache_misses?.length) {
+    lines.push('actual cache misses:');
+    for (const m of report.cache.actual_cache_misses.slice(0, 10)) {
+      lines.push(
+        `- ${shortId(m.session_id)} it=${m.iteration ?? '-'} reason=${m.reason || '-'} ws=${m.ws_mode || '-'} prev=${m.request_has_previous_response_id} cache=${fmtPct((m.cache_ratio ?? 0) * 100)} prompt=${fmtTok(m.prompt_tokens)} uncached=${fmtTok(m.uncached_tokens)} prevMax=${fmtTok(m.previous_max_cached_tokens)}`
+      );
+    }
+  }
+  if (report.cache.service_tier_downgrades.length) {
+    lines.push('service tier downgrades:');
+    for (const d of report.cache.service_tier_downgrades.slice(0, 10))
+      lines.push(`- ${shortId(d.session_id)} it=${d.iteration ?? '-'} ${d.requested}->${d.response}`);
+  }
+  if (report.compact?.sessions?.length || report.compact?.recent_meta?.length) {
+    renderCompactDiagnostics(report, lines, opts);
+  }
+  lines.push('');
+}
+
+function renderPreflight(report, lines) {
+  const p = report.preflight;
+  const row = (label, s) => `${label}: p50=${fmtMs(s.p50)} p90=${fmtMs(s.p90)} max=${fmtMs(s.max)} (n=${s.n})`;
+  lines.push('Turn preflight (harness-owned, submit → provider request)');
+  lines.push(row('runtime ttft', p.runtime_ttft_ms));
+  lines.push(row('end-to-end ttft', p.end_to_end_ttft_ms));
+  lines.push(`${row('queue', p.queue_ms)}`);
+  lines.push(`${row('route', p.route_ms)}`);
+  lines.push(`${row('preflight', p.preflight_ms)}`);
+  lines.push(`${row('mcp grace', p.mcp_ms)}`);
+  lines.push(`status: ${p.statuses.map(([k, v]) => `${k}×${v}`).join(', ') || '-'}`);
+  lines.push('');
+}
+
+function renderSlowTurns(report, lines, opts) {
+  lines.push('Slow turns / stage breakdown');
+  const table = [['agent', 'it', 'active', 'headers', 'stream', 'tools', 'cache', 'ws', 'prompt', 'out', 'flags']];
+  for (const t of report.stages.slowest_active.slice(0, Math.min(opts.limit, 12))) {
+    table.push([
+      t.agent || '-',
+      t.turn_label || (t.iteration ?? '-'),
+      fmtMs(t.approx_active_ms),
+      fmtMs(t.headers_ms),
+      fmtMs(t.stream_ms),
+      `${fmtMs(t.tool_ms)}/${t.tool_calls}`,
+      fmtPct((t.cache_ratio ?? 0) * 100),
+      `${t.ws_mode || '-'}${t.reused_connection === true ? '+reuse' : ''}`,
+      fmtTok(t.prompt_tokens),
+      fmtTok(t.output_tokens),
+      t.flags.join(',') || '-',
+    ]);
+  }
+  lines.push(...padTable(table));
+  if (report.stages.slowest_tools.some((t) => t.tool_ms > 0)) {
+    lines.push('slow tool turns:');
+    for (const t of report.stages.slowest_tools.slice(0, 5)) {
+      const toolLabel = t.top_tools.map((x) => `${x.tool}×${x.count}/${fmtMs(x.ms)}`).join(', ') || '-';
+      lines.push(
+        `- ${t.agent || '-'} it=${t.turn_label || (t.iteration ?? '-')} tools=${fmtMs(t.tool_ms)} calls=${t.tool_calls}: ${toolLabel}`
+      );
+    }
+  }
+  lines.push('');
+}
+
+function renderTokenAmplification(report, lines, opts) {
+  lines.push('Token amplification');
+  const sessionTable = [
+    ['agent', 'turns', 'prompt first→last', 'max', 'Δprompt', 'out', 'uncached', 'cache', 'session'],
+  ];
+  for (const s of report.tokens.sessions.slice(0, Math.min(opts.limit, 8))) {
+    sessionTable.push([
+      s.agent || '-',
+      s.turns,
+      `${fmtTok(s.first_prompt)}→${fmtTok(s.last_prompt)}`,
+      `${fmtTok(s.max_prompt)}@${s.max_prompt_it}`,
+      fmtTok(s.prompt_growth),
+      fmtTok(s.total_output + s.total_thinking),
+      fmtTok(s.uncached_tokens),
+      fmtPct((s.cache_ratio ?? 0) * 100),
+      shortId(s.session_id),
+    ]);
+  }
+  lines.push(...padTable(sessionTable));
+  if (report.tokens.growth_turns.length) {
+    lines.push('prompt growth spikes:');
+    for (const t of report.tokens.growth_turns.slice(0, 8)) {
+      const growth = t.growth_per_output;
+      let ratio = '-';
+      if (growth != null) ratio = `${growth.toFixed(growth >= 10 ? 0 : 1)}x/out`;
+      lines.push(
+        `- ${t.agent || '-'} it=${t.turn_label} prompt=${fmtTok(t.prompt_tokens)} Δ=${fmtTok(t.prompt_delta)} out=${fmtTok(t.output_tokens + t.thinking_tokens)} ${ratio} cache=${fmtPct((t.cache_ratio ?? 0) * 100)}`
+      );
+    }
+  }
+  if (report.tokens.output_heavy_turns.length) {
+    lines.push('large output turns:');
+    for (const t of report.tokens.output_heavy_turns.slice(0, 5)) {
+      lines.push(
+        `- ${t.agent || '-'} it=${t.turn_label} out=${fmtTok(t.output_tokens)} think=${fmtTok(t.thinking_tokens)} prompt=${fmtTok(t.prompt_tokens)} cache=${fmtPct((t.cache_ratio ?? 0) * 100)}`
+      );
+    }
+  }
+  if (report.tokens.cache_miss_cost_turns.length) {
+    lines.push('uncached prompt cost:');
+    for (const t of report.tokens.cache_miss_cost_turns.slice(0, 5)) {
+      lines.push(
+        `- ${t.agent || '-'} it=${t.turn_label} uncached=${fmtTok(t.uncached_tokens)} prompt=${fmtTok(t.prompt_tokens)} cache=${fmtPct((t.cache_ratio ?? 0) * 100)}`
+      );
+    }
+  }
+  lines.push('');
+}
+
+function renderToolDiagnostics(report, lines, opts) {
+  lines.push('Tool diagnostics');
+  lines.push(`tool result kinds: ${fmtKindCounts(report.tools.result_kinds, 6)}`);
+  const table = [['tool', 'count', 'ok/err', 'total', 'p50', 'p95', 'kinds', 'result']];
+  for (const t of report.tools.by_name.slice(0, opts.limit)) {
+    table.push([
+      t.tool,
+      t.count,
+      `${t.ok}/${t.errors}`,
+      fmtMs(t.total_ms),
+      fmtMs(t.p50_ms),
+      fmtMs(t.p95_ms),
+      fmtKindCounts(t.result_kinds),
+      `${Math.round(t.bytes / 1024)}KB/${t.lines}l`,
+    ]);
+  }
+  lines.push(...padTable(table));
+  if (report.tools.failures.length) {
+    lines.push('tool failures:');
+    for (const f of report.tools.failures.slice(0, 10)) {
+      lines.push(
+        `- ${f.agent || '-'} it=${f.iteration ?? '-'} ${f.tool || '-'} ${fmtMs(f.tool_ms)} category=${f.category || '-'} reason=${f.reason || 'trace\uC5D0 \uC0C1\uC138 stderr/\uC608\uC678 \uBBF8\uC800\uC7A5'} result=${Math.round(f.bytes / 1024)}KB/${f.lines}l: ${f.target}`
+      );
+      if (opts.failuresOnly && f.preview) {
+        const preview = compactText(f.preview, 700);
+        lines.push(`  preview: ${preview}`);
+      }
+    }
+  }
+  if (report.tools.recent_successes.length) {
+    lines.push('recent successful tools:');
+    for (const s of report.tools.recent_successes.slice(0, 5)) {
+      lines.push(
+        `- ${s.agent || '-'} it=${s.iteration ?? '-'} ${s.tool || '-'} ${fmtMs(s.tool_ms)} kind=${s.result_kind}: ${s.target}`
+      );
+    }
+  }
+  if (report.tools.duplicates.length) {
+    lines.push('tool churn / duplicates:');
+    for (const d of report.tools.duplicates.slice(0, 10))
+      lines.push(`- ${d.tool} x${d.count} kinds=${fmtKindCounts(d.result_kinds)}: ${d.target}`);
+  }
+  if (report.tools.broad_results.length) {
+    lines.push('broad/offloaded results:');
+    for (const b of report.tools.broad_results.slice(0, 10))
+      lines.push(`- ${b.tool} ${Math.round(b.bytes / 1024)}KB/${b.lines}l: ${b.target}`);
+  }
+  if (report.tools.read_fragmentation.length) {
+    lines.push('read fragmentation:');
+    for (const f of report.tools.read_fragmentation.slice(0, 10))
+      lines.push(`- x${f.count} span=${f.line_span} lines: ${f.path}`);
+  }
+  if (report.tools.sequential_tool_clusters?.length) {
+    lines.push('sequential single-tool clusters:');
+    for (const c of report.tools.sequential_tool_clusters.slice(0, 8)) {
+      const toolSummary = c.tools.map((x) => `${x.tool}×${x.count}`).join(', ');
+      lines.push(
+        `- ${c.agent || '-'} it=${c.start_it ?? '-'}→${c.end_it ?? '-'} x${c.count} span=${fmtMs(c.span_ms)} tool_ms=${fmtMs(c.tool_ms)} errors=${c.errors}: ${toolSummary}`
+      );
+      if (c.examples?.length) lines.push(`  e.g. ${c.examples.join(' | ')}`);
+    }
+  }
+  if (report.tools.edit_fragmentation?.length) {
+    lines.push('edit fragmentation:');
+    for (const e of report.tools.edit_fragmentation.slice(0, 8)) {
+      lines.push(
+        `- ${e.agent || '-'} it=${e.start_it}→${e.end_it} score=${e.frag_score} multi=${e.multi_patch_turns} cross=${e.cross_turn_patch}`
+      );
+    }
+  }
+  lines.push(
+    `missed parallelism heuristic: ${report.tools.missed_parallelism_heuristic.consecutive_single_tool_batches} close single-tool batches`
+  );
+  lines.push(
+    `ordered patch→shell follow-ups: ${report.tools.ordered_followup_candidates?.patch_then_shell || 0} separate-turn pair(s)`
+  );
+  lines.push('');
+}
+
+function renderIssues(report, lines, opts) {
+  lines.push('Issues');
+  if (!report.issues.length) lines.push('- none detected by current heuristics');
+  for (const issue of report.issues.slice(0, opts.limit))
+    lines.push(`- [${issue.severity}] ${issue.type}: ${issue.message}`);
+}
+
+// Section gating follows the --*-only flags: a focused view renders its own
+// section (plus the header and issues), the default view renders everything.
+export function renderText(report, opts) {
+  const lines = [];
+  const focused = opts.failuresOnly || opts.compactOnly || opts.tokensOnly || opts.slowOnly;
+  renderHeader(report, lines);
+  if (
+    !opts.issuesOnly &&
+    !opts.cacheOnly &&
+    !opts.toolsOnly &&
+    !opts.compactOnly &&
+    !opts.tokensOnly &&
+    !opts.failuresOnly
+  ) {
+    renderExecutiveSummary(report, lines, opts);
+  }
+  if (opts.compactOnly) {
+    renderCompactDiagnostics(report, lines, opts);
+    return lines.join('\n');
+  }
+  const wide = !focused && !opts.toolsOnly && !opts.issuesOnly;
+  if (wide) renderRouteTimeline(report, lines);
+  if (wide) renderCacheTransport(report, lines, opts);
+  if (wide && report.preflight?.turns) renderPreflight(report, lines);
+  if (
+    (opts.slowOnly || !focused) &&
+    !opts.cacheOnly &&
+    !opts.toolsOnly &&
+    !opts.issuesOnly &&
+    !opts.failuresOnly &&
+    !opts.tokensOnly
+  ) {
+    renderSlowTurns(report, lines, opts);
+  }
+  if (
+    (opts.tokensOnly || !focused) &&
+    !opts.cacheOnly &&
+    !opts.toolsOnly &&
+    !opts.issuesOnly &&
+    !opts.failuresOnly &&
+    !opts.slowOnly
+  ) {
+    renderTokenAmplification(report, lines, opts);
+  }
+  if (
+    (opts.toolsOnly || opts.failuresOnly || !focused) &&
+    !opts.cacheOnly &&
+    !opts.issuesOnly &&
+    !opts.tokensOnly &&
+    !opts.slowOnly
+  ) {
+    renderToolDiagnostics(report, lines, opts);
+  }
+  if (!opts.cacheOnly && !opts.toolsOnly) renderIssues(report, lines, opts);
+  return lines.join('\n');
+}

package/scripts/lib/smoke-loop-shared.mjs

@@ -0,0 +1,28 @@
+// Duration parsing and min/max/avg summaries shared by smoke-loop (the runner)
+// and smoke-loop-report (its reader).
+import { DURATION_UNIT_MS } from './parse-since.mjs';
+
+// `90000`, `500ms`, `30s`, `5m`, `2h` → milliseconds. Empty → fallback.
+export function parseDuration(value, fallback = null) {
+  const raw = String(value || '').trim();
+  if (!raw) return fallback;
+  if (/^\d+$/.test(raw)) return Number(raw);
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/i);
+  if (!match) throw new Error(`invalid duration: ${raw}`);
+  const n = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  const mult = DURATION_UNIT_MS[unit];
+  return Math.max(1, Math.floor(n * mult));
+}
+
+export function summarize(values) {
+  if (!values.length) return { min: 0, max: 0, avg: 0 };
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const avg = values.reduce((sum, value) => sum + value, 0) / values.length;
+  return {
+    min: Math.round(min * 10) / 10,
+    max: Math.round(max * 10) / 10,
+    avg: Math.round(avg * 10) / 10,
+  };
+}

package/scripts/lib/smoke-loop-shared.test.mjs

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { parseDuration, summarize } from './smoke-loop-shared.mjs';
+
+test('parseDuration reads bare milliseconds and unit suffixes', () => {
+  assert.equal(parseDuration('1500'), 1500);
+  assert.equal(parseDuration('30s'), 30_000);
+  assert.equal(parseDuration('5M'), 300_000);
+  assert.equal(parseDuration('1.5h'), 5_400_000);
+  assert.equal(parseDuration('0ms'), 1);
+});
+
+test('parseDuration returns the fallback when empty and throws on garbage', () => {
+  assert.equal(parseDuration('', 7), 7);
+  assert.equal(parseDuration(undefined), null);
+  assert.throws(() => parseDuration('soon'), /invalid duration: soon/);
+});
+
+test('summarize rounds min/max/avg to one decimal, zeros when empty', () => {
+  assert.deepEqual(summarize([]), { min: 0, max: 0, avg: 0 });
+  assert.deepEqual(summarize([1.04, 2.06, 3.31]), { min: 1, max: 3.3, avg: 2.1 });
+});

package/scripts/lib/trace-row.mjs

@@ -0,0 +1,40 @@
+// Accessors for agent-trace JSONL rows, shared by the trace CLIs (session-bench,
+// session-diag, llm-trace-summary, routing-corpus, internal-comms-bench). A
+// field lives either on the row itself or inside its `payload` object.
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+
+// The trace files a CLI reads, rotated file first: an explicit --path, else the
+// history dir of --data-dir, else the current project's and the user's data dir.
+export function defaultTraceFiles({ pathArg = null, dataDir = null } = {}) {
+  if (pathArg) return [resolve(pathArg)];
+  const mixdogHome = process.env.MIXDOG_HOME || resolve(homedir(), '.mixdog');
+  const mixdogDataDir = process.env.MIXDOG_DATA_DIR || resolve(mixdogHome, 'data');
+  const dirs = dataDir ? [resolve(dataDir)] : [resolve(process.cwd(), '.mixdog', 'data'), mixdogDataDir];
+  const files = dirs.flatMap((dir) => [
+    resolve(dir, 'history', 'agent-trace.jsonl.1'),
+    resolve(dir, 'history', 'agent-trace.jsonl'),
+  ]);
+  return [...new Set(files)];
+}
+
+export function payload(row) {
+  return row?.payload && typeof row.payload === 'object' ? row.payload : {};
+}
+
+export function field(row, name) {
+  if (row && row[name] != null) return row[name];
+  const p = payload(row);
+  return p[name] != null ? p[name] : null;
+}
+
+// The field coerced with Number(): null when the result is not finite. A
+// missing field is Number(null) === 0, so it reads as 0 rather than null.
+export function num(row, name) {
+  const n = Number(field(row, name));
+  return Number.isFinite(n) ? n : null;
+}
+
+export function sessionId(row) {
+  return String(row?.session_id || row?.sessionId || field(row, 'session_id') || '');
+}

package/scripts/lib/trace-row.test.mjs

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { resolve } from 'node:path';
+import { defaultTraceFiles, field, num, payload, sessionId } from './trace-row.mjs';
+
+test('defaultTraceFiles: an explicit path wins, a data dir yields its rotated pair', () => {
+  assert.deepEqual(defaultTraceFiles({ pathArg: 'x.jsonl' }), [resolve('x.jsonl')]);
+  assert.deepEqual(defaultTraceFiles({ dataDir: 'd' }), [
+    resolve('d', 'history', 'agent-trace.jsonl.1'),
+    resolve('d', 'history', 'agent-trace.jsonl'),
+  ]);
+});
+
+test('defaultTraceFiles without arguments covers the project and user data dirs, deduplicated', () => {
+  const files = defaultTraceFiles();
+  assert.equal(files.length, new Set(files).size);
+  assert.ok(files.includes(resolve(process.cwd(), '.mixdog', 'data', 'history', 'agent-trace.jsonl')));
+});
+
+test('payload is the row payload object, else an empty object', () => {
+  assert.deepEqual(payload({ payload: { a: 1 } }), { a: 1 });
+  assert.deepEqual(payload({ payload: 'text' }), {});
+  assert.deepEqual(payload(null), {});
+});
+
+test('field prefers the row itself, falls back to the payload, else null', () => {
+  assert.equal(field({ a: 1, payload: { a: 2 } }, 'a'), 1);
+  assert.equal(field({ payload: { a: 2 } }, 'a'), 2);
+  assert.equal(field({ a: null, payload: { a: 3 } }, 'a'), 3);
+  assert.equal(field({}, 'a'), null);
+  assert.equal(field(undefined, 'a'), null);
+});
+
+test('num coerces the field and drops non-finite values', () => {
+  assert.equal(num({ payload: { n: '12' } }, 'n'), 12);
+  assert.equal(num({ n: 'x' }, 'n'), null);
+  // A missing field reads as Number(null) === 0, not null (existing behavior
+  // of every trace CLI that used its own copy).
+  assert.equal(num({}, 'n'), 0);
+});
+
+test('sessionId reads either spelling, then the payload, as a string', () => {
+  assert.equal(sessionId({ session_id: 's1' }), 's1');
+  assert.equal(sessionId({ sessionId: 's2' }), 's2');
+  assert.equal(sessionId({ payload: { session_id: 's3' } }), 's3');
+  assert.equal(sessionId({}), '');
+});

package/scripts/lib/trace-stats.mjs

@@ -22,6 +22,13 @@ export function sortedFinite(values) {
   return values.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
 }
 
+// p50/p95 of the samples after Number() coercion; null percentiles when none
+// is finite.
+export function distribution(values) {
+  const sorted = sortedFinite(values.map(Number));
+  return { p50: percentile(sorted, 50), p95: percentile(sorted, 95) };
+}
+
 export function stats(nums) {
   const arr = sortedFinite(nums);
   if (arr.length === 0) return null;

package/scripts/lib/trace-stats.test.mjs

@@ -1,6 +1,12 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { median, percentile, sortedFinite, stats } from './trace-stats.mjs';
+import { distribution, median, percentile, sortedFinite, stats } from './trace-stats.mjs';
+
+test('distribution coerces samples with Number() and reports nearest-rank p50/p95', () => {
+  assert.deepEqual(distribution(['10', 20, '30', 40]), { p50: 20, p95: 40 });
+  assert.deepEqual(distribution([]), { p50: null, p95: null });
+  assert.deepEqual(distribution([undefined, 'x']), { p50: null, p95: null });
+});
 
 test('percentile picks the nearest rank of an ascending sample', () => {
   const sorted = [10, 20, 30, 40];

package/scripts/llm-trace-summary.mjs

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
 import { parseSince } from './lib/parse-since.mjs';
 import { argValue, intArg } from './lib/cli-args.mjs';
 import { stats } from './lib/trace-stats.mjs';
+import { defaultTraceFiles, field, num as numberField, payload } from './lib/trace-row.mjs';
 
 const pathArg = argValue('--path', null);
 const dataDir = argValue('--data-dir', null);
@@ -15,32 +14,6 @@ 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'),
-    ])
-  );
-}
-
 function readRows(file) {
   if (!existsSync(file)) return [];
   return readFileSync(file, 'utf8')
@@ -55,21 +28,6 @@ function readRows(file) {
     });
 }
 
-function payload(row) {
-  return 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) {
@@ -133,7 +91,7 @@ function printCounts(label, obj, max = 12) {
   console.log(`${label}: ${parts.join(', ') || '(none)'}`);
 }
 
-const files = defaultTraceFiles();
+const files = defaultTraceFiles({ pathArg, dataDir });
 const sinceTs = parseSince(sinceArg);
 const allRows = files
   .flatMap(readRows)

package/scripts/memory-chunk-quality.mjs

@@ -80,7 +80,7 @@ function assertCoverage(projection, expectedRows) {
 }
 if (simulationLimit) {
   const { callAgentDispatch } = await import('../src/runtime/memory/lib/agent-ipc.mjs');
-  const { resolveMaintenancePreset } = await import('../src/runtime/shared/llm/index.mjs');
+  const { resolveMaintenancePreset } = await import('../src/runtime/agent/orchestrator/maintenance-preset.mjs');
   const options = {
     callLlm: callAgentDispatch,
     request: {

package/scripts/memory-layer2-check.mjs

@@ -15,7 +15,7 @@ import { loadConfig } from '../src/runtime/agent/orchestrator/config.mjs';
 import { resolveMaintenanceRoute } from '../src/runtime/agent/orchestrator/agent-runtime/maintenance-route.mjs';
 import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
 import { loadScopedRoleInstructions } from '../src/runtime/agent/orchestrator/context/collect.mjs';
-import { resolveMaintenancePreset } from '../src/runtime/shared/llm/index.mjs';
+import { resolveMaintenancePreset } from '../src/runtime/agent/orchestrator/maintenance-preset.mjs';
 
 const { values } = parseArgs({
   options: {

package/scripts/pg-memory-diet.mjs

@@ -252,7 +252,7 @@ async function prepare(dataDir, runtimeDir, sourcePort) {
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  if (process.argv[2] !== 'prepare' || !process.argv[3] || !process.argv[4]) {
+  if (process.argv[2] !== 'prepare' || !process.argv[3] || !process.argv[4] || !process.argv[5]) {
     throw new Error('Usage: node scripts/pg-memory-diet.mjs prepare <data-dir> <runtime-dir> <source-port>');
   }
   await prepare(resolve(process.argv[3]), resolve(process.argv[4]), Number(process.argv[5]));