@kanadego/dsh-heartbeat 1.7.4 → 1.9.0

package/dist/chunk-PQTSXW4F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/seeds/pool.ts","../src/seeds/types.ts"],"sourcesContent":["// Material pool engine (design doc §4). All four eviction rules are\n// deterministic code - no LLM involvement (§4.2). Storage: data/seeds.jsonl,\n// one seed per JSON line, DPAPI-encrypted at rest (D14).\n\nimport path from 'node:path';\nimport type { PathGuard } from '../core/path-guard.js';\nimport { loadEncryptedText, saveEncryptedText } from '../vault/vault.js';\nimport type { Policy } from '../config/schema.js';\nimport {\n  SEED_SOURCE_DEFAULT_CONFIDENCE,\n  emptySeedDb,\n  type Seed,\n  type SeedCategory,\n  type SeedDb,\n  type SeedRetireReason,\n  type SeedSource,\n  type SeedTag,\n} from './types.js';\n\nconst DAY_MS = 86_400_000;\n\n// ── lifecycle audit (2026-10-06 / v1.9.0) ───────────────────────────────\n// The pool used to mutate in silence: a seed could appear, be evicted for\n// capacity, or be dropped from the archive with nothing in the log. Every\n// mutator now takes an optional sink and reports what it did. IDs and\n// metadata ONLY — heartbeat.jsonl is plaintext by charter and must never\n// carry conversation text; the seed text itself stays in the DPAPI pool.\nexport type SeedAuditFn = (entry: Record<string, unknown>) => void;\n\nconst NO_AUDIT: SeedAuditFn = () => {};\n\n/** Audit must never break the pool (or the beat that called it). */\nfunction emit(audit: SeedAuditFn, entry: Record<string, unknown>): void {\n  try {\n    audit(entry);\n  } catch {\n    /* audit is diagnostic; a failed append is not a pool failure */\n  }\n}\n\n// Per-category pool caps (2026-09-18 spec ⑤): topic stock vs conversation-grown\n// chat material, decoupled from `source`; sum == the global maxActive default.\nexport const SEED_CATEGORY_CAPS: Record<SeedCategory, number> = { topic: 16, chat: 14 };\n\nconst CATEGORY_VALUES: readonly string[] = ['topic', 'chat'];\n\n/** Lenient category coercion for on-disk rows: anything missing/unknown (all\n *  pre-v1.5 seeds) counts as topic stock. */\nexport function normalizeCategory(v: unknown): SeedCategory {\n  return typeof v === 'string' && (CATEGORY_VALUES as readonly string[]).includes(v)\n    ? (v as SeedCategory)\n    : 'topic';\n}\n\nexport interface AddSeedInput {\n  text: string;\n  topic?: string;\n  tag?: SeedTag;\n  source?: SeedSource;\n  /** Loop role (spec ⑤); defaults from source: chat->chat, everything else->topic. */\n  category?: SeedCategory;\n  confidence?: number;\n}\n\nexport interface AddSeedResult {\n  kind: 'added' | 'merged' | 'duplicate';\n  seed: Seed;\n  evicted?: Seed;\n}\n\nexport interface GcReport {\n  consumed: number;\n  expired: number;\n  coldBench: number;\n  activeAfter: number;\n  /** v1.9.0: archived rows dropped to honor seeds.archiveCap (oldest first). */\n  archiveTrimmed: number;\n}\n\nexport const TTL_KEYS: readonly SeedTag[] = ['news', 'fandom', 'scene', 'promise'];\n\nexport function normalizeTag(tag: string | undefined): SeedTag {\n  if (tag && (TTL_KEYS as readonly string[]).includes(tag)) return tag as SeedTag;\n  return 'scene';\n}\n\nfunction parseIso(v: string): number {\n  const t = Date.parse(v);\n  return Number.isFinite(t) ? t : 0;\n}\n\n// ── storage ─────────────────────────────────────────────────────────────\n\nexport function seedsFilePath(dataDir: string): string {\n  return path.join(dataDir, 'seeds.jsonl');\n}\n\nexport function loadPool(guard: PathGuard, file: string): SeedDb {\n  const raw = loadEncryptedText(guard, file);\n  if (raw === null) return emptySeedDb();\n  const db = emptySeedDb();\n  for (const line of raw.split('\\n')) {\n    const trimmed = line.trim();\n    if (!trimmed) continue;\n    try {\n      const obj = JSON.parse(trimmed) as Seed;\n      if (typeof obj.id === 'string' && obj.id.startsWith('s')) {\n        // spec ⑤ loadPool tolerance: only the id is load-bearing; a missing or\n        // unknown category (every pre-v1.5 row) falls back to topic stock.\n        obj.category = normalizeCategory(obj.category);\n        db.seeds.push(obj);\n        const n = Number(obj.id.slice(1));\n        if (Number.isFinite(n) && n > db.seq) db.seq = n;\n      }\n    } catch {\n      // corrupt line: skip (pool is a cache; journal-level audit lives elsewhere)\n    }\n  }\n  return db;\n}\n\nexport function savePool(guard: PathGuard, file: string, db: SeedDb): void {\n  const body = db.seeds.map((s) => JSON.stringify(s)).join('\\n');\n  saveEncryptedText(guard, file, body ? body + '\\n' : '');\n}\n\n// ── queries ─────────────────────────────────────────────────────────────\n\nexport const activeSeeds = (db: SeedDb): Seed[] => db.seeds.filter((s) => s.status === 'active');\nexport const archivedSeeds = (db: SeedDb): Seed[] => db.seeds.filter((s) => s.status === 'archived');\n\n// ── eviction scoring (rule 4) ───────────────────────────────────────────\n\n/**\n * Comprehensive score (§4.2): freshness x0.4 + unused x0.3 + confidence x0.3.\n * Higher = keep. Lowest-scoring active is evicted when the pool is full.\n */\nexport function evictionScore(seed: Seed, policy: Policy, now: number): number {\n  const ttlDays = policy.seeds.ttlDays[seed.tag] || 14;\n  const daysStale = Math.max(0, (now - parseIso(seed.lastEvidenceAt)) / DAY_MS);\n  const freshness = Math.max(0, 1 - daysStale / ttlDays);\n  const unused = seed.used === 0 ? 1 : 1 / seed.used;\n  const w = policy.seeds.scoreWeights;\n  return freshness * w.freshness + unused * w.unused + seed.confidence * w.confidence;\n}\n\n/** Pick the eviction victim: unprotected actives first (§4.2 加权保护); with\n *  `category`, only that category's actives compete (spec ⑤ per-category caps). */\nexport function pickEvictionVictim(db: SeedDb, policy: Policy, now: number, category?: SeedCategory): Seed | null {\n  const actives = activeSeeds(db).filter((s) => category === undefined || normalizeCategory(s.category) === category);\n  if (actives.length === 0) return null;\n  const unprotected = actives.filter((s) => !s.protected);\n  const candidates = unprotected.length > 0 ? unprotected : actives;\n  let worst: Seed | null = null;\n  let worstScore = Number.POSITIVE_INFINITY;\n  for (const s of candidates) {\n    const score = evictionScore(s, policy, now);\n    if (score < worstScore) {\n      worstScore = score;\n      worst = s;\n    }\n  }\n  return worst;\n}\n\nfunction archiveSeed(seed: Seed, reason: SeedRetireReason, now: number): void {\n  seed.status = 'archived';\n  seed.retireReason = reason;\n  seed.retiredAt = new Date(now).toISOString();\n}\n\n/** Spec ④: chat-grown material is consumed ONCE (conversation freshness);\n *  every other category follows the policy-wide retireAfterUsed. */\nfunction retireLimit(s: Seed, policy: Policy): number {\n  return normalizeCategory(s.category) === 'chat' ? 1 : policy.seeds.retireAfterUsed;\n}\n\n// ── operations ──────────────────────────────────────────────────────────\n\nexport function addSeed(\n  guard: PathGuard,\n  file: string,\n  policy: Policy,\n  input: AddSeedInput,\n  now = Date.now(),\n  audit: SeedAuditFn = NO_AUDIT,\n): AddSeedResult {\n  const db = loadPool(guard, file);\n  const text = input.text.trim();\n  if (!text) throw new Error('seed text must not be empty');\n  const tag = normalizeTag(input.tag);\n  const source: SeedSource = input.source ?? 'chat';\n  const category = normalizeCategory(input.category ?? (source === 'chat' ? 'chat' : 'topic'));\n  const confidence = input.confidence ?? SEED_SOURCE_DEFAULT_CONFIDENCE[source];\n\n  // Exact-text dedup against actives.\n  const dup = activeSeeds(db).find((s) => s.text === text);\n  if (dup) return { kind: 'duplicate', seed: dup };\n\n  const nowIso = new Date(now).toISOString();\n  const ttlMs = (policy.seeds.ttlDays[tag] || 14) * DAY_MS;\n\n  // Same-topic merge (§4.3): collapse all same-topic actives + the new item.\n  const sameTopic = activeSeeds(db).filter((s) => s.topic === (input.topic ?? text.slice(0, 24)));\n  let seed: Seed;\n  if (sameTopic.length > 0) {\n    const kept = sameTopic[0]!;\n    kept.text = text; // brief takes the latest\n    kept.tag = tag;\n    kept.source = source;\n    kept.category = normalizeCategory(input.category ?? kept.category ?? category);\n    kept.confidence = Math.max(kept.confidence, confidence);\n    kept.used = sameTopic.reduce((acc, s) => acc + s.used, 0); // used accumulates\n    kept.lastEvidenceAt = [kept.lastEvidenceAt, nowIso, ...sameTopic.map((s) => s.lastEvidenceAt)]\n      .reduce((a, b) => (parseIso(b) > parseIso(a) ? b : a));\n    kept.expiresAt = new Date(Math.max(parseIso(kept.expiresAt), now + ttlMs)).toISOString();\n    kept.protected = kept.protected || source === 'hand' || (source === 'profile' && confidence >= 0.7);\n    // remove the other same-topic actives (merged into kept)\n    for (const extra of sameTopic.slice(1)) {\n      extra.status = 'archived';\n      extra.retireReason = 'completed';\n      extra.retiredAt = nowIso;\n      emit(audit, { event: 'seed_retired', id: extra.id, reason: 'completed', via: 'merge', into: kept.id });\n    }\n    seed = kept;\n    // capacity still applies after growth check below if kept is somehow over cap\n    if (activeSeeds(db).length > policy.seeds.maxActive) {\n      const victim = pickEvictionVictim(db, policy, now, normalizeCategory(kept.category));\n      if (victim && victim.id !== kept.id) {\n        archiveSeed(victim, 'pool_cap', now);\n        emit(audit, { event: 'seed_added', id: kept.id, kind: 'merged', tag: kept.tag, source: kept.source, category: kept.category, confidence: kept.confidence, mergedFrom: sameTopic.length - 1 });\n        emit(audit, { event: 'seed_retired', id: victim.id, reason: 'pool_cap', via: 'merge', into: kept.id });\n        savePool(guard, file, db);\n        return { kind: 'merged', seed: kept, evicted: victim };\n      }\n    }\n    emit(audit, { event: 'seed_added', id: kept.id, kind: 'merged', tag: kept.tag, source: kept.source, category: kept.category, confidence: kept.confidence, mergedFrom: sameTopic.length - 1 });\n    savePool(guard, file, db);\n    return { kind: 'merged', seed: kept };\n  }\n\n  // Capacity first (rules 4 + spec ⑤): per-category cap evicts within its own\n  // pool; the global cap evicts in the incoming seed's category (a full topic\n  // stock must not push chat material out and vice versa).\n  let evicted: Seed | undefined;\n  const catCount = activeSeeds(db).filter((s) => normalizeCategory(s.category) === category).length;\n  if (catCount >= SEED_CATEGORY_CAPS[category]) {\n    const victim = pickEvictionVictim(db, policy, now, category);\n    if (victim) {\n      archiveSeed(victim, 'pool_cap', now);\n      evicted = victim;\n    }\n  }\n  if (activeSeeds(db).length >= policy.seeds.maxActive) {\n    const victim = pickEvictionVictim(db, policy, now, category);\n    if (victim) {\n      archiveSeed(victim, 'pool_cap', now);\n      evicted = evicted ?? victim;\n    }\n  }\n\n  db.seq += 1;\n  seed = {\n    id: `s${db.seq}`,\n    text,\n    topic: input.topic ?? text.slice(0, 24),\n    tag,\n    source,\n    category,\n    confidence,\n    protected: source === 'hand' || (source === 'profile' && confidence >= 0.7),\n    used: 0,\n    bornAt: nowIso,\n    expiresAt: new Date(now + ttlMs).toISOString(),\n    lastUsedAt: null,\n    lastEvidenceAt: nowIso,\n    status: 'active',\n  };\n  db.seeds.push(seed);\n  emit(audit, { event: 'seed_added', id: seed.id, kind: 'added', tag: seed.tag, source: seed.source, category: seed.category, confidence: seed.confidence });\n  if (evicted) emit(audit, { event: 'seed_retired', id: evicted.id, reason: 'pool_cap', via: 'add', into: seed.id });\n  savePool(guard, file, db);\n  return { kind: 'added', seed, evicted };\n}\n\n/**\n * Deterministic gc (rules 1-3 of §4.2). Rule 4 (pool cap) fires on add only.\n * v1.9.0: the archive area is ALSO capped (seeds.archiveCap) — the archive is\n * a forensic trail, not a hoard; trim oldest-retired first.\n */\nexport function gcPool(guard: PathGuard, file: string, policy: Policy, now = Date.now(), audit: SeedAuditFn = NO_AUDIT): GcReport {\n  const db = loadPool(guard, file);\n  const report: GcReport = { consumed: 0, expired: 0, coldBench: 0, activeAfter: 0, archiveTrimmed: 0 };\n  for (const s of activeSeeds(db)) {\n    const ageMs = now - parseIso(s.bornAt);\n    const sinceEvidence = parseIso(s.lastEvidenceAt);\n    const sinceUsed = s.lastUsedAt ? parseIso(s.lastUsedAt) : 0;\n    if (s.used >= retireLimit(s, policy) && sinceEvidence <= sinceUsed) {\n      archiveSeed(s, 'consumed', now);\n      report.consumed += 1;\n      emit(audit, { event: 'seed_retired', id: s.id, reason: 'consumed', via: 'gc', used: s.used });\n    } else if (now > parseIso(s.expiresAt)) {\n      archiveSeed(s, 'expired', now);\n      report.expired += 1;\n      emit(audit, { event: 'seed_retired', id: s.id, reason: 'expired', via: 'gc', used: s.used });\n    } else if (s.used === 0 && ageMs >= policy.seeds.coldBenchDays * DAY_MS) {\n      archiveSeed(s, 'cold_bench', now);\n      report.coldBench += 1;\n      emit(audit, { event: 'seed_retired', id: s.id, reason: 'cold_bench', via: 'gc', used: s.used });\n    }\n  }\n  // archive cap: drop the oldest-retired rows beyond the cap (retiredAt may be\n  // missing on pre-v1.5 rows — parseIso('') = 0 sorts them oldest).\n  const archived = db.seeds.filter((s) => s.status === 'archived');\n  if (archived.length > policy.seeds.archiveCap) {\n    const drop = [...archived]\n      .sort((a, b) => parseIso(a.retiredAt ?? '') - parseIso(b.retiredAt ?? ''))\n      .slice(0, archived.length - policy.seeds.archiveCap);\n    const dropped = new Set(drop.map((s) => s.id));\n    db.seeds = db.seeds.filter((s) => !dropped.has(s.id));\n    report.archiveTrimmed = drop.length;\n    // These rows are GONE (not archived — deleted): the log is the only trace\n    // left, so name them. IDs only, and cap the list in case a first GC trims\n    // a legacy archive wholesale.\n    emit(audit, { event: 'seed_archive_trimmed', count: drop.length, ids: drop.slice(0, 50).map((s) => s.id) });\n  }\n  report.activeAfter = activeSeeds(db).length;\n  savePool(guard, file, db);\n  return report;\n}\n\n/** The seed surfaced in a real expression: count + maybe retire (rule 1). */\nexport function surfaceSeed(\n  guard: PathGuard,\n  file: string,\n  policy: Policy,\n  id: string,\n  now = Date.now(),\n  audit: SeedAuditFn = NO_AUDIT,\n): Seed | null {\n  const db = loadPool(guard, file);\n  const s = db.seeds.find((x) => x.id === id && x.status === 'active');\n  if (!s) return null;\n  s.used += 1;\n  s.lastUsedAt = new Date(now).toISOString();\n  if (s.used >= retireLimit(s, policy) && parseIso(s.lastEvidenceAt) <= parseIso(s.lastUsedAt)) {\n    archiveSeed(s, 'consumed', now);\n    emit(audit, { event: 'seed_retired', id: s.id, reason: 'consumed', via: 'surface', used: s.used });\n  }\n  savePool(guard, file, db);\n  return s;\n}\n\n/** Deliberate retirement (item completed / no longer relevant). */\nexport function archiveSeedById(\n  guard: PathGuard,\n  file: string,\n  id: string,\n  reason: SeedRetireReason = 'completed',\n  now = Date.now(),\n  audit: SeedAuditFn = NO_AUDIT,\n): Seed | null {\n  const db = loadPool(guard, file);\n  const s = db.seeds.find((x) => x.id === id && x.status === 'active');\n  if (!s) return null;\n  archiveSeed(s, reason, now);\n  emit(audit, { event: 'seed_retired', id: s.id, reason, via: 'manual' });\n  savePool(guard, file, db);\n  return s;\n}\n\n/** Restore an archived seed to the active pool (UI operation; resets TTL). */\nexport function restoreSeed(\n  guard: PathGuard,\n  file: string,\n  policy: Policy,\n  id: string,\n  now = Date.now(),\n  audit: SeedAuditFn = NO_AUDIT,\n): { ok: true; seed: Seed } | { ok: false; reason: string } {\n  const db = loadPool(guard, file);\n  const s = db.seeds.find((x) => x.id === id && x.status === 'archived');\n  if (!s) return { ok: false, reason: 'archived seed not found' };\n  if (activeSeeds(db).length >= policy.seeds.maxActive) {\n    return { ok: false, reason: `pool full (${policy.seeds.maxActive}); archive something first` };\n  }\n  s.status = 'active';\n  s.retireReason = undefined;\n  s.retiredAt = undefined;\n  s.expiresAt = new Date(now + (policy.seeds.ttlDays[s.tag] || 14) * DAY_MS).toISOString();\n  s.lastEvidenceAt = new Date(now).toISOString();\n  emit(audit, { event: 'seed_restored', id: s.id });\n  savePool(guard, file, db);\n  return { ok: true, seed: s };\n}\n\n/** Hard delete (UI explicit action with confirm; the caller audits it). */\nexport function deleteSeed(guard: PathGuard, file: string, id: string, audit: SeedAuditFn = NO_AUDIT): boolean {\n  const db = loadPool(guard, file);\n  const before = db.seeds.length;\n  db.seeds = db.seeds.filter((x) => x.id !== id);\n  if (db.seeds.length === before) return false;\n  emit(audit, { event: 'seed_deleted', id });\n  savePool(guard, file, db);\n  return true;\n}\n","// Material pool (\"素材池\") types. Charter (axiom 3): this pool is a CACHE,\n// not memory - volatile, evictable, burnable; long-term memory only absorbs\n// conversation-validated content. Everything here may be destroyed.\n\nexport type SeedTag = 'news' | 'fandom' | 'scene' | 'promise';\nexport type SeedSource = 'chat' | 'screen' | 'browse' | 'hand' | 'profile';\nexport type SeedCategory = 'topic' | 'chat';\nexport type SeedRetireReason = 'consumed' | 'expired' | 'cold_bench' | 'pool_cap' | 'completed';\n\nexport interface Seed {\n  id: string;\n  /** Short brief shown to the reflection prompt. */\n  text: string;\n  /** Merge key (§4.3): same-topic actives collapse into one. */\n  topic: string;\n  tag: SeedTag;\n  source: SeedSource;\n  /** Loop role, decoupled from source (2026-09-18 spec ⑤): 'topic' = wander/\n   *  hand/profile stock (random pick), 'chat' = conversation-grown, consumed\n   *  once. Absent on pre-v1.5 rows; loadPool defaults them to 'topic'. */\n  category?: SeedCategory;\n  /** 0..1 trust level; handwriting and high-confidence profile sources gain eviction protection. */\n  confidence: number;\n  /** Eviction protection (§4.2 pool-cap rule): handwritten / high-confidence profile sources. */\n  protected: boolean;\n  /** Times this seed surfaced in an actual expression. */\n  used: number;\n  bornAt: string;\n  /** bornAt + ttlDays[tag]; archived when passed (rule 2). */\n  expiresAt: string;\n  lastUsedAt: string | null;\n  /** Fresh-evidence watermark: rule 1 spares seeds with evidence newer than last use. */\n  lastEvidenceAt: string;\n  status: 'active' | 'archived';\n  retireReason?: SeedRetireReason;\n  retiredAt?: string;\n}\n\nexport interface SeedDb {\n  seq: number;\n  seeds: Seed[];\n}\n\nexport function emptySeedDb(): SeedDb {\n  return { seq: 0, seeds: [] };\n}\n\nexport const SEED_SOURCE_DEFAULT_CONFIDENCE: Record<SeedSource, number> = {\n  hand: 1.0,\n  profile: 0.7,\n  chat: 0.6,\n  screen: 0.4,\n  browse: 0.4,\n};\n"],"mappings":"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","names":[]}

