mixdog 0.9.18 → 0.9.20

package/scripts/output-style-smoke.mjs

@@ -97,7 +97,7 @@ try {
 
   mkdirSync(join(dataDir, 'output-styles'), { recursive: true });
   writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({
-    agent: { profile: { title: '재영님', language: 'system' } },
+    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');
@@ -105,7 +105,7 @@ try {
   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 "재영님" when directly addressing the user'), 'profile title must inject into Lead BP3 meta');
+  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('pre-tool preambles (even single-line)'), 'profile language must cover pre-tool preambles');

package/scripts/reactive-compact-persist-smoke.mjs

@@ -102,23 +102,39 @@ try {
   thrownCode = err?.code || null;
 }
 
+// Non-agent sessions hard-lock to recall-fasttrack (7/3 commit). This smoke has
+// no memory subsystem registered, so ingest_session + search both fail — the
+// exact "memory pipeline broken" condition the fail-safe must cover. Assert the
+// fail-safe: recall-fasttrack aborts rather than dropping head behind a false
+// "Full history is in memory" notice, so no context is silently lost and the
+// overflow is surfaced instead of being masked by an empty summary shell.
 assert(threw, 'askSession should surface overflow error');
 assert(thrownCode === 'AGENT_CONTEXT_OVERFLOW', `expected AGENT_CONTEXT_OVERFLOW, got ${thrownCode}`);
-assert(mainSendCount === 2, `expected 2 main sends after reactive retry, got ${mainSendCount}`);
-assert(compactSendCount === 1, `expected 1 compact send, got ${compactSendCount}`);
+// Recall-fasttrack aborted (memory failed), so the reactive retry never produced
+// a smaller transcript to re-send: exactly one failing main send, no LLM compact.
+assert(mainSendCount === 1, `expected 1 main send (reactive retry aborted by fail-safe), got ${mainSendCount}`);
+assert(compactSendCount === 0, `expected 0 compact sends on recall-fasttrack path, got ${compactSendCount}`);
 
 const reloaded = loadSession(sessionId);
 assert(reloaded, 'session should reload from store after overflow');
-assert((reloaded.messages || []).length < beforeCount + 1, 'persisted transcript should reflect compaction shrink');
+// Fail-safe keeps full history for the cycle: current turn appended, nothing dropped.
+assert(
+  (reloaded.messages || []).length === beforeCount + 1,
+  `full history should be preserved on fail-safe abort (expected ${beforeCount + 1}, got ${(reloaded.messages || []).length})`,
+);
 const summary = (reloaded.messages || []).find(
   (m) => m?.role === 'user' && typeof m.content === 'string' && m.content.startsWith(SUMMARY_PREFIX),
 );
-assert(summary, 'compacted transcript with SUMMARY_PREFIX should persist after overflow error');
+assert(!summary, 'no empty summary shell should be injected when the memory pipeline fails');
+assert(
+  !(reloaded.messages || []).some((m) => typeof m?.content === 'string' && m.content.includes('Full history is in memory')),
+  'no false "Full history is in memory" recall notice should be injected on fail-safe abort',
+);
 assert(
   (reloaded.messages || []).some((m) => m?.role === 'user' && String(m.content).includes('current overflow task must stay verbatim')),
   'current user turn should remain in persisted transcript',
 );
-assert(reloaded.compaction?.lastStage !== 'compacting', 'compaction lastStage should not remain stuck on compacting');
-assert(reloaded.providerState === undefined, 'providerState should clear after reactive compact persist');
+assert(reloaded.compaction?.lastStage === 'overflow_failed', `compaction lastStage should be overflow_failed, got ${reloaded.compaction?.lastStage}`);
+assert(reloaded.providerState === undefined, 'providerState should clear after reactive compact abort');
 
 process.stdout.write('reactive-compact-persist smoke passed ✓\n');

package/scripts/recall-bench-cases.json

@@ -0,0 +1,10 @@
+[
+  { "id": "browse-last", "label": "query-less recent browse (period=last)", "args": { "period": "last", "limit": 10 }, "expect": "browse" },
+  { "id": "period-24h", "label": "period window 24h", "args": { "period": "24h", "limit": 10 }, "expect": "browse" },
+  { "id": "period-7d", "label": "period window 7d", "args": { "period": "7d", "limit": 10 }, "expect": "browse" },
+  { "id": "scope-all", "label": "all-scope query", "args": { "query": "recall", "projectScope": "all", "limit": 10 }, "expect": "results" },
+  { "id": "recent-dryrun-delta", "label": "recent-work topical: dryrun delta sum", "args": { "query": "드라이런 델타 합산", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["드라이런"], "topN": 5 } },
+  { "id": "recent-remote-singleton", "label": "recent-work topical: remote singleton seat", "args": { "query": "remote 싱글톤 좌석", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["싱글톤"], "topN": 5 } },
+  { "id": "recency-today", "label": "query+period recency: today's work (24h)", "args": { "query": "오늘 진행한 작업", "period": "24h", "limit": 10 }, "expect": { "kind": "results", "recencyOrdered": true } },
+  { "id": "xlang-embedding-crash", "label": "cross-language: embedding worker crash (strict topN)", "args": { "query": "embedding worker crash", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["embedding"], "topN": 3 } }
+]

package/scripts/recall-bench.mjs

@@ -113,13 +113,87 @@ function scoreTopNContains(lines, substrings, n) {
   return { perSubstring, hitAtN, mrr, n };
 }
 
-function evaluateCase(kase, { count, ms, isError }, quality) {
+// Parse leading "[YYYY-MM-DD HH:MM]" timestamps from result lines and check
+// they are non-increasing (newest-first). Returns null when fewer than 2
+// lines carry a parseable timestamp (nothing to order).
+function scoreRecencyOrdered(lines) {
+  const tsRe = /^\s*\[(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2})/;
+  const headerRe = /^\s*##\s/;
+  const parse = (raw) => Date.parse(raw.replace(' ', 'T'));
+  // Non-increasing check within a single ordered list of {raw,ts}. Returns
+  // the first {prev,cur} pair where cur is newer than prev, else null.
+  const firstBreak = (stamps) => {
+    for (let i = 1; i < stamps.length; i++) {
+      if (Number.isFinite(stamps[i].ts) && Number.isFinite(stamps[i - 1].ts) && stamps[i].ts > stamps[i - 1].ts) {
+        return { prev: stamps[i - 1].raw, cur: stamps[i].raw };
+      }
+    }
+    return null;
+  };
+  const hasSessions = lines.some((l) => headerRe.test(l));
+  if (!hasSessions) {
+    // Ungrouped: single global non-increasing check over all timestamped lines.
+    const stamps = [];
+    for (const line of lines) {
+      const m = tsRe.exec(line);
+      if (m) stamps.push({ raw: m[1], ts: parse(m[1]) });
+    }
+    if (stamps.length < 2) return { parsed: stamps.length, groups: 0, ordered: true, firstViolation: null };
+    const b = firstBreak(stamps);
+    return { parsed: stamps.length, groups: 0, ordered: b === null, firstViolation: b };
+  }
+  // Session-grouped: partition timestamped lines by their "## session" header.
+  // Timestamps only compared WITHIN a group; groups themselves must descend by
+  // their first line's timestamp.
+  const groups = [];
+  let cur = null;
+  for (const line of lines) {
+    if (headerRe.test(line)) { cur = { stamps: [] }; groups.push(cur); continue; }
+    const m = tsRe.exec(line);
+    if (m && cur) cur.stamps.push({ raw: m[1], ts: parse(m[1]) });
+  }
+  const nonEmpty = groups.filter((g) => g.stamps.length);
+  const parsed = nonEmpty.reduce((s, g) => s + g.stamps.length, 0);
+  let firstViolation = null;
+  for (const g of nonEmpty) {
+    const b = firstBreak(g.stamps);
+    if (b) { firstViolation = { ...b, scope: 'within-session' }; break; }
+  }
+  if (!firstViolation) {
+    const heads = nonEmpty.map((g) => g.stamps[0]);
+    const b = firstBreak(heads);
+    if (b) firstViolation = { ...b, scope: 'across-sessions' };
+  }
+  return { parsed, groups: nonEmpty.length, ordered: firstViolation === null, firstViolation };
+}
+
+// Score expect.allContain: every result line must contain at least one of the
+// given substrings (case-insensitive). Returns offending lines (matching none).
+// Use for negative cases where rows legitimately mention the term.
+function scoreAllContain(lines, substrings) {
+  const needles = substrings.map((s) => String(s || '').toLowerCase()).filter(Boolean);
+  const offenders = lines.filter((line) => {
+    const l = line.toLowerCase();
+    return !needles.some((n) => l.includes(n));
+  });
+  return { needles: substrings, offenders, ok: offenders.length === 0 };
+}
+
+function evaluateCase(kase, { count, ms, isError }, quality, recency, allContain) {
   const warnings = [];
   if (isError) warnings.push('error result');
   if (ms > WARN_LATENCY_MS) warnings.push(`latency ${ms}ms > ${WARN_LATENCY_MS}ms`);
   if ((kase.expect === 'browse' || kase.expect === 'idlookup') && count === 0) {
     warnings.push('0 results for a browse/id-lookup case (expected data present)');
   }
+  if (kase.expect === 'empty' && count > 0) {
+    warnings.push(`expected empty but got ${count} result(s) — possible filler/unrelated match`);
+  }
+  if (allContain) {
+    for (const line of allContain.offenders) {
+      warnings.push(`allContain miss: result line contains none of [${allContain.needles.join(', ')}]: "${line}"`);
+    }
+  }
   if (quality) {
     for (const p of quality.perSubstring) {
       if (!p.hit) {
@@ -129,6 +203,10 @@ function evaluateCase(kase, { count, ms, isError }, quality) {
       }
     }
   }
+  if (recency && !recency.ordered && recency.firstViolation) {
+    const v = recency.firstViolation;
+    warnings.push(`recencyOrdered violation (${v.scope || 'global'}): ${v.cur} newer than prior ${v.prev}`);
+  }
   const status = warnings.length ? 'WARN' : 'PASS';
   return { status, warnings };
 }
@@ -156,7 +234,10 @@ async function runCase(memoryModule, kase) {
   const topNContains = expectObj && Array.isArray(expectObj.topNContains) ? expectObj.topNContains : null;
   const cutoffN = expectObj && Number.isInteger(expectObj.topN) ? expectObj.topN : 5;
   const quality = topNContains ? scoreTopNContains(resultLines(text), topNContains, cutoffN) : null;
-  const evalResult = evaluateCase({ ...kase, expect: expectKind }, { count, ms, isError }, quality);
+  const recency = expectObj && expectObj.recencyOrdered ? scoreRecencyOrdered(resultLines(text)) : null;
+  const allContainNeedles = expectObj && Array.isArray(expectObj.allContain) ? expectObj.allContain : null;
+  const allContain = allContainNeedles ? scoreAllContain(resultLines(text), allContainNeedles) : null;
+  const evalResult = evaluateCase({ ...kase, expect: expectKind }, { count, ms, isError }, quality, recency, allContain);
   return {
     id: kase.id,
     label: kase.label,
@@ -167,6 +248,8 @@ async function runCase(memoryModule, kase) {
     errMsg,
     top3: topN(text, 3),
     quality,
+    recency,
+    allContain,
     status: evalResult.status,
     warnings: evalResult.warnings,
   };
@@ -182,6 +265,9 @@ function printCase(row) {
       process.stdout.write(`    substr "${p.needle}" -> rank ${p.rank ?? 'none'}${p.hit ? '' : '  (miss)'}\n`);
     }
   }
+  if (row.recency) {
+    process.stdout.write(`  recency: ${row.recency.ordered ? 'ordered' : 'OUT-OF-ORDER'} (${row.recency.parsed} timestamped lines)\n`);
+  }
   if (row.top3.length) {
     for (const line of row.top3) process.stdout.write(`    - ${line}\n`);
   } else {
@@ -218,6 +304,7 @@ function printSummary(rows) {
 async function main() {
   const casesPath = argValue('cases', DEFAULT_CASES_PATH);
   const jsonMode = hasFlag('json');
+  const strict = hasFlag('strict');
   const cases = loadCases(casesPath);
 
   let memoryModule;
@@ -262,6 +349,8 @@ async function main() {
 
   const hardErrors = rows.filter((r) => r.isError);
   if (hardErrors.length) process.exitCode = 1;
+  // --strict: any WARN row fails the run. Default behavior (errors-only) unchanged.
+  if (strict && rows.some((r) => r.status === 'WARN')) process.exitCode = 1;
 }
 
 main().catch((e) => {

package/scripts/recall-quality-cases.json

@@ -5,8 +5,7 @@
   { "id": "q-recall-general", "label": "bare recall keyword", "args": { "query": "recall" }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } },
   { "id": "q-uc4-topic-kr", "label": "UC4 topic query with Korean qualifier", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
   { "id": "q-recall-improve-kr", "label": "cache improvement topic", "args": { "query": "캐시 개선" }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
-  { "id": "q-battle-balance", "label": "ProjectAA topic", "args": { "query": "ProjectAA" }, "expect": { "kind": "results", "topNContains": ["ProjectAA"], "topN": 5 } },
-  { "id": "q-fanout-recall-battle", "label": "fan-out array query cache+ProjectAA", "args": { "query": ["캐시 개선", "ProjectAA"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["개선", "ProjectAA"], "topN": 10 } },
+  { "id": "q-fanout-recall-cache", "label": "fan-out array query cache+recall", "args": { "query": ["캐시 개선", "recall"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["개선", "recall"], "topN": 10 } },
   { "id": "q-short-2tok-cycle", "label": "short 2-token cycle1 query", "args": { "query": "cycle1 drain", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["cycle1"], "topN": 3 } },
   { "id": "q-recall-scope-project", "label": "project-scoped recall query", "args": { "query": "recall", "cwd": "C:\\Project\\mixdog" , "limit": 10 }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } }
 ]

package/scripts/recall-usecase-cases.json

@@ -15,4 +15,4 @@
   { "id": "uc5-yesterday", "label": "UC5 calendar yesterday", "args": { "period": "yesterday", "limit": 10 }, "expect": "browse" },
   { "id": "uc5-thisweek", "label": "UC5 calendar this_week", "args": { "period": "this_week", "limit": 10 }, "expect": "browse" },
   { "id": "uc6-category", "label": "UC6 category decision 7d", "args": { "period": "7d", "category": "decision", "limit": 10 }, "expect": "browse" }
-]
+]

package/scripts/session-ingest-compaction-smoke.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+// Compaction-append collision smoke for the session-ingest RUNTIME (not just
+// the pure helpers). Reproduces the silent-drop bug: after compaction removes an
+// earlier identical untimestamped message from the in-memory array, a newly
+// APPENDED identical message used to reproduce an already-persisted ordinal →
+// same source_ref → INSERT ... ON CONFLICT DO NOTHING silently dropped it.
+//
+// Proves, against an in-memory fake DB that enforces the source_ref uniqueness
+// the real ON CONFLICT relies on:
+//   (1) post-compaction appended untimestamped identical msg → NEW row;
+//   (2) full identical re-ingest in a FRESH runtime (rows already in DB) → 0 dups;
+//   (3) subset re-ingest reproduces the same source_refs as a full re-ingest.
+import { createSessionIngestRuntime } from '../src/runtime/memory/lib/session-ingest-runtime.mjs'
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message)
+}
+
+// Minimal fake DB. Only the two statements the ingest loop issues are modelled:
+//   • SELECT COALESCE(MAX(source_turn) ...)  → per-session max
+//   • INSERT INTO entries(...) ON CONFLICT DO NOTHING → dedupe on source_ref
+// Any other query (the post-ingest raw-embedding flush's schema calls) returns
+// an empty result; flushRawEmbeddings then hits `db._pool` (undefined) and its
+// error is swallowed by the runtime, so the smoke never blocks on embeddings.
+function createFakeDb() {
+  const rows = [] // { ts, role, content, source_ref, session_id, source_turn, project_id }
+  const bySourceRef = new Set()
+  let nextId = 1
+  return {
+    rows,
+    async query(sql, params = []) {
+      if (/MAX\(source_turn\)/.test(sql)) {
+        const sessionId = params[0]
+        let max = 0
+        for (const r of rows) if (r.session_id === sessionId && r.source_turn > max) max = r.source_turn
+        return { rows: [{ max_turn: max }] }
+      }
+      if (/INSERT INTO entries/.test(sql)) {
+        const [ts, role, content, source_ref, session_id, source_turn, project_id] = params
+        if (bySourceRef.has(source_ref)) return { rowCount: 0 } // ON CONFLICT DO NOTHING
+        bySourceRef.add(source_ref)
+        rows.push({ id: nextId++, ts, role, content, source_ref, session_id, source_turn, project_id })
+        return { rowCount: 1 }
+      }
+      return { rows: [] }
+    },
+  }
+}
+
+// Durable high-water store fake (mirrors the DB `meta` kv the facade wires). A
+// SHARED store passed to two runtime instances simulates the state file
+// surviving a process restart; an absent store simulates a deleted state file.
+function makeRuntime(db, durable = new Map()) {
+  return createSessionIngestRuntime({
+    getDb: () => db,
+    log: () => {},
+    parseTsToMs: (v) => (typeof v === 'number' ? v : Number(v) || 0),
+    loadOrdinalHighWater: async (sessionId) => durable.get(sessionId) ?? null,
+    saveOrdinalHighWater: (sessionId, obj) => { durable.set(sessionId, obj); },
+  })
+}
+
+const SESSION = 'compaction-smoke-sess'
+// Untimestamped identical turns (no ts/timestamp → ordinal is what disambiguates).
+const mk = (role, content) => ({ role, content })
+
+// ── Scenario: live process ingests, compaction drops an earlier copy, append ──
+const db = createFakeDb()
+const rt = makeRuntime(db)
+
+// Distinct object identities so compaction survival is by-reference (mirrors the
+// runtime's immutable-transcript assumption).
+const other1 = mk('assistant', 'sure, working on it')
+const dupA = mk('user', 'run it again') // 1st identical untimestamped turn
+const other2 = mk('assistant', 'done')
+const dupB = mk('user', 'run it again') // 2nd identical untimestamped turn (distinct object)
+
+// Call 1 (COLD): full array with two identical untimestamped user turns.
+const arr1 = [other1, dupA, other2, dupB]
+let r1 = await rt.ingestSessionMessages({ sessionId: SESSION, messages: arr1, limit: 5000 })
+const userRows1 = db.rows.filter(r => r.role === 'user' && r.content === 'run it again')
+assert(userRows1.length === 2, `cold ingest must persist BOTH identical untimestamped turns (got ${userRows1.length})`)
+const refDupA = userRows1[0].source_ref
+const refDupB = userRows1[1].source_ref
+assert(refDupA !== refDupB, 'the two identical untimestamped turns must persist under distinct source_refs')
+
+// Compaction: drop the FIRST identical copy (dupA) and some other rows; KEEP the
+// second identical copy object (dupB) — this is what makes the array position of
+// the surviving/new identical turn shift down onto an already-persisted ordinal.
+// Then APPEND a genuinely new identical turn (distinct object).
+const dupC = mk('user', 'run it again') // NEW appended identical turn
+const arr2 = [dupB, mk('assistant', 'ok next'), dupC]
+
+// Call 2 (WARM, same runtime/process): the appended dupC must persist as a NEW row.
+let r2 = await rt.ingestSessionMessages({ sessionId: SESSION, messages: arr2, limit: 5000 })
+const userRows2 = db.rows.filter(r => r.role === 'user' && r.content === 'run it again')
+assert(
+  userRows2.length === 3,
+  `INVARIANT 1: post-compaction appended identical turn must persist as a NEW row (expected 3 total, got ${userRows2.length}) — this is the silent-drop bug`,
+)
+const refDupC = userRows2.find(r => r.source_ref !== refDupA && r.source_ref !== refDupB)?.source_ref
+assert(refDupC, 'appended identical turn must have a fresh source_ref above the persisted high-water')
+// dupB survived: it must have deduped (reused its recorded ordinal), NOT minted a new row.
+assert(db.rows.filter(r => r.source_ref === refDupB).length === 1, 'survived identical turn must dedupe, not duplicate')
+
+// ── INVARIANT 2: fresh runtime (new process), full identical re-ingest ────────
+// Rows already in DB; re-ingesting the CURRENT array from start=0 must create
+// ZERO new rows.
+const rowCountBefore = db.rows.length
+const rtFresh = makeRuntime(db) // cold state for this "process"
+await rtFresh.ingestSessionMessages({ sessionId: SESSION, messages: arr2, limit: 5000 })
+assert(
+  db.rows.length === rowCountBefore,
+  `INVARIANT 2: full identical re-ingest in a fresh process must create 0 duplicates (before=${rowCountBefore} after=${db.rows.length})`,
+)
+
+// ── INVARIANT 3: subset re-ingest reproduces the same source_refs as full ─────
+// Fresh DB + fresh runtime; ingest the full array, capture refs; then a NEW
+// fresh DB/runtime ingesting the same array via a small window (subset, seeded
+// from the prefix) must reproduce the identical source_refs.
+function refsFor(messages, opts) {
+  const d = createFakeDb()
+  const r = makeRuntime(d)
+  return { d, r }
+}
+{
+  const fullMsgs = [mk('user', 'x'), mk('assistant', 'y'), mk('user', 'x'), mk('user', 'x'), mk('assistant', 'y')]
+  const { d: dFull, r: rFull } = refsFor()
+  await rFull.ingestSessionMessages({ sessionId: 'subset-sess', messages: fullMsgs, limit: 5000 })
+  const fullRefs = dFull.rows.filter(r => r.session_id === 'subset-sess').map(r => r.source_ref).sort()
+
+  // Subset: fresh process, window = last 2 messages, prefix seeded internally.
+  const { d: dSub, r: rSub } = refsFor()
+  await rSub.ingestSessionMessages({ sessionId: 'subset-sess', messages: fullMsgs, limit: 2 })
+  const subRefs = dSub.rows.filter(r => r.session_id === 'subset-sess').map(r => r.source_ref)
+  for (const ref of subRefs) {
+    assert(fullRefs.includes(ref), `INVARIANT 3: subset re-ingest source_ref ${ref} must match a full re-ingest ref`)
+  }
+  // The subset window's last two messages are `x`(3rd occurrence) and `y`(2nd);
+  // their refs must equal the full re-ingest's 3rd `x` and 2nd `y` refs.
+  assert(subRefs.length === 2, `subset window should ingest exactly its 2 messages (got ${subRefs.length})`)
+}
+
+// ── INVARIANT 1 across RESTART: fresh runtime (new process), same DB ──────────
+// A restart = a NEW runtime instance (empty in-memory ordinal state AND empty
+// WeakMap) ingesting a reloaded transcript against the SAME DB that already
+// holds prior rows. When the reloaded (compacted) array still RETAINS the
+// identical copies, positional ordinals reproduce each survivor's OWN live row,
+// and a freshly appended identical turn takes a free ordinal and persists NEW.
+{
+  const rdb = createFakeDb()
+  const S = 'restart-sess'
+  const rtA = makeRuntime(rdb)
+  await rtA.ingestSessionMessages({ sessionId: S, messages: [mk('user', 'ping'), mk('assistant', 'pong'), mk('user', 'ping')], limit: 5000 })
+  const pingBefore = rdb.rows.filter(r => r.content === 'ping')
+  assert(pingBefore.length === 2, `pre-restart should persist 2 identical pings (got ${pingBefore.length})`)
+  const beforeIds = new Set(pingBefore.map(r => r.id))
+
+  // Restart: brand-new runtime (fresh WeakMap + ordinal state), same DB. The
+  // reloaded compacted array RETAINS both ping copies (compaction dropped only
+  // the non-identical `pong`); append a genuinely new identical ping. The
+  // reloaded objects are DISTINCT references from the pre-restart ones.
+  const rtB = makeRuntime(rdb)
+  await rtB.ingestSessionMessages({ sessionId: S, messages: [mk('user', 'ping'), mk('user', 'ping'), mk('user', 'ping')], limit: 5000 })
+  const pingAfter = rdb.rows.filter(r => r.content === 'ping')
+  assert(pingAfter.length === 3, `RESTART: appended identical turn must persist as a NEW row (expected 3, got ${pingAfter.length})`)
+  // Row-identity (not ref-membership) check: the survivor re-ingest must DEDUPE
+  // onto the 2 pre-existing live rows (same ids, no re-insert) and add EXACTLY
+  // one NEW row (the append) — proving survivors mapped to live rows, not dropped.
+  const survivorRows = pingAfter.filter(r => beforeIds.has(r.id))
+  const newRows = pingAfter.filter(r => !beforeIds.has(r.id))
+  assert(survivorRows.length === 2, `RESTART: survivors must reuse the 2 live rows (got ${survivorRows.length})`)
+  assert(newRows.length === 1, `RESTART: exactly one NEW appended row expected (got ${newRows.length})`)
+}
+
+// ── INVARIANT 1 across RESTART, LATER-WARM append (durable high-water) ────────
+// The path the reviewer disproved: after restart the cold replay of a COMPACTED
+// array seeds occNext = survivor-count T, but the DB holds K>T copies. A NEW
+// untimestamped identical turn arriving in a LATER (warm) call is distinguishable
+// (it is genuinely new, not one of the cold-replay survivors) and MUST persist —
+// only the durable per-identity high-water K makes that possible.
+{
+  const durable = new Map()   // survives the "restart" (shared across runtimes)
+  const rdb = createFakeDb()  // DB rows survive the restart too
+  const S = 'restart-warm-sess'
+
+  // Pre-restart process: build K=3 persisted copies of an identical untimestamped
+  // turn (cold [X,other,X] → 2 copies; then in-process compaction+append → 3rd).
+  const rtA = makeRuntime(rdb, durable)
+  const xa1 = mk('user', 'again'); const xa2 = mk('user', 'again')
+  await rtA.ingestSessionMessages({ sessionId: S, messages: [xa1, mk('assistant', 'ok'), xa2], limit: 5000 })
+  const xa3 = mk('user', 'again') // in-process appended (compaction kept xa2)
+  await rtA.ingestSessionMessages({ sessionId: S, messages: [xa2, mk('assistant', 'ok2'), xa3], limit: 5000 })
+  assert(rdb.rows.filter(r => r.content === 'again').length === 3, 'pre-restart should hold K=3 identical copies')
+  assert(durable.has(S), 'durable high-water must have been persisted for the duplicate identity')
+
+  // Restart: fresh runtime (empty WeakMap + ordinal state), SAME db + durable.
+  // Reloaded COMPACTED array retains only ONE copy (T=1).
+  const rtB = makeRuntime(rdb, durable)
+  const rx = mk('user', 'again') // reloaded survivor (distinct object)
+  await rtB.ingestSessionMessages({ sessionId: S, messages: [rx], limit: 5000 }) // COLD replay (T=1)
+  assert(rdb.rows.filter(r => r.content === 'again').length === 3, 'cold replay of survivor must not add rows (dedupe)')
+
+  // LATER warm call on rtB appends a genuinely new identical turn.
+  const rxNew = mk('user', 'again')
+  const rowsBeforeAppend = rdb.rows.length
+  await rtB.ingestSessionMessages({ sessionId: S, messages: [rx, rxNew], limit: 5000 })
+  const againAfter = rdb.rows.filter(r => r.content === 'again')
+  assert(
+    againAfter.length === 4,
+    `LATER-WARM RESTART: appended identical turn must persist as a NEW row via durable K (expected 4, got ${againAfter.length})`,
+  )
+  assert(rdb.rows.length === rowsBeforeAppend + 1, 'exactly one new row from the later-warm append')
+}
+
+// ── Zero-dup guarantee when a compacted reload DROPPED an identical copy ──────
+// If the reloaded array is missing an earlier identical untimestamped copy AND
+// the WeakMap survivor signal is gone (restart), the appended identical turn is
+// information-theoretically indistinguishable from the survivors (see the
+// DURABILITY note in session-ingest-runtime.mjs). Contract in that corner: NEVER
+// mint a duplicate survivor row (ON CONFLICT dedupes). The append may collapse;
+// it must not duplicate.
+{
+  const rdb = createFakeDb()
+  const S = 'restart-drop-sess'
+  const rtA = makeRuntime(rdb)
+  await rtA.ingestSessionMessages({ sessionId: S, messages: [mk('user', 'echo'), mk('user', 'echo')], limit: 5000 })
+  const before = rdb.rows.filter(r => r.content === 'echo').length
+  assert(before === 2, `pre-restart should persist 2 identical echoes (got ${before})`)
+  const rowsBefore = rdb.rows.length
+
+  // Restart with a compacted reload that DROPPED one echo, then appended one
+  // (net 2 copies again). Must not mint a duplicate; the append collapses.
+  const rtB = makeRuntime(rdb)
+  await rtB.ingestSessionMessages({ sessionId: S, messages: [mk('user', 'echo'), mk('user', 'echo')], limit: 5000 })
+  const after = rdb.rows.filter(r => r.content === 'echo').length
+  assert(after === before, `RESTART+drop: must not mint a duplicate survivor row (before=${before} after=${after})`)
+  assert(rdb.rows.length === rowsBefore, 'RESTART+drop: no duplicate rows created')
+}
+
+process.stdout.write('session ingest compaction-append smoke passed \u2713\n')