mixdog 0.9.62 → 0.9.64

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

@@ -1,279 +0,0 @@
-#!/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')
-}
-
-// ── WARM runtime + JSON-cloned replay (desktop/session resume) ───────────────
-// The memory daemon can outlive a surface that reloads the same session JSON.
-// Every transcript message is then a new object while the ingest runtime's
-// WeakMaps remain warm. The replay must reuse prior source_refs, and only a
-// genuinely appended suffix may insert.
-{
-  const rdb = createFakeDb()
-  const S = 'warm-json-clone-sess'
-  const rt = makeRuntime(rdb)
-  const original = [
-    mk('user', 'optimize session switching'),
-    mk('assistant', 'I will inspect the transition path'),
-    mk('user', 'go ahead'),
-    mk('assistant', 'working'),
-  ]
-  await rt.ingestSessionMessages({ sessionId: S, messages: original, limit: 5000 })
-  const beforeReplay = rdb.rows.length
-
-  const clonedReplay = JSON.parse(JSON.stringify(original))
-  await rt.ingestSessionMessages({ sessionId: S, messages: clonedReplay, limit: 5000 })
-  assert(
-    rdb.rows.length === beforeReplay,
-    `WARM CLONE: JSON-reloaded transcript must insert 0 duplicates (before=${beforeReplay} after=${rdb.rows.length})`,
-  )
-
-  // Reload the whole array again and append text identical to an older row.
-  // Snapshot reconciliation reuses the cloned prefix while the suffix consumes
-  // the historical occurrence high-water.
-  const clonedWithAppend = JSON.parse(JSON.stringify(original))
-  clonedWithAppend.push(mk('assistant', 'working'))
-  await rt.ingestSessionMessages({ sessionId: S, messages: clonedWithAppend, limit: 5000 })
-  assert(rdb.rows.length === beforeReplay + 1, 'WARM CLONE: exactly one genuinely appended row must insert')
-
-  const clonedAgain = JSON.parse(JSON.stringify(clonedWithAppend))
-  await rt.ingestSessionMessages({ sessionId: S, messages: clonedAgain, limit: 5000 })
-  assert(rdb.rows.length === beforeReplay + 1, 'WARM CLONE: replay after append must remain idempotent')
-}
-
-process.stdout.write('session ingest compaction-append smoke passed \u2713\n')

package/scripts/session-ingest-smoke.mjs