package/dist/chunk-RB3NLLGF.js

@@ -0,0 +1,87 @@
+import {
+  ARCHIVE_PREFIX,
+  appendAuditLine,
+  journalFilePath,
+  replayJournal,
+  snapshotFilePath
+} from "./chunk-VIZNIQLK.js";
+import {
+  saveJson
+} from "./chunk-IFTFDHZX.js";
+
+// src/profile/snapshot.ts
+import fs from "fs";
+import path from "path";
+var SNAPSHOT_THRESHOLD = 5e3;
+function snapshotDue(guard, dataDir, threshold = SNAPSHOT_THRESHOLD) {
+  let lines = 0;
+  try {
+    const raw = fs.readFileSync(guard.assert(journalFilePath(dataDir)), "utf8");
+    lines = raw.split("\n").filter((l) => l.trim()).length;
+  } catch {
+    return { needed: false, lines: 0 };
+  }
+  return { needed: lines >= threshold, lines };
+}
+function snapshotProfile(guard, dataDir, now = Date.now()) {
+  const journalFile = journalFilePath(dataDir);
+  let raw = "";
+  try {
+    raw = fs.readFileSync(guard.assert(journalFile), "utf8");
+  } catch {
+    return { ok: false, reason: "no journal" };
+  }
+  const liveRecords = raw.split("\n").filter((l) => l.trim());
+  if (liveRecords.length === 0) return { ok: false, reason: "journal empty, nothing to fold" };
+  const replayed = replayJournal(guard, dataDir);
+  const lastTs = lastRecordTs(raw) ?? new Date(now).toISOString();
+  const snapshot = {
+    version: 1,
+    baselineTs: lastTs,
+    recordsFolded: replayed.records,
+    doc: replayed.doc
+  };
+  saveJson(guard, snapshotFilePath(dataDir), snapshot);
+  const stamp = new Date(now).toISOString().replace(/[-:T]/g, "").slice(0, 15);
+  const archiveFile = `${ARCHIVE_PREFIX}${stamp}.jsonl`;
+  fs.writeFileSync(path.join(dataDir, archiveFile), liveRecords.join("\n") + "\n", "utf8");
+  fs.writeFileSync(guard.assert(journalFile), "", "utf8");
+  return {
+    ok: true,
+    baselineTs: lastTs,
+    folded: replayed.records,
+    archiveFile,
+    liveRemaining: 0
+  };
+}
+function lastRecordTs(raw) {
+  const lines = raw.split("\n").filter((l) => l.trim());
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      return String(JSON.parse(lines[i]).ts ?? "") || null;
+    } catch {
+    }
+  }
+  return null;
+}
+function snapshotIfDue(guard, dataDir, auditFile, why, now = Date.now()) {
+  try {
+    const { needed, lines } = snapshotDue(guard, dataDir);
+    if (!needed) return;
+    const report = snapshotProfile(guard, dataDir, now);
+    appendAuditLine(auditFile, { event: "profile_snapshot", why, lines, ...report });
+  } catch (e) {
+    try {
+      appendAuditLine(auditFile, { event: "profile_snapshot_failed", why, error: String(e).slice(0, 160) });
+    } catch {
+    }
+  }
+}
+
+export {
+  SNAPSHOT_THRESHOLD,
+  snapshotDue,
+  snapshotProfile,
+  snapshotIfDue
+};
+//# sourceMappingURL=chunk-RB3NLLGF.js.map

