mixdog 0.9.1 → 0.9.3

package/scripts/compact-trigger-migration-smoke.mjs

@@ -7,10 +7,16 @@ import {
   _compactTriggerForSession as compactTriggerForSession,
   _preserveBufferConfigFields as preserveBufferConfigFields,
 } from '../src/runtime/agent/orchestrator/session/manager.mjs';
-import { _autoCompactTokenLimit as routeMetaAutoCompactTokenLimit } from '../src/vendor/statusline/src/gateway/route-meta.mjs';
+import {
+  _autoCompactTokenLimit as routeMetaAutoCompactTokenLimit,
+  autoCompactWindowForRoute,
+  compactBoundaryDenominator,
+  summarizeGatewayUsage,
+} from '../src/vendor/statusline/src/gateway/route-meta.mjs';
 import {
   _routeContextMeta as routeContextMeta,
   _resolveStatusAutoCompactTokenLimit as resolveStatusAutoCompactTokenLimit,
+  compactBoundaryForStatus,
 } from '../src/vendor/statusline/bin/statusline-route.mjs';
 
 function assert(condition, message) {
@@ -184,4 +190,64 @@ function assert(condition, message) {
     `status: configured explicit limit should surface, got ${configuredExplicit}`);
 }
 
+// 10) Boundary / window denominators ignore autoCompactTokenLimit (trigger-only).
+{
+  const boundary = 200000;
+  const trigger = 150000;
+  const route = {
+    contextWindow: boundary,
+    compactBoundaryTokens: boundary,
+    rawContextWindow: boundary,
+    autoCompactTokenLimit: trigger,
+  };
+  assert(compactBoundaryForStatus(route) === boundary,
+    `status boundary should be ${boundary}, got ${compactBoundaryForStatus(route)}`);
+  assert(compactBoundaryForStatus({ contextWindow: boundary, autoCompactTokenLimit: trigger }) === boundary,
+    `status boundary should use contextWindow ${boundary}, got ${compactBoundaryForStatus({ contextWindow: boundary, autoCompactTokenLimit: trigger })}`);
+  assert(autoCompactWindowForRoute({ contextWindow: boundary, autoCompactTokenLimit: trigger }) === boundary,
+    `route compact window should be ${boundary}, got ${autoCompactWindowForRoute({ contextWindow: boundary, autoCompactTokenLimit: trigger })}`);
+  const trig = compactTriggerForSession({ autoCompactTokenLimit: trigger, compaction: {} }, boundary);
+  assert(trig === trigger, `trigger resolver should stay ${trigger}, got ${trig}`);
+}
+
+// 11) Boundary fallback order and compact boundary fields.
+{
+  const context = 200000;
+  const smallerBudget = 150000;
+  assert(
+    compactBoundaryForStatus({ contextWindow: context }, { budgetWindow: smallerBudget, compactLimitTokens: smallerBudget }) === context,
+    `contextWindow ${context} must win over smaller budgetWindow ${smallerBudget}`,
+  );
+  assert(
+    compactBoundaryDenominator({ contextWindow: context }, { budgetWindow: smallerBudget }) === context,
+    `route denominator: contextWindow must win over budgetWindow`,
+  );
+  assert(
+    compactBoundaryForStatus({ contextWindow: context }, { boundaryTokens: 180000 }) === 180000,
+    'compact.boundaryTokens should be honored',
+  );
+  assert(
+    compactBoundaryForStatus({ contextWindow: context }, { compactBoundaryTokens: 190000 }) === 190000,
+    'compact.compactBoundaryTokens should be honored',
+  );
+  assert(
+    compactBoundaryForStatus({ boundaryTokens: 175000, contextWindow: context }, { budgetWindow: smallerBudget }) === 175000,
+    'routeInfo.boundaryTokens should be honored',
+  );
+  const withLimitOnly = compactBoundaryForStatus(
+    { contextWindow: context, autoCompactTokenLimit: smallerBudget },
+    { compactLimitTokens: smallerBudget, budgetWindow: smallerBudget },
+  );
+  assert(withLimitOnly === context,
+    `compactLimitTokens/budget must not shrink boundary; expected ${context}, got ${withLimitOnly}`);
+  const usage = summarizeGatewayUsage(
+    { provider: 'openai-oauth', model: 'gpt-5.5', contextWindow: context },
+    { usage: { inputTokens: 1, outputTokens: 1 } },
+    { boundaryTokens: 180000, budgetWindow: smallerBudget, compactLimitTokens: smallerBudget, afterTokens: 90000 },
+    1,
+  );
+  assert(usage.contextUsedPct === 50,
+    `gateway usage pct should use compact.boundaryTokens denominator 180000; got ${usage.contextUsedPct}`);
+}
+
 process.stdout.write('compact-trigger-migration smoke passed ✓\n');