@@ -1,177 +0,0 @@
-#!/usr/bin/env node
-import {
-  normalizeIngestRole,
-  stableSessionSourceRef,
-  redactToolArgString,
-  redactToolArgValue,
-  sessionMessageContent,
-  createIngestTurnAllocator,
-} from '../src/runtime/memory/lib/session-ingest.mjs';
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-// --- Role normalization ---
-assert(normalizeIngestRole('human') === 'user', 'human should normalize to user');
-assert(normalizeIngestRole('AI') === 'assistant', 'AI should normalize to assistant');
-assert(normalizeIngestRole('tool_result') === null, 'tool_result is not ingested (maps to tool, dropped)');
-assert(normalizeIngestRole('developer') === null, 'developer is not ingested');
-assert(normalizeIngestRole('mystery') === null, 'unknown role should be dropped');
-
-// --- Stable source_ref across index/time for untimestamped messages ---
-const plain = { role: 'user', content: 'fix the bug in compact.mjs' };
-const refA = stableSessionSourceRef('sess1', plain, 'user', 'fix the bug in compact.mjs');
-const refB = stableSessionSourceRef('sess1', plain, 'user', 'fix the bug in compact.mjs');
-assert(refA === refB, 'same untimestamped message must yield the same source_ref regardless of call');
-assert(!/#\d+$/.test(refA), 'source_ref must not carry a volatile #index suffix');
-
-// Two textually identical untimestamped plain messages dedupe to one ref.
-const dupA = stableSessionSourceRef('sess1', { role: 'user', content: 'ok' }, 'user', 'ok');
-const dupB = stableSessionSourceRef('sess1', { role: 'user', content: 'ok' }, 'user', 'ok');
-assert(dupA === dupB, 'identical untimestamped plain messages should share a stable ref (dedupe preferred)');
-
-// A synthesized Date.now() fallback ts must NOT change identity: the helper
-// only reads m.ts/m.timestamp, so two calls for the same untimestamped message
-// at different wall-clock times still match.
-const t1 = stableSessionSourceRef('sess1', plain, 'user', 'fix the bug in compact.mjs');
-const t2 = stableSessionSourceRef('sess1', plain, 'user', 'fix the bug in compact.mjs');
-assert(t1 === t2, 'synthesized timestamps must not enter identity');
-
-// Original timestamp, when present, DOES contribute to identity.
-const tsMsg = { role: 'user', content: 'same text', ts: 1700000000000 };
-const tsRef = stableSessionSourceRef('sess1', tsMsg, 'user', 'same text');
-const noTsRef = stableSessionSourceRef('sess1', { role: 'user', content: 'same text' }, 'user', 'same text');
-assert(tsRef !== noTsRef, 'an original ts should differentiate identity from an untimestamped twin');
-
-// Tool-id identity: different tool ids => different refs; same id => same ref.
-const toolMsg1 = { role: 'assistant', content: 'x', toolCalls: [{ id: 'call_1', name: 'apply_patch' }] };
-const toolMsg2 = { role: 'assistant', content: 'x', toolCalls: [{ id: 'call_2', name: 'apply_patch' }] };
-const toolRef1 = stableSessionSourceRef('sess1', toolMsg1, 'assistant', 'x');
-const toolRef2 = stableSessionSourceRef('sess1', toolMsg2, 'assistant', 'x');
-assert(toolRef1 !== toolRef2, 'different tool-call ids should produce different source_refs');
-const toolRef1b = stableSessionSourceRef('sess1', { ...toolMsg1 }, 'assistant', 'x');
-assert(toolRef1 === toolRef1b, 'same tool-call id + content should produce the same source_ref');
-const resultRef = stableSessionSourceRef('sess1', { role: 'tool', content: 'done', toolCallId: 'call_1' }, 'tool', 'done');
-assert(typeof resultRef === 'string' && resultRef.startsWith('session:sess1:'), 'tool_result ref should be well formed');
-
-// --- Sensitive redaction (object/JSON args) ---
-const jsonArgs = JSON.stringify({ url: 'https://x', api_key: 'sk-secret-123', nested: { password: 'p@ss word' } });
-const redactedJson = redactToolArgString(jsonArgs);
-assert(!redactedJson.includes('sk-secret-123'), 'api_key value must be redacted from JSON args');
-assert(!redactedJson.includes('p@ss word'), 'nested password must be redacted from JSON args');
-assert(redactedJson.includes('https://x'), 'non-sensitive url should be preserved');
-assert(redactedJson.includes('[redacted]'), 'redaction marker should be present');
-
-const objRedaction = redactToolArgValue({ authorization: 'Bearer abc.def', keep: 'value' });
-assert(objRedaction.authorization === '[redacted]', 'authorization key should collapse to [redacted]');
-assert(objRedaction.keep === 'value', 'non-sensitive key should be preserved');
-
-// --- Sensitive redaction (raw non-JSON strings with spaces / Bearer / cookies) ---
-const rawCases = [
-  'authorization: Bearer abc.def',
-  'password="abc def"',
-  "api_key='abc def'",
-  'cookie: a=b; c=d',
-];
-for (const raw of rawCases) {
-  const out = redactToolArgString(raw);
-  assert(out.includes('[redacted]'), `raw secret should be redacted: ${raw}`);
-}
-const bearerOut = redactToolArgString('authorization: Bearer abc.def');
-assert(!bearerOut.includes('abc.def'), 'Bearer token fragment must not leak');
-assert(!bearerOut.includes('Bearer'), 'Bearer scheme word must be consumed by redaction');
-const pwSpaceOut = redactToolArgString('password="abc def"');
-assert(!pwSpaceOut.includes('abc def'), 'quoted password with spaces must not leak');
-const apiSpaceOut = redactToolArgString("api_key='abc def'");
-assert(!apiSpaceOut.includes('abc def'), 'single-quoted api_key with spaces must not leak');
-const cookieOut = redactToolArgString('cookie: a=b; c=d');
-assert(!/a=b/.test(cookieOut), 'cookie value (incl. ;-separated pairs) must not leak');
-
-// Non-sensitive raw args stay readable.
-const plainArgs = redactToolArgString('file=compact.mjs lines=10');
-assert(plainArgs.includes('compact.mjs'), 'non-sensitive raw args should be preserved');
-assert(!plainArgs.includes('[redacted]'), 'non-sensitive raw args should not be redacted');
-
-// --- Prefixed sensitive key variants (raw) ---
-const prefixedRawCases = [
-  ['access_token=abc.def', 'abc.def'],
-  ['access-token=abc.def', 'abc.def'],
-  ['x-api-key=sk-supersecret-123', 'sk-supersecret-123'],
-  ['bearer_token: Bearer bear-tok-456', 'bear-tok-456'],
-];
-for (const [raw, frag] of prefixedRawCases) {
-  const out = redactToolArgString(raw);
-  assert(out.includes('[redacted]'), `prefixed key variant should be redacted: ${raw}`);
-  assert(!out.includes(frag), `prefixed key variant must not leak its secret fragment: ${raw}`);
-}
-
-// --- JSON/object string VALUES carrying embedded raw secrets ---
-// Non-sensitive keys (headers/env) whose string value embeds a secret pair must
-// still be redacted (defense-in-depth), while non-sensitive content stays.
-const embeddedCases = [
-  [{ headers: 'authorization: Bearer abc.def' }, 'abc.def'],
-  [{ headers: 'cookie: a=b; c=d' }, 'a=b'],
-  [{ env: 'x-api-key=sk-supersecret-123' }, 'sk-supersecret-123'],
-];
-for (const [obj, frag] of embeddedCases) {
-  const viaString = redactToolArgString(JSON.stringify(obj));
-  assert(!viaString.includes(frag), `JSON string value secret must not leak: ${JSON.stringify(obj)}`);
-  assert(viaString.includes('[redacted]'), `JSON string value secret should be redacted: ${JSON.stringify(obj)}`);
-  // Object path (redactToolArgValue) must redact the embedded secret too.
-  const viaObject = JSON.stringify(redactToolArgValue(obj));
-  assert(!viaObject.includes(frag), `object string value secret must not leak: ${JSON.stringify(obj)}`);
-}
-// Non-sensitive sibling values remain readable.
-const mixedObj = redactToolArgValue({ url: 'https://x', headers: 'authorization: Bearer abc.def', note: 'keep me' });
-assert(mixedObj.url === 'https://x', 'non-sensitive url should be preserved alongside redacted header value');
-assert(mixedObj.note === 'keep me', 'non-sensitive note should be preserved');
-assert(!JSON.stringify(mixedObj).includes('abc.def'), 'embedded header secret must not leak from mixed object');
-
-// --- sessionMessageContent shaping ---
-const asstMsg = {
-  role: 'assistant',
-  content: 'running tool',
-  toolCalls: [{ id: 'call_9', name: 'http_get', arguments: '{"url":"https://x","authorization":"Bearer zzz"}' }],
-};
-const asstShaped = sessionMessageContent(asstMsg);
-assert(asstShaped.includes('running tool'), 'assistant text should be preserved');
-assert(asstShaped.includes('http_get'), 'tool name should be readable');
-assert(asstShaped.includes('id=call_9'), 'tool id should be readable');
-assert(asstShaped.includes('https://x'), 'non-sensitive tool arg should be readable');
-assert(!asstShaped.includes('zzz'), 'sensitive tool arg should be redacted in shaped content');
-
-const toolResultShaped = sessionMessageContent({ role: 'tool', content: 'patch applied', toolCallId: 'call_9' });
-assert(toolResultShaped.includes('[tool_result id=call_9]'), 'tool result should be tagged with its pairing id');
-assert(toolResultShaped.includes('patch applied'), 'tool result body should be preserved');
-
-const rawToolMsg = sessionMessageContent({
-  role: 'assistant',
-  content: '',
-  toolCalls: [{ id: 'call_x', name: 'curl', arguments: 'authorization: Bearer abc.def' }],
-});
-assert(!/abc\.def/.test(rawToolMsg), 'session message redaction should not leak raw Bearer token text');
-
-// --- Monotonic source_turn allocator (post-compaction ordering) ---
-// Seed from the current MAX(source_turn) for the session; every newly inserted
-// row must get a strictly increasing turn ABOVE all prior rows, independent of
-// the (post-compaction) array index. Re-ingested rows do not advance the count.
-const alloc = createIngestTurnAllocator(42);
-assert(alloc.peekNext() === 43, 'allocator should peek the next turn above the prior max');
-assert(alloc.peekNext() === 43, 'peek must be idempotent until next() is called');
-assert(alloc.next() === 43, 'first inserted row should take prevMax+1');
-assert(alloc.next() === 44, 'second inserted row should take prevMax+2');
-assert(alloc.current() === 44, 'current should track the last consumed turn');
-// Simulate: pre-compact rows already at turns 1..3 (prevMax=3); after
-// compaction a later message is appended with a LOW array index — it must STILL
-// get turn 4 (continuation), not a low/old turn that would sort before them.
-const post = createIngestTurnAllocator(3);
-const appendedTurn = post.next();
-assert(appendedTurn === 4, 'a post-compaction appended row must continue after the prior max source_turn');
-assert(appendedTurn > 3, 'post-compaction row turn must sort AFTER older pre-compaction rows');
-// A conflicting re-ingest (row already present) must not consume a turn.
-const seeded = createIngestTurnAllocator(10);
-const peek = seeded.peekNext();
-assert(peek === 11 && seeded.current() === 10, 're-ingest peek must not advance the counter');
-
-process.stdout.write('session ingest smoke passed \u2713\n');

package/scripts/session-orphan-sweep-test.mjs

@@ -1,109 +0,0 @@
-/**
- * session-orphan-sweep-test.mjs — proves the periodic sweep reclaims mature
- * closed tombstones that exist ON DISK but are ABSENT from the summary index.
- *
- * Regression guard for the pre-fix bug where sweepStaleSessions iterated only
- * listStoredSessionSummaries() rows, so on-disk session files missing from a
- * stale index were never visited and their tombstones accumulated forever.
- */
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-test('mature closed on-disk orphan absent from summary index gets tombstone-swept', async () => {
-    const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-orphan-sweep-'));
-    process.env.MIXDOG_DATA_DIR = dataDir;
-    try {
-        const store = await import('../src/runtime/agent/orchestrator/session/store.mjs');
-        const { sweepStaleSessions, _sessionSummary, _writeSummaryIndex } = store;
-
-        const sessionsDir = join(dataDir, 'sessions');
-        mkdirSync(sessionsDir, { recursive: true });
-
-        const now = Date.now();
-        const TWO_HOURS = 2 * 60 * 60 * 1000;
-        const ONE_HOUR = 60 * 60 * 1000;
-
-        // (1) An INDEXED, fresh, open agent session — present in the summary
-        //     index so the index is non-empty (blocking any rebuild) and must
-        //     survive the sweep.
-        const indexed = {
-            id: 'sess_indexed_keep',
-            closed: false,
-            status: 'idle',
-            owner: 'agent:test',
-            updatedAt: now,
-            createdAt: now,
-            lastHeartbeatAt: now,
-            messages: [],
-        };
-        writeFileSync(join(sessionsDir, `${indexed.id}.json`), JSON.stringify(indexed));
-
-        // (2) An ORPHAN closed+mature tombstone — on disk, NOT in the index,
-        //     closed >1h ago. Only reachable if the sweep reconciles the index
-        //     candidate set with a direct directory scan.
-        const orphan = {
-            id: 'sess_orphan_tombstone',
-            closed: true,
-            status: 'closed',
-            owner: 'agent:test',
-            updatedAt: now - TWO_HOURS,
-            createdAt: now - TWO_HOURS,
-            messages: [],
-        };
-        writeFileSync(join(sessionsDir, `${orphan.id}.json`), JSON.stringify(orphan));
-
-        // (3) A shared-store tombstone whose id still has local in-flight work.
-        // It must be excluded before unlink, otherwise that work's late save
-        // could recreate an open session after the tombstone disappears.
-        const locallyLive = {
-            ...orphan,
-            id: 'sess_shared_tombstone_locally_live',
-        };
-        writeFileSync(join(sessionsDir, `${locallyLive.id}.json`), JSON.stringify(locallyLive));
-
-        // Index contains ONLY the indexed session — the orphan is absent.
-        const rows = _writeSummaryIndex([_sessionSummary(indexed)]);
-        assert.equal(rows.length, 1, 'index seeded with exactly one row');
-        assert.ok(!rows.some((r) => r.id === orphan.id), 'orphan is absent from the summary index');
-
-        // Tombstone-only pass (no idle sweep) with a 1h maturity threshold.
-        const result = sweepStaleSessions({
-            sweepIdle: false,
-            tombstoneMaxAgeMs: ONE_HOUR,
-            isSessionLive: (id) => id === locallyLive.id,
-        });
-
-        assert.equal(result.tombstonesCleaned, 1, 'the orphan tombstone was reclaimed');
-        assert.ok(
-            result.tombstoneDetails.some((d) => d.id === orphan.id),
-            'sweep reports the orphan id among tombstone deletions',
-        );
-        assert.ok(
-            !existsSync(join(sessionsDir, `${orphan.id}.json`)),
-            'orphan session file was unlinked from disk',
-        );
-        assert.ok(
-            existsSync(join(sessionsDir, `${indexed.id}.json`)),
-            'fresh open indexed session was preserved',
-        );
-        assert.ok(
-            existsSync(join(sessionsDir, `${locallyLive.id}.json`)),
-            'locally live shared-store tombstone was excluded before unlink',
-        );
-        const afterLocalWork = sweepStaleSessions({
-            sweepIdle: false,
-            tombstoneMaxAgeMs: ONE_HOUR,
-            isSessionLive: () => false,
-        });
-        assert.ok(
-            afterLocalWork.tombstoneDetails.some((d) => d.id === locallyLive.id),
-            'protected tombstone is reclaimed once local work settles',
-        );
-    } finally {
-        try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
-        delete process.env.MIXDOG_DATA_DIR;
-    }
-});

package/scripts/set-effort-config-test.mjs

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import { __saveModelSettingsForTest } from '../src/mixdog-session-runtime.mjs';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const RUNTIME_SRC = resolve(__dirname, '../src/mixdog-session-runtime.mjs');
-
-test('setEffort persists through adoptConfig with in-memory baseConfig', () => {
-  const src = readFileSync(RUNTIME_SRC, 'utf8');
-  const block = src.match(/async setEffort\(value\) \{[\s\S]*?\n    \},/)?.[0] || '';
-  assert.match(block, /adoptConfig\(saveModelSettings\(cfgMod, route, \{ fastCapable, baseConfig: config \}\)/);
-  assert.doesNotMatch(block, /config = saveModelSettings/);
-});
-
-test('saveModelSettings preserves baseConfig fields not present on disk', () => {
-  const saved = [];
-  const cfgMod = {
-    loadConfig: () => ({ profile: 'from-disk', modelSettings: {}, fastModels: {} }),
-    saveConfig: (next) => {
-      saved.push(next);
-      return next;
-    },
-  };
-  const baseConfig = {
-    profile: 'in-memory-only',
-    modelSettings: {},
-    fastModels: {},
-    autoClear: { enabled: true },
-  };
-  const route = { provider: 'openai', model: 'gpt-5.4', effort: 'high', fast: false };
-  const result = __saveModelSettingsForTest(cfgMod, route, { fastCapable: true, baseConfig });
-  assert.equal(result.profile, 'in-memory-only');
-  assert.equal(result.autoClear?.enabled, true);
-  assert.equal(result.modelSettings['openai/gpt-5.4']?.effort, 'high');
-  assert.equal(saved.length, 1);
-  assert.equal(saved[0].profile, 'in-memory-only');
-});