package/dist/chunk-RB3NLLGF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/profile/snapshot.ts"],"sourcesContent":["// Journal snapshot + shard rotation (v1.8.0, design doc §14 ③). The journal\n// grows without bound; past the threshold the maintenance phase folds it into\n// a DPAPI snapshot and moves the folded records into a timestamped archive\n// shard, so replay cost stays bounded while the raw history survives on disk.\n//\n// Safety: replayJournal (store.ts) is the single authority reader and already\n// understands snapshot → archives → live journal, so verify/rebuild keep\n// working across rotations with no special-casing.\n\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { appendAuditLine } from '../core/audit-log.js';\nimport type { PathGuard } from '../core/path-guard.js';\nimport { saveJson } from '../vault/vault.js';\nimport {\n  journalFilePath,\n  replayJournal,\n  snapshotFilePath,\n  ARCHIVE_PREFIX,\n  type ProfileSnapshot,\n} from './store.js';\n\n/** Fold the journal once the live file reaches this many records. */\nexport const SNAPSHOT_THRESHOLD = 5000;\n\nexport interface SnapshotReport {\n  ok: boolean;\n  reason?: string;\n  baselineTs?: string;\n  folded?: number;\n  archiveFile?: string;\n  liveRemaining?: number;\n}\n\n/** How far the live journal is from the snapshot threshold. */\nexport function snapshotDue(guard: PathGuard, dataDir: string, threshold = SNAPSHOT_THRESHOLD): { needed: boolean; lines: number } {\n  let lines = 0;\n  try {\n    const raw = fs.readFileSync(guard.assert(journalFilePath(dataDir)), 'utf8');\n    lines = raw.split('\\n').filter((l) => l.trim()).length;\n  } catch {\n    return { needed: false, lines: 0 };\n  }\n  return { needed: lines >= threshold, lines };\n}\n\n/** Fold the live journal into a snapshot and shard the folded records into an\n * archive file. Returns a report; never throws on missing data (nothing to\n * fold is a no-op, reported as such). */\nexport function snapshotProfile(guard: PathGuard, dataDir: string, now = Date.now()): SnapshotReport {\n  const journalFile = journalFilePath(dataDir);\n  let raw = '';\n  try {\n    raw = fs.readFileSync(guard.assert(journalFile), 'utf8');\n  } catch {\n    return { ok: false, reason: 'no journal' };\n  }\n  const liveRecords = raw.split('\\n').filter((l) => l.trim());\n  if (liveRecords.length === 0) return { ok: false, reason: 'journal empty, nothing to fold' };\n\n  // Replay the CURRENT live journal only — prior snapshots + shards are\n  // already inside the accumulated view; the live tail is what we fold.\n  const replayed = replayJournal(guard, dataDir);\n  const lastTs = lastRecordTs(raw) ?? new Date(now).toISOString();\n  const snapshot: ProfileSnapshot = {\n    version: 1,\n    baselineTs: lastTs,\n    recordsFolded: replayed.records,\n    doc: replayed.doc,\n  };\n  saveJson(guard, snapshotFilePath(dataDir), snapshot);\n\n  // Shard: move the folded records out of the live journal. The shard is a\n  // closed file (never appended again); the live journal restarts empty. A\n  // torn shard write is tolerated by replay (corrupt lines are skipped).\n  const stamp = new Date(now).toISOString().replace(/[-:T]/g, '').slice(0, 15);\n  const archiveFile = `${ARCHIVE_PREFIX}${stamp}.jsonl`;\n  fs.writeFileSync(path.join(dataDir, archiveFile), liveRecords.join('\\n') + '\\n', 'utf8');\n  fs.writeFileSync(guard.assert(journalFile), '', 'utf8');\n\n  return {\n    ok: true,\n    baselineTs: lastTs,\n    folded: replayed.records,\n    archiveFile,\n    liveRemaining: 0,\n  };\n}\n\nfunction lastRecordTs(raw: string): string | null {\n  const lines = raw.split('\\n').filter((l) => l.trim());\n  for (let i = lines.length - 1; i >= 0; i--) {\n    try {\n      return String((JSON.parse(lines[i]!) as { ts?: string }).ts ?? '') || null;\n    } catch { /* skip a torn tail line */ }\n  }\n  return null;\n}\n\n/** Maintenance hook: fold when over threshold. Audits + never throws. */\nexport function snapshotIfDue(guard: PathGuard, dataDir: string, auditFile: string, why: string, now = Date.now()): void {\n  try {\n    const { needed, lines } = snapshotDue(guard, dataDir);\n    if (!needed) return;\n    const report = snapshotProfile(guard, dataDir, now);\n    appendAuditLine(auditFile, { event: 'profile_snapshot', why, lines, ...report });\n  } catch (e) {\n    try {\n      appendAuditLine(auditFile, { event: 'profile_snapshot_failed', why, error: String(e).slice(0, 160) });\n    } catch { /* audit must never break the beat */ }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,OAAO,QAAQ;AACf,OAAO,UAAU;AAaV,IAAM,qBAAqB;AAY3B,SAAS,YAAY,OAAkB,SAAiB,YAAY,oBAAwD;AACjI,MAAI,QAAQ;AACZ,MAAI;AACF,UAAM,MAAM,GAAG,aAAa,MAAM,OAAO,gBAAgB,OAAO,CAAC,GAAG,MAAM;AAC1E,YAAQ,IAAI,MAAM,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE;AAAA,EAClD,QAAQ;AACN,WAAO,EAAE,QAAQ,OAAO,OAAO,EAAE;AAAA,EACnC;AACA,SAAO,EAAE,QAAQ,SAAS,WAAW,MAAM;AAC7C;AAKO,SAAS,gBAAgB,OAAkB,SAAiB,MAAM,KAAK,IAAI,GAAmB;AACnG,QAAM,cAAc,gBAAgB,OAAO;AAC3C,MAAI,MAAM;AACV,MAAI;AACF,UAAM,GAAG,aAAa,MAAM,OAAO,WAAW,GAAG,MAAM;AAAA,EACzD,QAAQ;AACN,WAAO,EAAE,IAAI,OAAO,QAAQ,aAAa;AAAA,EAC3C;AACA,QAAM,cAAc,IAAI,MAAM,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC;AAC1D,MAAI,YAAY,WAAW,EAAG,QAAO,EAAE,IAAI,OAAO,QAAQ,iCAAiC;AAI3F,QAAM,WAAW,cAAc,OAAO,OAAO;AAC7C,QAAM,SAAS,aAAa,GAAG,KAAK,IAAI,KAAK,GAAG,EAAE,YAAY;AAC9D,QAAM,WAA4B;AAAA,IAChC,SAAS;AAAA,IACT,YAAY;AAAA,IACZ,eAAe,SAAS;AAAA,IACxB,KAAK,SAAS;AAAA,EAChB;AACA,WAAS,OAAO,iBAAiB,OAAO,GAAG,QAAQ;AAKnD,QAAM,QAAQ,IAAI,KAAK,GAAG,EAAE,YAAY,EAAE,QAAQ,UAAU,EAAE,EAAE,MAAM,GAAG,EAAE;AAC3E,QAAM,cAAc,GAAG,cAAc,GAAG,KAAK;AAC7C,KAAG,cAAc,KAAK,KAAK,SAAS,WAAW,GAAG,YAAY,KAAK,IAAI,IAAI,MAAM,MAAM;AACvF,KAAG,cAAc,MAAM,OAAO,WAAW,GAAG,IAAI,MAAM;AAEtD,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,YAAY;AAAA,IACZ,QAAQ,SAAS;AAAA,IACjB;AAAA,IACA,eAAe;AAAA,EACjB;AACF;AAEA,SAAS,aAAa,KAA4B;AAChD,QAAM,QAAQ,IAAI,MAAM,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC;AACpD,WAAS,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;AAC1C,QAAI;AACF,aAAO,OAAQ,KAAK,MAAM,MAAM,CAAC,CAAE,EAAsB,MAAM,EAAE,KAAK;AAAA,IACxE,QAAQ;AAAA,IAA8B;AAAA,EACxC;AACA,SAAO;AACT;AAGO,SAAS,cAAc,OAAkB,SAAiB,WAAmB,KAAa,MAAM,KAAK,IAAI,GAAS;AACvH,MAAI;AACF,UAAM,EAAE,QAAQ,MAAM,IAAI,YAAY,OAAO,OAAO;AACpD,QAAI,CAAC,OAAQ;AACb,UAAM,SAAS,gBAAgB,OAAO,SAAS,GAAG;AAClD,oBAAgB,WAAW,EAAE,OAAO,oBAAoB,KAAK,OAAO,GAAG,OAAO,CAAC;AAAA,EACjF,SAAS,GAAG;AACV,QAAI;AACF,sBAAgB,WAAW,EAAE,OAAO,2BAA2B,KAAK,OAAO,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;AAAA,IACtG,QAAQ;AAAA,IAAwC;AAAA,EAClD;AACF;","names":[]}