package/scripts/explore-bench.mjs

@@ -0,0 +1,124 @@
+// Explore quality bench — round-based tuning harness.
+//
+// Runs a fixed query set through runExplore against this repo, then reads
+// agent-trace.jsonl to report per-session tool-call counts, wall time, and
+// anchor quality. Usage:
+//   node scripts/explore-bench.mjs [roundLabel]
+// Fresh process per run = no in-memory result cache carryover.
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { runExplore } from '../src/standalone/explore-tool.mjs';
+
+const ROUND = process.argv[2] || 'r0';
+const CWD = 'C:/Project/mixdog';
+
+// Representative locator queries with ground truth: expect = substrings, at
+// least one must appear in the anchor output (quality hit). expectFail = the
+// correct answer is EXPLORATION_FAILED (miss discipline).
+const QUERIES = [
+  {
+    q: 'where is the tool-call stall watchdog policy resolved and what defaults does it use',
+    expect: ['agent-progress-watchdog', 'stall-policy'],
+  },
+  {
+    q: 'session compact / smart compact trigger threshold logic',
+    expect: ['compact'],
+  },
+  {
+    q: 'where are hidden agent tool schema profiles defined (read / read-write-search)',
+    expect: ['agent-dispatch', 'agents.json', 'internal-agents'],
+  },
+  {
+    q: 'recall memory chunk importance scoring implementation',
+    expect: ['importance', 'memory'],
+  },
+  {
+    q: 'websocket reconnect backoff handling',
+    expect: ['openai-oauth-ws', 'retry-classifier'],
+  },
+  // ── extended set: symbol-exact, filename, error-string, korean, flow, config ──
+  {
+    q: 'buildExplorerPrompt definition', // exact known symbol
+    expect: ['explore-tool'],
+  },
+  {
+    q: 'where does the explore tool cache results and what is the TTL',
+    expect: ['explore-tool'],
+  },
+  {
+    q: 'error text "maintenance route unresolved for agent" — where is it thrown',
+    expect: ['agent-dispatch'],
+  },
+  {
+    q: '에이전트 세션의 최대 루프 반복 횟수는 어디서 정해져?', // korean concept query
+    expect: ['agent-loop-policy'],
+  },
+  {
+    q: 'how does a fixed agent slot map to a workflow slot (explore/explorer)',
+    expect: ['mixdog-session-runtime', 'internal-agents'],
+  },
+  {
+    q: 'where is the mixdog config json file path resolved (data dir)',
+    expect: ['config', 'plugin-paths'],
+  },
+  {
+    q: 'GraphQL schema stitching resolver implementation', // not in this repo
+    expectFail: true,
+  },
+];
+
+function tracePath() {
+  return process.env.MIXDOG_AGENT_TRACE_PATH
+    || join(process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'), 'history', 'agent-trace.jsonl');
+}
+
+function readTraceSince(ts) {
+  const p = tracePath();
+  if (!existsSync(p)) return [];
+  const rows = [];
+  for (const line of readFileSync(p, 'utf8').split('\n')) {
+    if (!line) continue;
+    try {
+      const r = JSON.parse(line);
+      if (r.ts >= ts && r.agent === 'explorer') rows.push(r);
+    } catch { /* skip */ }
+  }
+  return rows;
+}
+
+const t0 = Date.now();
+const results = [];
+for (const { q, expect, expectFail } of QUERIES) {
+  const qt0 = Date.now();
+  const res = await runExplore({ query: q, cwd: CWD }, { callerCwd: CWD });
+  const text = res?.content?.[0]?.text || '';
+  const anchors = text.split('\n').filter((l) => /:\d+/.test(l)).length;
+  const failed = /EXPLORATION_FAILED/.test(text);
+  const lower = text.toLowerCase();
+  const hit = expectFail
+    ? (failed && anchors === 0)
+    : (!failed && (expect || []).some((e) => lower.includes(e.toLowerCase())));
+  results.push({ q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, bytes: text.length });
+}
+
+// Attribute tool calls per explorer session spawned during this run.
+const rows = readTraceSince(t0);
+const bySession = new Map();
+for (const r of rows) {
+  if (r.kind !== 'tool') continue;
+  const s = bySession.get(r.session_id) || { calls: 0, tools: [] };
+  s.calls++; s.tools.push(r.tool_name);
+  bySession.set(r.session_id, s);
+}
+const callCounts = [...bySession.values()].map((s) => s.calls).sort((a, b) => a - b);
+const p50 = callCounts[Math.floor(callCounts.length / 2)] ?? 0;
+
+console.log(`\n=== explore-bench round=${ROUND} ===`);
+for (const r of results) {
+  console.log(`  [${String(r.ms).padStart(6)}ms] ${r.hit ? 'HIT ' : 'MISS'} anchors=${r.anchors} failed=${r.failed} bytes=${r.bytes}  ${r.q}`);
+}
+console.log(`  quality: ${results.filter((r) => r.hit).length}/${results.length} hits`);
+console.log(`  sessions=${bySession.size} toolcalls p50=${p50} max=${callCounts[callCounts.length - 1] ?? 0} total=${callCounts.reduce((a, b) => a + b, 0)}`);
+for (const [id, s] of bySession) console.log(`    ${id.slice(-8)}: ${s.tools.join(',')}`);
+console.log(`  wall total=${((Date.now() - t0) / 1000).toFixed(1)}s`);

package/scripts/hook-bus-test.mjs

@@ -328,3 +328,194 @@ console.log(JSON.stringify({ hookSpecificOutput: {
     else process.env.MIXDOG_HOOKS_FILE = prev;
   }
 });
+
+test('mcp_tool handler routes output through parseHandlerOutput', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [{ type: 'mcp_tool', server: 'guard', tool: 'check' }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    let seenName = null;
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      mcpToolRunner: async ({ name }) => {
+        seenName = name;
+        return JSON.stringify({ hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: 'mcp denied',
+        }});
+      },
+    });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(seenName, 'mcp__guard__check');
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /mcp denied/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler ok:false maps to deny', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [{ type: 'prompt', prompt: 'is this safe?' }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: async () => JSON.stringify({ ok: false, reason: 'unsafe' }),
+    });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /unsafe/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('unconfigured prompt/mcp_tool and unsupported agent emit hook:error and skip', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [
+          { type: 'prompt', prompt: 'x' },
+          { type: 'mcp_tool', server: 'g', tool: 't' },
+          { type: 'agent', agent: 'a' },
+        ],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root });
+    const result = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(result, null);
+    const errs = bus.status().recent.filter((e) => e.name === 'hook:error');
+    assert.ok(errs.some((e) => /prompt not configured/.test(e.payload?.error || '')));
+    assert.ok(errs.some((e) => /mcp_tool not configured/.test(e.payload?.error || '')));
+    assert.ok(errs.some((e) => /unsupported hook type: agent/.test(e.payload?.error || '')));
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('setRewakeHandler fires on async child exit code 2', async () => {
+  const root = tempRoot();
+  const hookScript = join(root, 'rewake.mjs');
+  writeFileSync(hookScript, `process.stderr.write('needs rewake'); process.exit(2);`, 'utf8');
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      Stop: [{
+        hooks: [{ type: 'command', command: process.execPath, args: [hookScript], asyncRewake: true }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root });
+    const fired = new Promise((resolve) => bus.setRewakeHandler((info) => resolve(info)));
+    await bus.dispatch('Stop', { session_id: 's', cwd: root });
+    const info = await fired;
+    assert.equal(info.eventName, 'Stop');
+    assert.match(info.text, /needs rewake/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler plain-text "no" denies', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{ matcher: 'shell', hooks: [{ type: 'prompt', prompt: 'safe?' }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root, promptRunner: async () => 'no' });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /no/i);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler timeout does not hang and reports error', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{ matcher: 'shell', hooks: [{ type: 'prompt', prompt: 'x', timeout: 0.05 }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: () => new Promise(() => {}),
+    });
+    const result = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(result, null);
+    const errs = bus.status().recent.filter((e) => e.name === 'hook:error');
+    assert.ok(errs.some((e) => /timed out/i.test(e.payload?.error || '')));
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt deny uses universal exit-2 path on Stop event', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      Stop: [{ hooks: [{ type: 'prompt', prompt: 'done?' }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: async () => JSON.stringify({ ok: false, reason: 'not done' }),
+    });
+    const result = await bus.dispatch('Stop', { session_id: 's', cwd: root });
+    assert.equal(result.blocked, true);
+    assert.match(result.reason, /not done/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});

package/scripts/ingest-pure-conversation-smoke.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module'
+import {
+  normalizeIngestRole,
+  sessionMessageContent,
+  sessionMessageContentForIngest,
+  shouldExcludeIngestMessage,
+} from '../src/runtime/memory/lib/session-ingest.mjs'
+
+// cleanMemoryText is the SAME downstream cleaner the real ingest loop applies
+// (memory/index.mjs:795). text-utils.cjs is a dependency-free CJS module, so we
+// require it directly to mirror the pipeline without booting the MCP server.
+const require = createRequire(import.meta.url)
+const { cleanMemoryText } = require('../src/lib/text-utils.cjs')
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message)
+}
+
+// Mirror memory/index.mjs ingestSessionMessages row handling for one message:
+//   role gate → exclusion predicate → ingest shaper → cleanMemoryText → trim.
+// Returns the persisted content string, or null when the row is NOT ingested.
+function ingestRow(m) {
+  const role = normalizeIngestRole(m.role)
+  if (!role) return null
+  if (shouldExcludeIngestMessage(m)) return null
+  const content = cleanMemoryText(sessionMessageContentForIngest(m))
+  if (!content || !content.trim()) return null
+  return content
+}
+
+const SUMMARY_PREFIX = 'A previous model worked on this task and produced the compacted handoff summary below. Build on the work already done and avoid duplicating it; treat the summary as authoritative context for continuing the task. You also retain the preserved recent turns that follow.'
+
+// ── Synthetic session.messages covering every audited case ──────────────────
+// (i) assistant prose + an `agent` toolCall (tool-call trace must be stripped).
+const asstWithTool = {
+  role: 'assistant',
+  content: 'Here is my plan for the refactor.',
+  toolCalls: [{ id: 'call_42', name: 'agent', arguments: '{"type":"send","text":"go"}' }],
+}
+// (ii) the real human turn carrying the full manager-style prefix envelope.
+const sessionBlock = '# Session\nCwd: C:/Project/mixdog\nModel: GPT-5 · HIGH'
+const prefixedUser = {
+  role: 'user',
+  content:
+    `${sessionBlock}\n\n` +
+    '# Additional context\nsome context body line one\nline two\n\n' +
+    '# Prefetch\nprefetched file snippet\n\n' +
+    '# Task\n실제 질문',
+}
+// (iii) Reference files synthetic row.
+const referenceRow = { role: 'user', content: 'Reference files:\n- a.mjs\n- b.mjs' }
+// (iv) compaction summary row.
+const summaryRow = { role: 'user', content: `${SUMMARY_PREFIX}\nmessages=10 sha256=abcd roles=user:5` }
+// (v) protected-context `.` ack assistant row.
+const ackRow = { role: 'assistant', content: '.' }
+// (vi) internal runtime nudge user row.
+const nudgeRow = { role: 'user', content: '[mixdog-runtime] Your previous response was empty. Continue.' }
+// (vii) normal human + normal assistant.
+const normalUser = { role: 'user', content: '안녕' }
+const normalAsst = { role: 'assistant', content: '네 안녕하세요' }
+
+const before = {
+  asstWithTool: sessionMessageContent(asstWithTool),
+  prefixedUser: prefixedUser.content,
+  referenceRow: referenceRow.content,
+  summaryRow: summaryRow.content,
+  ackRow: ackRow.content,
+  nudgeRow: nudgeRow.content,
+  normalUser: normalUser.content,
+  normalAsst: normalAsst.content,
+}
+
+const after = {
+  asstWithTool: ingestRow(asstWithTool),
+  prefixedUser: ingestRow(prefixedUser),
+  referenceRow: ingestRow(referenceRow),
+  summaryRow: ingestRow(summaryRow),
+  ackRow: ingestRow(ackRow),
+  nudgeRow: ingestRow(nudgeRow),
+  normalUser: ingestRow(normalUser),
+  normalAsst: ingestRow(normalAsst),
+}
+
+// (i) tool-call trace gone, prose kept.
+assert(before.asstWithTool.includes('[tool_call agent'), 'precondition: structured shaper inlines the tool_call trace')
+assert(after.asstWithTool && !after.asstWithTool.includes('[tool_call'), 'ingest must strip the tool_call trace')
+assert(after.asstWithTool.includes('Here is my plan for the refactor.'), 'assistant prose must survive')
+
+// (ii) prefixed user collapses to exactly the human prompt.
+assert(after.prefixedUser === '실제 질문', `prefixed user must shape to "실제 질문" (got: ${JSON.stringify(after.prefixedUser)})`)
+assert(!/# Session|Cwd:|Model:|Additional context|Prefetch|# Task/.test(after.prefixedUser), 'no prefix residue may remain')
+
+// (iii)-(vi) synthetic rows excluded.
+assert(after.referenceRow === null, 'Reference files row must be excluded')
+assert(after.summaryRow === null, 'SUMMARY_PREFIX row must be excluded')
+assert(after.ackRow === null, '`.` ack row must be excluded')
+assert(after.nudgeRow === null, '[mixdog-runtime] nudge row must be excluded')
+
+// (vii) normal conversation survives intact.
+assert(after.normalUser === '안녕', 'normal human text must survive intact')
+assert(after.normalAsst === '네 안녕하세요', 'normal assistant text must survive intact')
+
+// Zero-loss guard: a human message that merely MENTIONS the markers mid-text is
+// NOT stripped (anchors only fire on the leading manager-produced prefix).
+const humanMentionsMarkers = { role: 'user', content: 'please write a # Task section and a # Prefetch note' }
+assert(ingestRow(humanMentionsMarkers) === 'please write a # Task section and a # Prefetch note', 'mid-text markers must not be stripped')
+
+// ── Edge: field-anchored `# Session` strip (zero-loss for human docs) ────────
+// A human doc that legitimately STARTS with a `# Session` heading followed by
+// free prose must NOT be wiped. The strip is field-anchored to the EXACT shape
+// buildSessionStartBlock emits (`# Session` then only Cwd/Model/Workflow lines).
+// Assert on the SHAPER directly so the check isolates the strip rule from
+// cleanMemoryText's normal markdown-header cleaning.
+const humanSessionDoc = { role: 'user', content: '# Session\n프로젝트 회의록입니다\n다음 안건' }
+assert(
+  sessionMessageContentForIngest(humanSessionDoc) === '# Session\n프로젝트 회의록입니다\n다음 안건',
+  'human doc starting with `# Session` heading must be preserved verbatim (not wiped)',
+)
+// And through the full ingest row it must still carry the human words (the lone
+// `# ` heading marker is stripped by normal markdown cleaning — not data loss).
+assert(/프로젝트 회의록입니다/.test(ingestRow(humanSessionDoc) || ''), 'human session-doc words must survive ingest')
+
+// Injected real session block (Cwd/Model) still strips to the human prompt.
+const injectedCwdModel = { role: 'user', content: '# Session\nCwd: /x\nModel: Y\n\n실제질문' }
+assert(sessionMessageContentForIngest(injectedCwdModel) === '실제질문', 'injected Cwd/Model session block must strip to the human prompt')
+
+// Injected real session block incl. Workflow line still strips.
+const injectedWorkflow = { role: 'user', content: '# Session\nCwd: /x\nModel: Y\nWorkflow: Default\n\nq' }
+assert(sessionMessageContentForIngest(injectedWorkflow) === 'q', 'injected Cwd/Model/Workflow session block must strip to the human prompt')
+
+const rows = [
+  ['(i) assistant + agent toolCall', before.asstWithTool, after.asstWithTool],
+  ['(ii) prefixed human turn', before.prefixedUser, after.prefixedUser],
+  ['(iii) Reference files', before.referenceRow, after.referenceRow],
+  ['(iv) SUMMARY_PREFIX', before.summaryRow, after.summaryRow],
+  ['(v) `.` ack', before.ackRow, after.ackRow],
+  ['(vi) [mixdog-runtime] nudge', before.nudgeRow, after.nudgeRow],
+  ['(vii) normal human', before.normalUser, after.normalUser],
+  ['(vii) normal assistant', before.normalAsst, after.normalAsst],
+]
+process.stdout.write('before/after (EXCLUDED = row not ingested):\n')
+for (const [label, b, a] of rows) {
+  process.stdout.write(`  ${label}\n`)
+  process.stdout.write(`    before: ${JSON.stringify(b)}\n`)
+  process.stdout.write(`    after : ${a === null ? 'EXCLUDED' : JSON.stringify(a)}\n`)
+}
+process.stdout.write('\ningest pure-conversation smoke passed \u2713\n')