package/dist/chunk-VIZNIQLK.js

@@ -0,0 +1,472 @@
+import {
+  loadJson,
+  readText,
+  saveJson,
+  writeText
+} from "./chunk-IFTFDHZX.js";
+
+// src/core/audit-log.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/core/atomic-fs.ts
+import fs from "fs";
+import path from "path";
+import { randomUUID, randomFillSync } from "crypto";
+function tmpSibling(target, tag = "w") {
+  return path.join(
+    path.dirname(target),
+    `.${path.basename(target)}.${tag}-${randomUUID().slice(0, 8)}.tmp`
+  );
+}
+function atomicWriteFileSync(target, data) {
+  const tmp = tmpSibling(target);
+  try {
+    fs.writeFileSync(tmp, data);
+    fs.renameSync(tmp, target);
+  } finally {
+    fs.rmSync(tmp, { force: true });
+  }
+}
+function atomicWriteJsonSync(target, value) {
+  atomicWriteFileSync(target, JSON.stringify(value, null, 2));
+}
+function shredFileSync(target, passes = 3) {
+  const stat = fs.statSync(target);
+  if (!stat.isFile()) throw new Error(`shred: not a file: ${target}`);
+  const buf = Buffer.alloc(Math.max(stat.size, 1));
+  for (let i = 0; i < passes; i++) {
+    randomFillSync(buf);
+    fs.writeFileSync(target, buf);
+  }
+  fs.rmSync(target, { force: true });
+}
+
+// src/core/audit-log.ts
+function appendAuditLine(file, event) {
+  fs2.mkdirSync(path2.dirname(file), { recursive: true });
+  const line = JSON.stringify({ ts: event.ts ?? (/* @__PURE__ */ new Date()).toISOString(), ...event });
+  fs2.appendFileSync(file, line + "\n", "utf8");
+}
+function readAuditLines(file) {
+  if (!fs2.existsSync(file)) return [];
+  const out = [];
+  const raw = fs2.readFileSync(file, "utf8");
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      out.push({ ts: "", corrupt: true, raw: trimmed.slice(0, 200) });
+    }
+  }
+  return out;
+}
+function pruneAuditFile(file, maxAgeMs, now = Date.now()) {
+  if (!fs2.existsSync(file)) return 0;
+  const lines = readAuditLines(file);
+  const kept = lines.filter((e) => {
+    const ev = e;
+    const ts = Date.parse(ev.ts ?? "");
+    if (!Number.isFinite(ts)) return true;
+    return now - ts <= maxAgeMs;
+  });
+  const removed = lines.length - kept.length;
+  if (removed === 0) return 0;
+  const body = kept.map((e) => JSON.stringify(e)).join("\n");
+  atomicWriteFileSync(file, body ? body + "\n" : "");
+  return removed;
+}
+
+// src/profile/store.ts
+import path4 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import fs4 from "fs";
+
+// src/profile/types.ts
+var PARTITIONS = ["interest", "projects", "comm", "psy"];
+var CONFIDENCE_CAP = {
+  chat: 0.6,
+  screen: 0.4,
+  browse: 0.4,
+  hand: 1,
+  ledger: 0.6
+};
+function emptyProfile() {
+  return {
+    version: 1,
+    partitions: { interest: { entries: [] }, projects: { entries: [] }, comm: { entries: [] }, psy: { entries: [] } }
+  };
+}
+
+// src/profile/schema.ts
+import fs3 from "fs";
+import path3 from "path";
+function loadProfileSchema(paths) {
+  const userPath = path3.join(paths.settingsDir, "profile-schema.json");
+  const file = fs3.existsSync(userPath) ? userPath : path3.join(paths.configDir, "profile-schema.json");
+  try {
+    const raw = JSON.parse(fs3.readFileSync(file, "utf8"));
+    if (!raw.partitions) throw new Error("partitions missing");
+    return raw;
+  } catch (e) {
+    throw new Error(`profile-schema unreadable at ${file}: ${String(e)}`);
+  }
+}
+function checkAddAgainstSchema(schema, partition, topic, subTopic, nominated) {
+  const p = schema.partitions[partition];
+  if (!p) return { ok: false, reason: `partition not in schema: ${partition}`, temporal: "stable" };
+  const t = p.topics[topic];
+  if (!t) return { ok: false, reason: `topic not in schema: ${partition}/${topic}`, temporal: "stable" };
+  const st = t.subtopics[subTopic];
+  if (!st) return { ok: false, reason: `sub_topic not in schema: ${partition}/${topic}/${subTopic}`, temporal: "stable" };
+  const allowed = st.allowed && st.allowed.length > 0 ? st.allowed : ["stable"];
+  const def = st.default && allowed.includes(st.default) ? st.default : allowed[0];
+  if (!nominated) return { ok: true, temporal: def };
+  if (!allowed.includes(nominated)) {
+    return {
+      ok: false,
+      reason: `temporal "${nominated}" not allowed for ${partition}/${topic}/${subTopic} (allowed: ${allowed.join("|")})`,
+      temporal: def
+    };
+  }
+  return { ok: true, temporal: nominated };
+}
+
+// src/profile/store.ts
+var DAY_MS = 864e5;
+function profileFilePath(dataDir) {
+  return path4.join(dataDir, "profile.json");
+}
+function journalFilePath(dataDir) {
+  return path4.join(dataDir, "profile_journal.jsonl");
+}
+var SNAPSHOT_FILE = "profile_snapshot.json";
+var ARCHIVE_PREFIX = "profile_journal.archive-";
+function snapshotFilePath(dataDir) {
+  return path4.join(dataDir, SNAPSHOT_FILE);
+}
+function loadSnapshot(guard, dataDir) {
+  const snap = loadJson(guard, snapshotFilePath(dataDir));
+  if (!snap || snap.version !== 1 || typeof snap.baselineTs !== "string" || !snap.doc?.partitions) return null;
+  return snap;
+}
+function listArchiveFiles(guard, dataDir) {
+  try {
+    return fs4.readdirSync(guard.assert(dataDir)).filter((f) => f.startsWith(ARCHIVE_PREFIX) && f.endsWith(".jsonl")).sort();
+  } catch {
+    return [];
+  }
+}
+function replayText(doc, text, baselineTs, stats) {
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    try {
+      const rec = JSON.parse(trimmed);
+      if (baselineTs && rec.ts && String(rec.ts) <= baselineTs) continue;
+      for (const op of rec.applied ?? []) applyOpPermissive(doc, op, rec.ts);
+      stats.records += 1;
+    } catch {
+      const isLast = lines.slice(i + 1).every((l) => !l.trim());
+      if (stats.isLive && isLast) {
+        stats.truncatedTail = lines.length - i;
+        break;
+      }
+    }
+  }
+}
+function replayJournal(guard, dataDir) {
+  const snap = loadSnapshot(guard, dataDir);
+  const doc = snap ? snap.doc : emptyProfile();
+  const baselineTs = snap?.baselineTs ?? "";
+  const stats = { records: snap?.recordsFolded ?? 0, truncatedTail: 0, isLive: false };
+  for (const file of listArchiveFiles(guard, dataDir)) {
+    try {
+      replayText(doc, fs4.readFileSync(path4.join(dataDir, file), "utf8"), baselineTs, { records: 0, truncatedTail: 0, isLive: false });
+    } catch {
+    }
+  }
+  stats.isLive = true;
+  replayText(doc, readText(guard, journalFilePath(dataDir), ""), baselineTs, stats);
+  return { doc, truncatedTail: stats.truncatedTail, records: stats.records };
+}
+function loadProfile(guard, file) {
+  const doc = loadJson(guard, file);
+  if (!doc || !doc.partitions) return emptyProfile();
+  for (const p of PARTITIONS) {
+    if (!doc.partitions[p]) doc.partitions[p] = { entries: [] };
+  }
+  return doc;
+}
+function parseIso(v) {
+  const t = Date.parse(v);
+  return Number.isFinite(t) ? t : 0;
+}
+function refExists(guard, dataDir, ref) {
+  const base = ref.split("#")[0] ?? "";
+  if (!base) return false;
+  const target = path4.join(dataDir, base);
+  try {
+    return fs4.existsSync(guard.assert(target));
+  } catch {
+    return false;
+  }
+}
+function capForKinds(kinds) {
+  if (kinds.length === 0) return 0.4;
+  return Math.min(...kinds.map((k) => CONFIDENCE_CAP[k] ?? 0.4));
+}
+function findActive(doc, id) {
+  for (const p of PARTITIONS) {
+    const hit = doc.partitions[p].entries.find((e) => e.id === id && e.validTo === null);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function applyOpsToDoc(guard, dataDir, doc, ops, schema, policy, now) {
+  const applied = [];
+  const rejected = [];
+  const nowIso = new Date(now).toISOString();
+  for (const op of ops) {
+    if (op.op === "NOOP") {
+      applied.push(op);
+      continue;
+    }
+    if (op.op === "ADD") {
+      if (op.partition === "psy" && !policy.profile.psyEnabled) {
+        rejected.push({ op, reason: "psy partition is disabled" });
+        continue;
+      }
+      const check = checkAddAgainstSchema(schema, op.partition, op.topic, op.subTopic, op.temporal);
+      if (!check.ok) {
+        rejected.push({ op, reason: check.reason });
+        continue;
+      }
+      if (!op.evidence || op.evidence.length === 0) {
+        rejected.push({ op, reason: "ADD without evidence (no provenance, axiom 1)" });
+        continue;
+      }
+      const badRef = op.evidence.find((e) => !refExists(guard, dataDir, e.ref));
+      if (badRef) {
+        rejected.push({ op, reason: `evidence ref does not resolve: ${badRef.ref}` });
+        continue;
+      }
+      const cap = capForKinds(op.evidence.map((e) => e.kind));
+      const active = doc.partitions[op.partition].entries.filter((e) => e.validTo === null);
+      if (active.length >= policy.profile.partitionCap) {
+        rejected.push({ op, reason: `partition ${op.partition} at cap (${policy.profile.partitionCap}); converge first` });
+        continue;
+      }
+      dbSeq += 1;
+      const entry = {
+        id: `p${dbSeq.toString(36)}${randomUUID2().slice(0, 4)}`,
+        partition: op.partition,
+        topic: op.topic,
+        subTopic: op.subTopic,
+        content: op.content.trim(),
+        confidence: Math.min(op.confidence ?? cap, cap),
+        temporal: check.temporal,
+        validFrom: nowIso,
+        validTo: null,
+        supersededBy: null,
+        evidence: op.evidence,
+        createdAt: nowIso,
+        updatedAt: nowIso,
+        updateCount: 0
+      };
+      op.assignedId = entry.id;
+      doc.partitions[op.partition].entries.push(entry);
+      applied.push(op);
+      continue;
+    }
+    if (op.op === "UPDATE") {
+      const entry = findActive(doc, op.id);
+      if (!entry) {
+        rejected.push({ op, reason: `unknown or inactive entry: ${op.id}` });
+        continue;
+      }
+      if (op.changes.content !== void 0) entry.content = op.changes.content.trim();
+      if (op.changes.confidence !== void 0) {
+        const cap = capForKinds(entry.evidence.map((e) => e.kind));
+        if (op.changes.confidence > entry.confidence && entry.evidence.length < 2) {
+          rejected.push({ op, reason: "confidence upgrade requires a second confirming observation" });
+          continue;
+        }
+        entry.confidence = Math.min(op.changes.confidence, cap);
+      }
+      entry.updatedAt = nowIso;
+      entry.updateCount += 1;
+      applied.push(op);
+      continue;
+    }
+    if (op.op === "INVALIDATE") {
+      const entry = findActive(doc, op.id);
+      if (!entry) {
+        rejected.push({ op, reason: `unknown or inactive entry: ${op.id}` });
+        continue;
+      }
+      if (entry.temporal === "volatile") {
+        rejected.push({ op, reason: "volatile expiry is code-owned (time-driven), not LLM-nominated" });
+        continue;
+      }
+      const hasNewObservation = (op.evidence ?? []).length > 0 && (op.evidence ?? []).some((e) => parseIso(e.at) > parseIso(entry.evidence[entry.evidence.length - 1]?.at ?? ""));
+      if (!hasNewObservation) {
+        rejected.push({ op, reason: "stable INVALIDATE requires a newer contradicting observation" });
+        continue;
+      }
+      entry.validTo = nowIso;
+      entry.supersededBy = null;
+      entry.updatedAt = nowIso;
+      entry.updateCount += 1;
+      if (op.evidence) entry.evidence.push(...op.evidence);
+      applied.push(op);
+      continue;
+    }
+  }
+  return { applied, rejected };
+}
+var dbSeq = 0;
+function runDeterministicAging(doc, policy, now) {
+  const nowIso = new Date(now).toISOString();
+  let volatileExpired = 0;
+  let lowActivityMarked = 0;
+  for (const p of PARTITIONS) {
+    for (const e of doc.partitions[p].entries) {
+      if (e.validTo !== null) continue;
+      const lastEvidence = Math.max(...e.evidence.map((x) => parseIso(x.at)), parseIso(e.updatedAt));
+      if (e.temporal === "volatile") {
+        if (now - lastEvidence > policy.profile.volatileDays * DAY_MS) {
+          e.validTo = nowIso;
+          e.updatedAt = nowIso;
+          e.updateCount += 1;
+          volatileExpired += 1;
+        }
+      } else if (!e.lowActivity && now - lastEvidence > policy.profile.stableLowActivityDays * DAY_MS) {
+        e.lowActivity = true;
+        lowActivityMarked += 1;
+      }
+    }
+  }
+  return { volatileExpired, lowActivityMarked };
+}
+function persistWithJournal(guard, dataDir, doc, record) {
+  saveJson(guard, profileFilePath(dataDir), doc);
+  const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...record });
+  const journal = journalFilePath(dataDir);
+  try {
+    fs4.appendFileSync(guard.assert(journal), line + "\n", "utf8");
+  } catch {
+    fs4.mkdirSync(dataDir, { recursive: true });
+    fs4.appendFileSync(guard.assert(journal), line + "\n", "utf8");
+  }
+}
+function applyOpPermissive(doc, op, ts) {
+  if (op.op === "ADD") {
+    dbSeq += 1;
+    doc.partitions[op.partition].entries.push({
+      id: op.assignedId ?? `r${dbSeq.toString(36)}${randomUUID2().slice(0, 4)}`,
+      partition: op.partition,
+      topic: op.topic,
+      subTopic: op.subTopic,
+      content: op.content,
+      confidence: op.confidence ?? 0.5,
+      temporal: op.temporal ?? "stable",
+      validFrom: ts,
+      validTo: null,
+      supersededBy: null,
+      evidence: op.evidence,
+      createdAt: ts,
+      updatedAt: ts,
+      updateCount: 0
+    });
+    return;
+  }
+  if (op.op === "UPDATE") {
+    const e = [...PARTITIONS].flatMap((p) => doc.partitions[p].entries).find((x) => x.id === op.id);
+    if (e) {
+      if (op.changes.content !== void 0) e.content = op.changes.content;
+      if (op.changes.confidence !== void 0) e.confidence = op.changes.confidence;
+      e.updatedAt = ts;
+      e.updateCount += 1;
+    }
+    return;
+  }
+  if (op.op === "INVALIDATE") {
+    const e = [...PARTITIONS].flatMap((p) => doc.partitions[p].entries).find((x) => x.id === op.id);
+    if (e) {
+      e.validTo = ts;
+      e.updatedAt = ts;
+      e.updateCount += 1;
+    }
+  }
+}
+function verifyProfile(guard, dataDir) {
+  const replayed = replayJournal(guard, dataDir);
+  const onDisk = loadProfile(guard, profileFilePath(dataDir));
+  const strip = (doc) => JSON.stringify(doc.partitions, (k, v) => ["id", "supersededBy", "validFrom", "createdAt", "updatedAt", "retiredAt"].includes(k) ? "<norm>" : v);
+  const ok = strip(replayed.doc) === strip(onDisk);
+  if (ok) return { ok: true, truncatedTail: replayed.truncatedTail, records: replayed.records };
+  const diskIds = new Set([...PARTITIONS].flatMap((p) => onDisk.partitions[p].entries.map((e) => e.content)));
+  const replayIds = new Set([...PARTITIONS].flatMap((p) => replayed.doc.partitions[p].entries.map((e) => e.content)));
+  const onlyDisk = [...diskIds].find((c) => !replayIds.has(c));
+  const onlyReplay = [...replayIds].find((c) => !diskIds.has(c));
+  return {
+    ok: false,
+    firstDivergence: {
+      id: onlyDisk ?? onlyReplay ?? "(content)",
+      expected: onlyReplay ? "absent in journal replay" : "present in journal replay",
+      actual: onlyDisk ? "present on disk" : "absent on disk"
+    },
+    truncatedTail: replayed.truncatedTail,
+    records: replayed.records
+  };
+}
+function rebuildProfile(guard, dataDir, opts = {}) {
+  const replayed = replayJournal(guard, dataDir);
+  const target = profileFilePath(dataDir);
+  if (opts.check) {
+    const onDisk = loadProfile(guard, target);
+    const same = JSON.stringify(onDisk) === JSON.stringify(replayed.doc);
+    return {
+      ok: same,
+      truncatedTail: replayed.truncatedTail,
+      records: replayed.records,
+      wrote: false,
+      diffSummary: same ? "no diff" : "materialized view differs from journal replay"
+    };
+  }
+  saveJson(guard, target, replayed.doc);
+  if (replayed.truncatedTail > 0) {
+    writeText(
+      guard,
+      path4.join(dataDir, "logs", "rebuild-report.txt"),
+      `rebuild truncated ${replayed.truncatedTail} torn line(s) at journal tail; ${replayed.records} records applied
+`
+    );
+  }
+  return { ok: true, truncatedTail: replayed.truncatedTail, records: replayed.records, wrote: true };
+}
+
+export {
+  atomicWriteJsonSync,
+  shredFileSync,
+  appendAuditLine,
+  readAuditLines,
+  pruneAuditFile,
+  loadProfileSchema,
+  profileFilePath,
+  journalFilePath,
+  ARCHIVE_PREFIX,
+  snapshotFilePath,
+  replayJournal,
+  loadProfile,
+  applyOpsToDoc,
+  runDeterministicAging,
+  persistWithJournal,
+  verifyProfile,
+  rebuildProfile
+};
+//# sourceMappingURL=chunk-VIZNIQLK.js.map