@remnic/core 1.1.30 → 9.3.515

package/dist/{chunk-WIICJPET.js → chunk-DEUNUKTD.js}

@@ -18,9 +18,11 @@ function emitGraphEvent(memoryDir, type, payload) {
     payload
   };
   const bus = getGraphEventBus(memoryDir);
-  try {
-    bus.emit("graph-event", event);
-  } catch {
+  for (const listener of bus.listeners("graph-event")) {
+    try {
+      listener(event);
+    } catch {
+    }
   }
 }
 function subscribeGraphEvents(memoryDir, listener) {
@@ -42,4 +44,4 @@ export {
   subscribeGraphEvents,
   destroyGraphEventBus
 };
-//# sourceMappingURL=chunk-WIICJPET.js.map
+//# sourceMappingURL=chunk-DEUNUKTD.js.map

package/dist/{chunk-WIICJPET.js.map → chunk-DEUNUKTD.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/graph-events.ts"],"sourcesContent":["/**\n * In-process EventEmitter for graph mutation events (issue #691 PR 5/5).\n *\n * The singleton is keyed by memoryDir so multiple orchestrator instances in\n * the same process get distinct event buses (CLAUDE.md rule 11: scope globals\n * per service).  The SSE handler in access-http.ts subscribes to the bus for\n * the resolved namespace and fans out to connected clients.\n *\n * Event types mirror the five mutations the graph layer can produce:\n *   node-added    — a memory file was referenced for the first time\n *   node-updated  — a memory file's metadata changed\n *   edge-added    — a new edge was appended\n *   edge-updated  — an existing edge's confidence/weight was modified\n *   edge-removed  — an edge was pruned (e.g. by decay maintenance)\n *\n * The `GraphEventBus` interface is intentionally narrow so nothing outside\n * this module needs to import Node.js EventEmitter directly.\n */\n\nimport { EventEmitter } from \"node:events\";\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\nexport type GraphEventType =\n  | \"node-added\"\n  | \"node-updated\"\n  | \"edge-added\"\n  | \"edge-updated\"\n  | \"edge-removed\";\n\nexport interface GraphEvent {\n  type: GraphEventType;\n  /** Memory dir that owns this event (absolute path). */\n  memoryDir: string;\n  /** ISO timestamp of the event. */\n  ts: string;\n  /** Payload depends on event type — always serialisable to JSON. */\n  payload: Record<string, unknown>;\n}\n\nexport interface NodeAddedPayload {\n  nodeId: string;   // relative memory path\n  kind: string;\n  label: string;\n  lastUpdated: string;\n}\n\nexport interface NodeUpdatedPayload {\n  nodeId: string;\n  kind: string;\n  label: string;\n  lastUpdated: string;\n}\n\nexport interface EdgeAddedPayload {\n  source: string;\n  target: string;\n  kind: string;\n  weight: number;\n  label: string;\n  confidence: number;\n}\n\nexport interface EdgeUpdatedPayload {\n  source: string;\n  target: string;\n  kind: string;\n  weight: number;\n  confidence: number;\n}\n\nexport interface EdgeRemovedPayload {\n  source: string;\n  target: string;\n  kind: string;\n}\n\n// ---------------------------------------------------------------------------\n// Per-memoryDir singleton bus\n// ---------------------------------------------------------------------------\n\nconst buses = new Map<string, EventEmitter>();\n\n/**\n * Return (or lazily create) the event bus for the given memoryDir.\n * The same bus is shared by the write side (graph.ts → appendEdge hooks) and\n * the read side (EngramAccessHttpServer SSE handler).\n */\nexport function getGraphEventBus(memoryDir: string): EventEmitter {\n  let bus = buses.get(memoryDir);\n  if (!bus) {\n    bus = new EventEmitter();\n    // Remove the default listener-count warning — SSE clients may hold many\n    // concurrent connections. Each SSE client registers one \"graph-event\"\n    // listener; warn only when an unreasonably high count suggests a leak.\n    bus.setMaxListeners(200);\n    buses.set(memoryDir, bus);\n  }\n  return bus;\n}\n\n/**\n * Emit a single graph event onto the bus for memoryDir.\n * Fails open: any listener that throws is caught so one bad client can't\n * crash the extraction pipeline.\n */\nexport function emitGraphEvent(\n  memoryDir: string,\n  type: GraphEventType,\n  payload: Record<string, unknown>,\n): void {\n  const event: GraphEvent = {\n    type,\n    memoryDir,\n    ts: new Date().toISOString(),\n    payload,\n  };\n  const bus = getGraphEventBus(memoryDir);\n  try {\n    bus.emit(\"graph-event\", event);\n  } catch {\n    // fail-open: never propagate listener errors to the write path\n  }\n}\n\n/**\n * Subscribe to graph events for a given memoryDir.\n * Returns an unsubscribe function.\n */\nexport function subscribeGraphEvents(\n  memoryDir: string,\n  listener: (event: GraphEvent) => void,\n): () => void {\n  const bus = getGraphEventBus(memoryDir);\n  bus.on(\"graph-event\", listener);\n  return () => bus.off(\"graph-event\", listener);\n}\n\n/**\n * Remove all listeners and the bus entry for a memoryDir.\n * Useful for tests that spin up isolated memory dirs.\n */\nexport function destroyGraphEventBus(memoryDir: string): void {\n  const bus = buses.get(memoryDir);\n  if (bus) {\n    bus.removeAllListeners();\n    buses.delete(memoryDir);\n  }\n}\n"],"mappings":";AAmBA,SAAS,oBAAoB;AAgE7B,IAAM,QAAQ,oBAAI,IAA0B;AAOrC,SAAS,iBAAiB,WAAiC;AAChE,MAAI,MAAM,MAAM,IAAI,SAAS;AAC7B,MAAI,CAAC,KAAK;AACR,UAAM,IAAI,aAAa;AAIvB,QAAI,gBAAgB,GAAG;AACvB,UAAM,IAAI,WAAW,GAAG;AAAA,EAC1B;AACA,SAAO;AACT;AAOO,SAAS,eACd,WACA,MACA,SACM;AACN,QAAM,QAAoB;AAAA,IACxB;AAAA,IACA;AAAA,IACA,KAAI,oBAAI,KAAK,GAAE,YAAY;AAAA,IAC3B;AAAA,EACF;AACA,QAAM,MAAM,iBAAiB,SAAS;AACtC,MAAI;AACF,QAAI,KAAK,eAAe,KAAK;AAAA,EAC/B,QAAQ;AAAA,EAER;AACF;AAMO,SAAS,qBACd,WACA,UACY;AACZ,QAAM,MAAM,iBAAiB,SAAS;AACtC,MAAI,GAAG,eAAe,QAAQ;AAC9B,SAAO,MAAM,IAAI,IAAI,eAAe,QAAQ;AAC9C;AAMO,SAAS,qBAAqB,WAAyB;AAC5D,QAAM,MAAM,MAAM,IAAI,SAAS;AAC/B,MAAI,KAAK;AACP,QAAI,mBAAmB;AACvB,UAAM,OAAO,SAAS;AAAA,EACxB;AACF;","names":[]}
+{"version":3,"sources":["../src/graph-events.ts"],"sourcesContent":["/**\n * In-process EventEmitter for graph mutation events (issue #691 PR 5/5).\n *\n * The singleton is keyed by memoryDir so multiple orchestrator instances in\n * the same process get distinct event buses (CLAUDE.md rule 11: scope globals\n * per service).  The SSE handler in access-http.ts subscribes to the bus for\n * the resolved namespace and fans out to connected clients.\n *\n * Event types mirror the five mutations the graph layer can produce:\n *   node-added    — a memory file was referenced for the first time\n *   node-updated  — a memory file's metadata changed\n *   edge-added    — a new edge was appended\n *   edge-updated  — an existing edge's confidence/weight was modified\n *   edge-removed  — an edge was pruned (e.g. by decay maintenance)\n *\n * The `GraphEventBus` interface is intentionally narrow so nothing outside\n * this module needs to import Node.js EventEmitter directly.\n */\n\nimport { EventEmitter } from \"node:events\";\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\nexport type GraphEventType =\n  | \"node-added\"\n  | \"node-updated\"\n  | \"edge-added\"\n  | \"edge-updated\"\n  | \"edge-removed\";\n\nexport interface GraphEvent {\n  type: GraphEventType;\n  /** Memory dir that owns this event (absolute path). */\n  memoryDir: string;\n  /** ISO timestamp of the event. */\n  ts: string;\n  /** Payload depends on event type — always serialisable to JSON. */\n  payload: Record<string, unknown>;\n}\n\nexport interface NodeAddedPayload {\n  nodeId: string;   // relative memory path\n  kind: string;\n  label: string;\n  lastUpdated: string;\n}\n\nexport interface NodeUpdatedPayload {\n  nodeId: string;\n  kind: string;\n  label: string;\n  lastUpdated: string;\n}\n\nexport interface EdgeAddedPayload {\n  source: string;\n  target: string;\n  kind: string;\n  weight: number;\n  label: string;\n  confidence: number;\n}\n\nexport interface EdgeUpdatedPayload {\n  source: string;\n  target: string;\n  kind: string;\n  weight: number;\n  confidence: number;\n}\n\nexport interface EdgeRemovedPayload {\n  source: string;\n  target: string;\n  kind: string;\n}\n\n// ---------------------------------------------------------------------------\n// Per-memoryDir singleton bus\n// ---------------------------------------------------------------------------\n\nconst buses = new Map<string, EventEmitter>();\n\n/**\n * Return (or lazily create) the event bus for the given memoryDir.\n * The same bus is shared by the write side (graph.ts → appendEdge hooks) and\n * the read side (EngramAccessHttpServer SSE handler).\n */\nexport function getGraphEventBus(memoryDir: string): EventEmitter {\n  let bus = buses.get(memoryDir);\n  if (!bus) {\n    bus = new EventEmitter();\n    // Remove the default listener-count warning — SSE clients may hold many\n    // concurrent connections. Each SSE client registers one \"graph-event\"\n    // listener; warn only when an unreasonably high count suggests a leak.\n    bus.setMaxListeners(200);\n    buses.set(memoryDir, bus);\n  }\n  return bus;\n}\n\n/**\n * Emit a single graph event onto the bus for memoryDir.\n * Fails open: any listener that throws is caught so one bad client can't\n * crash the extraction pipeline.\n */\nexport function emitGraphEvent(\n  memoryDir: string,\n  type: GraphEventType,\n  payload: Record<string, unknown>,\n): void {\n  const event: GraphEvent = {\n    type,\n    memoryDir,\n    ts: new Date().toISOString(),\n    payload,\n  };\n  const bus = getGraphEventBus(memoryDir);\n  for (const listener of bus.listeners(\"graph-event\")) {\n    try {\n      (listener as (event: GraphEvent) => void)(event);\n    } catch {\n      // fail-open: never let one subscriber block later listeners or writes\n    }\n  }\n}\n\n/**\n * Subscribe to graph events for a given memoryDir.\n * Returns an unsubscribe function.\n */\nexport function subscribeGraphEvents(\n  memoryDir: string,\n  listener: (event: GraphEvent) => void,\n): () => void {\n  const bus = getGraphEventBus(memoryDir);\n  bus.on(\"graph-event\", listener);\n  return () => bus.off(\"graph-event\", listener);\n}\n\n/**\n * Remove all listeners and the bus entry for a memoryDir.\n * Useful for tests that spin up isolated memory dirs.\n */\nexport function destroyGraphEventBus(memoryDir: string): void {\n  const bus = buses.get(memoryDir);\n  if (bus) {\n    bus.removeAllListeners();\n    buses.delete(memoryDir);\n  }\n}\n"],"mappings":";AAmBA,SAAS,oBAAoB;AAgE7B,IAAM,QAAQ,oBAAI,IAA0B;AAOrC,SAAS,iBAAiB,WAAiC;AAChE,MAAI,MAAM,MAAM,IAAI,SAAS;AAC7B,MAAI,CAAC,KAAK;AACR,UAAM,IAAI,aAAa;AAIvB,QAAI,gBAAgB,GAAG;AACvB,UAAM,IAAI,WAAW,GAAG;AAAA,EAC1B;AACA,SAAO;AACT;AAOO,SAAS,eACd,WACA,MACA,SACM;AACN,QAAM,QAAoB;AAAA,IACxB;AAAA,IACA;AAAA,IACA,KAAI,oBAAI,KAAK,GAAE,YAAY;AAAA,IAC3B;AAAA,EACF;AACA,QAAM,MAAM,iBAAiB,SAAS;AACtC,aAAW,YAAY,IAAI,UAAU,aAAa,GAAG;AACnD,QAAI;AACF,MAAC,SAAyC,KAAK;AAAA,IACjD,QAAQ;AAAA,IAER;AAAA,EACF;AACF;AAMO,SAAS,qBACd,WACA,UACY;AACZ,QAAM,MAAM,iBAAiB,SAAS;AACtC,MAAI,GAAG,eAAe,QAAQ;AAC9B,SAAO,MAAM,IAAI,IAAI,eAAe,QAAQ;AAC9C;AAMO,SAAS,qBAAqB,WAAyB;AAC5D,QAAM,MAAM,MAAM,IAAI,SAAS;AAC/B,MAAI,KAAK;AACP,QAAI,mBAAmB;AACvB,UAAM,OAAO,SAAS;AAAA,EACxB;AACF;","names":[]}

package/dist/{chunk-ZYVPLJ4T.js → chunk-DHGSZ3UD.js}

@@ -1,20 +1,20 @@
 import {
   createVersion
-} from "./chunk-FAAFWE4G.js";
+} from "./chunk-ALEPI75L.js";
 import {
   parseExportBundle
 } from "./chunk-WEHSQBFR.js";
 import {
   decryptCapsuleFileInMemory,
   isEncryptedCapsuleFile
-} from "./chunk-KNKUID7G.js";
+} from "./chunk-X7Y7WX73.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot,
   fromPosixRelPath,
   isPathInsideRoot,
   sha256String
-} from "./chunk-AGZQD76C.js";
+} from "./chunk-GCGJW34D.js";
 
 // src/transfer/capsule-import.ts
 import { lstat, mkdir, readFile, realpath, stat, writeFile } from "fs/promises";
@@ -34,12 +34,14 @@ async function importCapsule(opts) {
   const encrypted = await isEncryptedCapsuleFile(archiveAbs);
   let raw;
   if (encrypted) {
-    if (!opts.memoryDir) {
+    if (!opts.memoryDir && !opts.passphrase) {
       throw new Error(
-        `importCapsule: archive is encrypted but 'memoryDir' was not provided. Pass the memory directory so the secure-store key can be retrieved, or run \`remnic secure-store unlock\` before importing.`
+        `importCapsule: archive is encrypted but 'memoryDir' was not provided. Pass the memory directory so the secure-store key can be retrieved, provide the original passphrase for a format-v2 archive restore, or run \`remnic secure-store unlock\` before importing.`
       );
     }
-    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir);
+    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir, {
+      passphrase: opts.passphrase
+    });
   } else {
     raw = await readFile(archiveAbs);
   }
@@ -225,4 +227,4 @@ function mintForkId(capsuleId, originalId, now) {
 export {
   importCapsule
 };
-//# sourceMappingURL=chunk-ZYVPLJ4T.js.map
+//# sourceMappingURL=chunk-DHGSZ3UD.js.map

package/dist/chunk-DHGSZ3UD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/capsule-import.ts"],"sourcesContent":["import { lstat, mkdir, readFile, realpath, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { gunzipSync } from \"node:zlib\";\nimport {\n  createVersion,\n  type VersioningConfig,\n  type VersioningLogger,\n} from \"../page-versioning.js\";\nimport {\n  assertIsDirectoryNotSymlink,\n  assertRealpathInsideRoot,\n  fromPosixRelPath,\n  isPathInsideRoot,\n  sha256String,\n} from \"./fs-utils.js\";\nimport {\n  parseExportBundle,\n  type CapsuleBlock,\n  type ExportManifestV2,\n  type ExportMemoryRecordV1,\n} from \"./types.js\";\nimport { isEncryptedCapsuleFile, decryptCapsuleFileInMemory } from \"./capsule-crypto.js\";\n\n/**\n * Conflict-resolution mode for {@link importCapsule}. Inverse of the\n * `mode` selector in PR 4/6's CLI surface.\n *\n *  - `\"skip\"` (default) — when a target file already exists at the same\n *    relative path, leave it untouched. The corresponding record is reported\n *    via {@link ImportCapsuleResult.skipped}.\n *  - `\"overwrite\"` — when a target file exists, snapshot the prior content\n *    via {@link createVersion} (gotcha #54: write-before-delete; gotcha #25:\n *    don't destroy old state until new state is confirmed), then write the\n *    incoming content. The snapshot's `note` includes the source capsule id.\n *  - `\"fork\"` — never overwrite. Every record is rebased under\n *    `forks/<capsule-id>/<original-path>` and any YAML-frontmatter `id:`\n *    field is rewritten to a new fork-scoped value. The original tree is\n *    not touched.\n *\n * The mode is selected once per call and applied uniformly to every record\n * in the bundle. Mixed-mode imports are not supported by design — that\n * would let a single corrupted manifest silently land partial state.\n */\nexport type ImportCapsuleMode = \"skip\" | \"overwrite\" | \"fork\";\n\n/**\n * Options accepted by {@link importCapsule}.\n *\n * `archivePath` — absolute or cwd-relative path to a `.capsule.json.gz`\n * archive produced by `exportCapsule`. The archive must contain a V2\n * bundle (`schemaVersion: 2`); V1 archives are rejected.\n *\n * `root` — absolute or cwd-relative path to the memory directory that\n * will receive the records. Must be an existing directory.\n *\n * `mode` — see {@link ImportCapsuleMode}. Defaults to `\"skip\"`.\n *\n * `versioning` — optional page-versioning config used by `mode: \"overwrite\"`\n * to snapshot prior content before replacing it. Snapshots are skipped when\n * not provided or when `enabled === false`. Tests pass an enabled config\n * to assert snapshot creation; production callers thread the\n * orchestrator's resolved versioning config.\n *\n * `log` — optional logger forwarded to {@link createVersion}.\n *\n * `now` — optional clock override (ms epoch) used to derive deterministic\n * fork ids in tests. Production callers omit this.\n */\nexport interface ImportCapsuleOptions {\n  archivePath: string;\n  root: string;\n  mode?: ImportCapsuleMode;\n  versioning?: VersioningConfig;\n  log?: VersioningLogger;\n  now?: number;\n  /**\n   * Memory directory whose secure-store keyring is used when the archive is\n   * encrypted. Required when `archivePath` ends with `.enc` or when the file\n   * starts with the REMNIC-ENC magic header. If `memoryDir` is omitted and the\n   * archive turns out to be encrypted, `importCapsule` throws a clear error\n   * rather than silently failing.\n   *\n   * When provided and the archive is NOT encrypted, the value is ignored.\n   */\n  memoryDir?: string;\n  /**\n   * Original secure-store passphrase for encrypted format-v2 archives. When\n   * supplied, the importer derives the archive key from the embedded KDF\n   * header, enabling restore without the source machine's unlocked keyring.\n   */\n  passphrase?: string;\n}\n\nexport interface ImportCapsuleSkippedRecord {\n  /** Original record path (capsule-relative, posix). */\n  path: string;\n  /**\n   * Why this record was not written.\n   *\n   * `\"exists\"` — the target path already existed and the mode was `\"skip\"`,\n   * OR the computed fork path already existed in fork mode.\n   *\n   * `\"checksum_mismatch\"` is intentionally absent: a checksum failure aborts\n   * the import entirely (fail-closed) rather than skipping the offending\n   * record, so no `ImportCapsuleSkippedRecord` is ever produced for it.\n   */\n  reason: \"exists\";\n}\n\nexport interface ImportCapsuleImportedRecord {\n  /** Capsule-relative posix path the record carried. */\n  sourcePath: string;\n  /** Memory-dir-relative posix path the file was written to. */\n  targetPath: string;\n  /** Whether a prior version snapshot was taken (overwrite-mode only). */\n  snapshotted: boolean;\n  /** Whether the frontmatter `id:` field was rewritten (fork-mode only). */\n  rewroteId: boolean;\n}\n\nexport interface ImportCapsuleResult {\n  /** Records that landed on disk. */\n  imported: ImportCapsuleImportedRecord[];\n  /** Records that were not written. */\n  skipped: ImportCapsuleSkippedRecord[];\n  /** The manifest decoded from the archive. */\n  manifest: ExportManifestV2;\n}\n\n/**\n * Pure async function that imports a capsule archive into a memory\n * directory. Inverse of {@link import(\"./capsule-export.js\").exportCapsule}.\n *\n * Sequence:\n *   1. Read + gunzip + JSON.parse the archive.\n *   2. Validate the bundle through `parseExportBundle` (V1 rejected).\n *   3. Verify each record's content sha256 against the manifest entry.\n *      Any mismatch aborts the import BEFORE any file is written —\n *      partial-write recovery would require a full rollback we cannot\n *      offer cheaply, so we fail closed (gotcha #25).\n *   4. Apply the selected {@link ImportCapsuleMode} to every record.\n *\n * Determinism guarantees:\n *  - Imported records are returned sorted by `sourcePath`.\n *  - Skipped records are returned sorted by `path`.\n *  - Fork-mode rebases under a stable `forks/<capsule-id>/` prefix so\n *    repeated fork imports of the same capsule shape land in predictable\n *    locations (subsequent fork imports still skip-on-exist because the\n *    target tree is computed from the source path).\n */\nexport async function importCapsule(\n  opts: ImportCapsuleOptions,\n): Promise<ImportCapsuleResult> {\n  const archiveAbs = path.resolve(opts.archivePath);\n  const rootAbs = path.resolve(opts.root);\n  await assertIsDirectoryNotSymlink(rootAbs, \"importCapsule\", \"root\");\n\n  const mode: ImportCapsuleMode = opts.mode ?? \"skip\";\n  // Reject unknown mode values up-front (rule 51). TypeScript callers get a\n  // compile-time check via the union type; JS/CLI callers get a runtime error\n  // here before any write begins — not a silent destructive fallback.\n  if (mode !== \"skip\" && mode !== \"overwrite\" && mode !== \"fork\") {\n    throw new Error(\n      `importCapsule: unknown mode ${JSON.stringify(mode)}; expected \"skip\", \"overwrite\", or \"fork\"`,\n    );\n  }\n\n  // Auto-detect encrypted archives. If the file ends with `.enc` or starts\n  // with the REMNIC-ENC magic header, decrypt it first before gunzip+parse.\n  // Rule 48: default is \"not encrypted\"; we only attempt decryption when the\n  // header is definitively present, never on ambiguous content.\n  const encrypted = await isEncryptedCapsuleFile(archiveAbs);\n  let raw: Buffer;\n  if (encrypted) {\n    if (!opts.memoryDir && !opts.passphrase) {\n      throw new Error(\n        `importCapsule: archive is encrypted but 'memoryDir' was not provided. ` +\n          `Pass the memory directory so the secure-store key can be retrieved, ` +\n          `provide the original passphrase for a format-v2 archive restore, ` +\n          `or run \\`remnic secure-store unlock\\` before importing.`,\n      );\n    }\n    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir, {\n      passphrase: opts.passphrase,\n    });\n  } else {\n    raw = await readFile(archiveAbs);\n  }\n  const json = gunzipSync(raw).toString(\"utf-8\");\n  let parsedJson: unknown;\n  try {\n    parsedJson = JSON.parse(json);\n  } catch (cause) {\n    throw new Error(\n      `importCapsule: archive is not valid JSON after gunzip: ${archiveAbs}`,\n      { cause: cause as Error },\n    );\n  }\n\n  const parsed = parseExportBundle(parsedJson);\n  if (parsed.capsuleVersion !== 2) {\n    // PR 1/6 ships a V1 reader; capsule import is V2-only by design. A V1\n    // bundle does not carry a capsule block, so fork-mode (which depends on\n    // `capsule.id` for the rebase prefix) cannot work. Reject up-front per\n    // gotcha #51 instead of silently routing to a different code path.\n    throw new Error(\n      \"importCapsule: archive is V1; only V2 capsule archives are supported\",\n    );\n  }\n  const bundle = parsed.bundle as { manifest: ExportManifestV2; records: ExportMemoryRecordV1[] };\n  const manifest = bundle.manifest;\n  const capsule = manifest.capsule;\n\n  // Build a path → manifest-entry index for O(1) checksum lookup. The\n  // manifest is the source of truth; records-without-manifest-entries and\n  // manifest-entries-without-records are both treated as corruption.\n  const manifestIndex = new Map<string, ExportManifestV2[\"files\"][number]>();\n  for (const f of manifest.files) {\n    manifestIndex.set(f.path, f);\n  }\n  if (manifestIndex.size !== manifest.files.length) {\n    throw new Error(\n      \"importCapsule: manifest contains duplicate file paths\",\n    );\n  }\n  const recordPaths = new Set<string>();\n  for (const rec of bundle.records) {\n    if (recordPaths.has(rec.path)) {\n      throw new Error(\n        `importCapsule: bundle contains duplicate record path: ${rec.path}`,\n      );\n    }\n    recordPaths.add(rec.path);\n  }\n\n  // Phase 1: verify every record matches its manifest entry AND validate all\n  // target paths before any filesystem mutation.  We do both in a single pass\n  // so a corrupted or malicious archive cannot leave the memory dir partially\n  // written (fail-closed per gotcha #25).\n  //\n  // The real root is resolved once via realpath so the subsequent per-record\n  // inside-root checks are symlink-aware: a record path like `facts/a.md`\n  // cannot write outside the intended sandbox via a symlinked subdirectory\n  // (Codex P1 feedback).  If realpath fails (root does not exist) the earlier\n  // assertIsDirectoryNotSymlink call already threw, so this should always succeed.\n  const rootReal = await realpath(rootAbs).catch(() => rootAbs);\n\n  // Tracks normalized, case-folded target paths seen so far in phase 1.  Maps\n  // targetAbs.toLowerCase() → first source path so the collision error can name\n  // both offending entries.  Two manifest entries whose computed target paths\n  // normalize to the same absolute path (e.g. `subdir/file.md` and\n  // `subdir/./file.md`, or differing case on case-insensitive filesystems such\n  // as macOS and Windows) would both try to write the same inode — the second\n  // would silently overwrite the first.  We reject the import up-front before\n  // any write (Codex P2 thread on PR #741, line 283).\n  const seenTargetPaths = new Map<string, string>();\n\n  for (const rec of bundle.records) {\n    // Checksum validation.\n    const entry = manifestIndex.get(rec.path);\n    if (!entry) {\n      throw new Error(\n        `importCapsule: archive checksum mismatch (record without manifest entry: ${rec.path})`,\n      );\n    }\n    const { sha256, bytes } = sha256String(rec.content);\n    if (sha256 !== entry.sha256 || bytes !== entry.bytes) {\n      throw new Error(\n        `importCapsule: archive checksum mismatch for ${rec.path}: ` +\n          `expected sha256=${entry.sha256} bytes=${entry.bytes}, ` +\n          `got sha256=${sha256} bytes=${bytes}`,\n      );\n    }\n\n    // Source path validation: reject any record whose posix source path\n    // contains a `..` segment, an absolute prefix, or any component that would\n    // let fork-mode bypass its isolation invariant.  This check runs before\n    // `computeTargetPath` so that fork mode's `forks/<id>/` rebase cannot be\n    // bypassed by a path like `../../profile.md` (which `path.join` would\n    // silently collapse, landing the file inside root but outside the fork\n    // prefix — Cursor medium thread #741).  Rejecting `..` up-front is simpler\n    // and more robust than normalising after the fact.\n    //\n    // Extended guard (Codex P1 #741 round 5): also reject paths containing\n    // backslash separators (`\\`), which are Windows path separators. On Windows\n    // a path like `..\\\\escape.md` or `subdir\\\\..\\\\..\\\\escape.md` would resolve\n    // to a parent traversal but would bypass a purely posix-split check.\n    // Additionally, after posix-normalizing the path we re-check for a leading\n    // `..` or `/` — this catches edge-cases such as `subdir/../..` where the\n    // individual split segments are not `..` but the normalized result is.\n    if (rec.path.includes(\"\\\\\")) {\n      throw new Error(\n        `importCapsule: record path contains backslash separators (Windows-style paths are not allowed): ${rec.path}`,\n      );\n    }\n    const posixNormalized = path.posix.normalize(rec.path);\n    if (\n      rec.path.startsWith(\"/\") ||\n      rec.path.split(\"/\").some((seg) => seg === \"..\") ||\n      posixNormalized.startsWith(\"..\") ||\n      posixNormalized.startsWith(\"/\")\n    ) {\n      throw new Error(\n        `importCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Path-traversal validation (moved here from phase 2 per Cursor feedback:\n    // the traversal check must run before ANY write so a malicious archive\n    // with an escaping path that sorts last cannot land partial writes).\n    //\n    // We build targetAbs relative to the real-resolved root (rootReal) so\n    // that the inside-root check is symlink-aware: if `rootReal !== rootAbs`\n    // (the import root is itself behind a symlink), we still compare against\n    // the canonical path (Codex P1).\n    const targetRel = computeTargetPath(rec.path, mode, capsule.id);\n    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));\n    if (!isPathInsideRoot(rootReal, targetAbs)) {\n      throw new Error(\n        `importCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Symlink-aware containment check (Cursor thread #741 line 247/264).\n    // The lexical check above handles `..`-traversal but cannot detect\n    // symlinked subdirectories that point outside the root. We resolve the\n    // nearest existing ancestor of the target via realpath to catch symlinks\n    // anywhere in the path components. If any resolved prefix escapes rootReal,\n    // the import is rejected before any write. This applies to ALL modes,\n    // including fork mode whose rebase prefix may itself traverse a symlink.\n    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, \"importCapsule\");\n\n    // Target-file symlink check (Codex P1 #741 round 4, line 260).\n    // `assertRealpathInsideRoot` resolves the nearest existing *ancestor* to\n    // catch symlinked parent directories, but if the TARGET FILE itself already\n    // exists and is a symlink, that check passes (the parent is real) while the\n    // write would silently follow the symlink to a path outside root.  We\n    // therefore lstat the target directly: if it exists and is a symlink we\n    // reject the record up-front.  For new files the parent-canonicalization\n    // performed above is sufficient; no realpath of a non-existent file is\n    // needed.\n    const targetLstat = await lstat(targetAbs).catch(() => null);\n    if (targetLstat !== null && targetLstat.isSymbolicLink()) {\n      throw new Error(\n        `importCapsule: record target is a symlink and cannot be written to safely: ${rec.path}`,\n      );\n    }\n\n    // Duplicate normalized target path detection (Codex P2 #741, line 283).\n    // `path.join` already normalises `.` segments (e.g. `subdir/./file.md` →\n    // `subdir/file.md`).  On case-insensitive filesystems (macOS default,\n    // Windows), two paths that differ only in case would resolve to the same\n    // inode.  We fold the dedup key to lowercase so that `subdir/File.md` and\n    // `subdir/file.md` are detected as duplicates before any write occurs.\n    // This is intentionally unconditional: the cost of an extra `.toLowerCase()`\n    // on case-sensitive filesystems is negligible, and a defensive lowercase\n    // is far simpler than probing filesystem case-sensitivity at runtime.\n    const dedupKey = targetAbs.toLowerCase();\n    const firstSourcePath = seenTargetPaths.get(dedupKey);\n    if (firstSourcePath !== undefined) {\n      throw new Error(\n        `importCapsule: manifest contains two entries that resolve to the same target path: ` +\n          `\"${firstSourcePath}\" and \"${rec.path}\" both map to \"${targetRel}\"`,\n      );\n    }\n    seenTargetPaths.set(dedupKey, rec.path);\n  }\n  // Detect manifest-only entries (missing record). Treat as corruption.\n  for (const f of manifest.files) {\n    if (!recordPaths.has(f.path)) {\n      throw new Error(\n        `importCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`,\n      );\n    }\n  }\n\n  // Phase 2: apply the mode. All records were validated in phase 1; we now\n  // write to disk. Per-record errors propagate; each individual write is\n  // atomic (mkdir + writeFile pair).\n  const imported: ImportCapsuleImportedRecord[] = [];\n  const skipped: ImportCapsuleSkippedRecord[] = [];\n\n  // Sort by source path so the imported/skipped lists are deterministic\n  // regardless of bundle order. (`exportCapsule` already sorts; we re-sort\n  // defensively in case a hand-edited archive ships records in another order.)\n  const sortedRecords = [...bundle.records].sort((a, b) =>\n    a.path.localeCompare(b.path),\n  );\n\n  for (const rec of sortedRecords) {\n    const targetRel = computeTargetPath(rec.path, mode, capsule.id);\n    // Use rootReal (realpath-resolved) to stay consistent with phase 1's\n    // traversal validation and avoid writing through stale symlinks.\n    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));\n\n    const exists = await fileExistsAt(targetAbs);\n\n    // Skip logic applies to both `skip` mode (explicit) and `fork` mode\n    // (Cursor medium: fork mode must also be skip-on-exist for the computed\n    // fork path, because production imports generate non-deterministic IDs —\n    // so re-importing the same capsule should not overwrite user edits in the\n    // fork tree or silently change file identities by generating new IDs).\n    if ((mode === \"skip\" || mode === \"fork\") && exists) {\n      skipped.push({ path: rec.path, reason: \"exists\" });\n      continue;\n    }\n\n    let snapshotted = false;\n    if (mode === \"overwrite\" && exists) {\n      // Gotcha #54: snapshot BEFORE overwriting. If snapshot creation fails\n      // we abort this record's import rather than silently destroying\n      // history. The page-versioning module is responsible for atomic\n      // sidecar writes; we just call it.\n      if (opts.versioning && opts.versioning.enabled) {\n        const prior = await readFile(targetAbs, \"utf-8\").catch(() => \"\");\n        await createVersion(\n          targetAbs,\n          prior,\n          \"manual\",\n          opts.versioning,\n          opts.log,\n          `capsule-import: ${capsule.id}`,\n          rootReal,\n        );\n        snapshotted = true;\n      }\n    }\n\n    let contentToWrite = rec.content;\n    let rewroteId = false;\n    if (mode === \"fork\") {\n      const forked = rewriteFrontmatterIdForFork(rec.content, capsule.id, opts.now);\n      contentToWrite = forked.content;\n      rewroteId = forked.rewrote;\n    }\n\n    await mkdir(path.dirname(targetAbs), { recursive: true });\n    await writeFile(targetAbs, contentToWrite, \"utf-8\");\n    imported.push({\n      sourcePath: rec.path,\n      targetPath: targetRel,\n      snapshotted,\n      rewroteId,\n    });\n  }\n\n  // Sort skipped for stable output (see comment above).\n  skipped.sort((a, b) => a.path.localeCompare(b.path));\n\n  return { imported, skipped, manifest };\n}\n\n// ---------------------------------------------------------------------------\n// Path helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Compute the destination relative path for a record under the chosen\n * mode.\n *\n *  - `skip` / `overwrite` — identity: the record's posix path is used as-is.\n *  - `fork` — rebased under `forks/<capsule-id>/<original-path>` so the\n *    original tree is never modified.\n */\nfunction computeTargetPath(\n  sourcePosix: string,\n  mode: ImportCapsuleMode,\n  capsuleId: string,\n): string {\n  if (mode === \"fork\") return `forks/${capsuleId}/${sourcePosix}`;\n  return sourcePosix;\n}\n\nasync function fileExistsAt(absPath: string): Promise<boolean> {\n  const st = await stat(absPath).catch(() => null);\n  return st !== null && st.isFile();\n}\n\n// ---------------------------------------------------------------------------\n// Fork-mode id rewriting\n// ---------------------------------------------------------------------------\n\n/**\n * Rewrite a YAML-frontmatter `id:` field to a fork-scoped value.\n *\n * Strategy: we deliberately do NOT parse the entire YAML — memory files\n * use a deterministic top-of-file frontmatter delimited by `---` lines,\n * and the orchestrator's `parseFrontmatter` reads `id` as a top-level\n * key with a single-line scalar value. We mirror that contract:\n *\n *   - Detect a leading `---\\n` … `\\n---` block at the top of the file.\n *   - Within that block, locate the first `id:` line that is not nested\n *     under another key (cheap heuristic: line starts at column 0).\n *   - Replace its value with a new fork-id derived from `capsuleId` and\n *     a short random suffix (or {@link opts.now} when provided for tests).\n *\n * Files without a frontmatter block, or without an `id:` key inside one,\n * are returned unchanged with `rewrote: false`. This keeps non-memory\n * artifacts (READMEs, transcripts) byte-identical to the source.\n */\nfunction rewriteFrontmatterIdForFork(\n  content: string,\n  capsuleId: string,\n  now: number | undefined,\n): { content: string; rewrote: boolean } {\n  // Detect the dominant line ending in the file so we can preserve it when\n  // rebuilding the frontmatter delimiters. Splitting/joining on `\\n` silently\n  // drops `\\r` from CRLF files, changing the byte content (Cursor thread #741\n  // line 467). We detect the ending of the very first line (the opening `---`)\n  // and use that as the canonical separator for the reconstructed delimiters.\n  // All three cases are covered: CRLF (\\r\\n), LF (\\n), and bare CR (\\r).\n  const crlfMatch = /^---(\\r\\n|\\r|\\n)/.exec(content);\n  // Fall back to LF if the file starts with `---` but has no newline (EOF).\n  const eol = crlfMatch ? crlfMatch[1] : \"\\n\";\n\n  // Frontmatter block detection: `---` on its own line at the very start,\n  // followed by content, followed by `---` on its own line. The closing\n  // delimiter must be at column 0. We capture the trailing terminator\n  // (`\\r?\\n` or end-of-string) as a separate group so we can re-emit it\n  // verbatim, preserving CRLF/LF/EOF shape from the original file.\n  const fmMatch = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---(\\r?\\n|$)/.exec(content);\n  if (!fmMatch) return { content, rewrote: false };\n  const fmBody = fmMatch[1];\n  const fmTrailer = fmMatch[2];\n  const fmStart = fmMatch.index;\n  const fmEnd = fmStart + fmMatch[0].length;\n\n  // Find a top-level `id:` line. Top-level means the line begins at\n  // column 0 inside the frontmatter body (no leading whitespace) and the\n  // key is exactly `id`. We deliberately accept `id:` and `id : ` shapes\n  // but reject `nested_id:` to avoid touching unrelated keys.\n  const idLineRe = /^id:[ \\t]*([^\\r\\n]*)$/m;\n  const idMatch = idLineRe.exec(fmBody);\n  if (!idMatch) return { content, rewrote: false };\n\n  const newId = mintForkId(capsuleId, idMatch[1]?.trim() ?? \"\", now);\n  const replacedBody = fmBody.replace(idLineRe, `id: ${newId}`);\n  // Reconstruct the file: original prefix (always empty here, fmStart === 0\n  // by the `^` anchor) + frontmatter delimiters around the rewritten body.\n  // Use the detected `eol` for the opening/closing `---` lines so that CRLF\n  // files remain CRLF and LF files remain LF, preserving byte-content fidelity\n  // (Cursor thread #741 line 467).  The captured `fmTrailer` (the newline\n  // immediately after the closing `---`, or end-of-string) is re-emitted\n  // verbatim so the byte immediately after the closing fence is unchanged.\n  const prefix = content.slice(0, fmStart);\n  const tail = content.slice(fmEnd);\n  const rebuilt = `${prefix}---${eol}${replacedBody}${eol}---${fmTrailer}${tail}`;\n  return { content: rebuilt, rewrote: true };\n}\n\n/**\n * Derive a deterministic-when-`now`-is-set fork id from the capsule id and\n * the original record id. Production callers omit `now` and get a UUID\n * suffix; tests pass `now` for byte-stable assertions.\n */\nfunction mintForkId(capsuleId: string, originalId: string, now: number | undefined): string {\n  const base = originalId.length > 0 ? originalId : \"fork\";\n  if (now === undefined) {\n    const suffix = randomUUID().slice(0, 8);\n    return `${base}-fork-${capsuleId}-${suffix}`;\n  }\n  // Deterministic suffix: short hash of (capsuleId, originalId, now). Using\n  // sha256 over a sorted-key serialization (gotcha #38) so the suffix does\n  // not depend on Object.entries order.\n  const payload = JSON.stringify({ c: capsuleId, i: originalId, n: now });\n  const suffix = createHash(\"sha256\").update(payload, \"utf-8\").digest(\"hex\").slice(0, 8);\n  return `${base}-fork-${capsuleId}-${suffix}`;\n}\n\n// Note: `CapsuleBlock` is re-exported here purely so callers that want to\n// inspect the manifest block don't have to deep-import from `./types.js`.\nexport type { CapsuleBlock };\n"],"mappings":"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","names":["suffix"]}

package/dist/{chunk-JR4ZC3G4.js → chunk-DLJ4IR6M.js}

@@ -155,34 +155,45 @@ var SessionObserverState = class {
   }
   async save() {
     await this.withSaveLock(async () => {
-      const merged = /* @__PURE__ */ new Map();
-      const persisted = await this.readPersistedState();
-      if (persisted) {
-        for (const [key, value] of this.normalizePersistedSessions(persisted.sessions).entries()) {
-          merged.set(key, value);
-        }
-      }
-      for (const [key, current] of this.sessions.entries()) {
-        const existing = merged.get(key);
-        if (!existing) {
-          merged.set(key, current);
-          continue;
-        }
-        merged.set(key, mergeSessionCursor(existing, current));
-      }
+      const merged = await this.readMergedSessions();
       this.sessions = merged;
-      const sessions = {};
-      for (const [key, value] of merged.entries()) {
-        sessions[key] = value;
-      }
-      const payload = { version: 1, sessions };
-      await mkdir(path.dirname(this.statePath), { recursive: true });
-      await writeFile(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+      await this.writeSessions(merged);
     });
   }
-  enqueueSave() {
-    this.saveQueue = this.saveQueue.catch(() => void 0).then(() => this.save());
-    return this.saveQueue;
+  async readMergedSessions() {
+    const merged = /* @__PURE__ */ new Map();
+    const persisted = await this.readPersistedState();
+    if (persisted) {
+      for (const [key, value] of this.normalizePersistedSessions(persisted.sessions).entries()) {
+        merged.set(key, value);
+      }
+    }
+    for (const [key, current] of this.sessions.entries()) {
+      const existing = merged.get(key);
+      if (!existing) {
+        merged.set(key, current);
+        continue;
+      }
+      merged.set(key, mergeSessionCursor(existing, current));
+    }
+    return merged;
+  }
+  async writeSessions(sessionsMap) {
+    const sessions = {};
+    for (const [key, value] of sessionsMap.entries()) {
+      sessions[key] = value;
+    }
+    const payload = { version: 1, sessions };
+    await mkdir(path.dirname(this.statePath), { recursive: true });
+    await writeFile(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+  }
+  enqueueObservation(input) {
+    const operation = this.saveQueue.catch(() => void 0).then(() => this.observeWithSaveLock(input));
+    this.saveQueue = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
   }
   bandForTotalBytes(totalBytes) {
     const bytes = sanitizeNonNegativeInt(totalBytes);
@@ -192,19 +203,39 @@ var SessionObserverState = class {
     return this.bands[this.bands.length - 1];
   }
   async observe(input) {
+    return this.enqueueObservation(input);
+  }
+  async observeWithSaveLock(input) {
+    let decision;
+    await this.withSaveLock(async () => {
+      const localExisting = this.sessions.get(input.sessionKey);
+      const sessions = await this.readMergedSessions();
+      decision = await this.observeMerged(
+        input,
+        sessions,
+        localExisting ? { ...localExisting } : void 0
+      );
+    });
+    if (!decision) {
+      throw new Error("session observer decision was not computed");
+    }
+    return decision;
+  }
+  async observeMerged(input, sessions, localExisting) {
     const nowIso = input.observedAt ?? (/* @__PURE__ */ new Date()).toISOString();
     const totalBytes = sanitizeNonNegativeInt(input.totalBytes);
     const totalTokens = sanitizeNonNegativeInt(input.totalTokens);
     const band = this.bandForTotalBytes(totalBytes);
-    const existing = this.sessions.get(input.sessionKey);
+    const existing = sessions.get(input.sessionKey);
     if (!existing) {
-      this.sessions.set(input.sessionKey, {
+      sessions.set(input.sessionKey, {
         sessionKey: input.sessionKey,
         cursorBytes: totalBytes,
         cursorTokens: totalTokens,
         lastObservedAt: nowIso
       });
-      await this.enqueueSave();
+      this.sessions = sessions;
+      await this.writeSessions(sessions);
       return {
         triggered: false,
         deltaBytes: 0,
@@ -214,13 +245,27 @@ var SessionObserverState = class {
       };
     }
     const session = { ...existing };
+    const observedMs = parseIsoMs(nowIso);
+    const existingObservedMs = parseIsoMs(session.lastObservedAt);
+    const existingResetMs = parseIsoMs(session.lastResetAt);
+    if (existingResetMs > 0 && observedMs < existingResetMs) {
+      this.sessions = sessions;
+      return { triggered: false, deltaBytes: 0, deltaTokens: 0, band, reason: "baseline" };
+    }
     if (totalBytes < session.cursorBytes || totalTokens < session.cursorTokens) {
-      session.cursorBytes = totalBytes;
-      session.cursorTokens = totalTokens;
-      session.lastObservedAt = nowIso;
-      session.lastResetAt = nowIso;
-      this.sessions.set(input.sessionKey, session);
-      await this.enqueueSave();
+      const localSawReset = localExisting !== void 0 && (totalBytes < sanitizeNonNegativeInt(localExisting.cursorBytes) || totalTokens < sanitizeNonNegativeInt(localExisting.cursorTokens));
+      const canApplyReset = localSawReset && observedMs >= existingObservedMs;
+      if (canApplyReset) {
+        session.cursorBytes = totalBytes;
+        session.cursorTokens = totalTokens;
+        session.lastObservedAt = nowIso;
+        session.lastResetAt = nowIso;
+      } else if (observedMs >= existingObservedMs) {
+        session.lastObservedAt = nowIso;
+      }
+      sessions.set(input.sessionKey, session);
+      this.sessions = sessions;
+      await this.writeSessions(sessions);
       return { triggered: false, deltaBytes: 0, deltaTokens: 0, band, reason: "baseline" };
     }
     const deltaBytes = totalBytes - session.cursorBytes;
@@ -230,8 +275,11 @@ var SessionObserverState = class {
     if (!crossedThreshold) {
       const unchanged = deltaBytes === 0 && deltaTokens === 0;
       if (!unchanged) {
-        this.sessions.set(input.sessionKey, session);
-        await this.enqueueSave();
+        sessions.set(input.sessionKey, session);
+        this.sessions = sessions;
+        await this.writeSessions(sessions);
+      } else {
+        this.sessions = sessions;
       }
       return {
         triggered: false,
@@ -244,8 +292,9 @@ var SessionObserverState = class {
     const lastTriggeredMs = session.lastTriggeredAt ? Date.parse(session.lastTriggeredAt) : NaN;
     const withinDebounce = Number.isFinite(lastTriggeredMs) && nowMs - lastTriggeredMs < this.debounceMs;
     if (withinDebounce) {
-      this.sessions.set(input.sessionKey, session);
-      await this.enqueueSave();
+      sessions.set(input.sessionKey, session);
+      this.sessions = sessions;
+      await this.writeSessions(sessions);
       return {
         triggered: false,
         deltaBytes,
@@ -257,8 +306,9 @@ var SessionObserverState = class {
     session.lastTriggeredAt = nowIso;
     session.cursorBytes = totalBytes;
     session.cursorTokens = totalTokens;
-    this.sessions.set(input.sessionKey, session);
-    await this.enqueueSave();
+    sessions.set(input.sessionKey, session);
+    this.sessions = sessions;
+    await this.writeSessions(sessions);
     return {
       triggered: true,
       deltaBytes,
@@ -273,4 +323,4 @@ export {
   normalizeObserverBands,
   SessionObserverState
 };
-//# sourceMappingURL=chunk-JR4ZC3G4.js.map
+//# sourceMappingURL=chunk-DLJ4IR6M.js.map

package/dist/chunk-DLJ4IR6M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/session-observer-state.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, open, readFile, stat, unlink, writeFile } from \"node:fs/promises\";\nimport { log } from \"./logger.js\";\nimport type { SessionObserverBandConfig } from \"./types.js\";\nimport { cloneDefaultSessionObserverBands } from \"./session-observer-bands.js\";\n\ninterface SessionObserverCursor {\n  sessionKey: string;\n  cursorBytes: number;\n  cursorTokens: number;\n  lastObservedAt: string;\n  lastTriggeredAt?: string;\n  lastResetAt?: string;\n}\n\ninterface SessionObserverPersistedState {\n  version: 1;\n  sessions: Record<string, SessionObserverCursor>;\n}\n\nexport interface SessionObservationInput {\n  sessionKey: string;\n  totalBytes: number;\n  totalTokens: number;\n  observedAt?: string;\n}\n\nexport interface SessionObservationDecision {\n  triggered: boolean;\n  deltaBytes: number;\n  deltaTokens: number;\n  band: SessionObserverBandConfig;\n  reason?: \"threshold\" | \"debounced\" | \"baseline\";\n}\n\nfunction sanitizeNonNegativeInt(value: number): number {\n  if (!Number.isFinite(value)) return 0;\n  return Math.max(0, Math.floor(value));\n}\n\nfunction parseIsoMs(value?: string): number {\n  if (!value) return 0;\n  const ms = Date.parse(value);\n  return Number.isFinite(ms) ? ms : 0;\n}\n\nfunction mergeSessionCursor(\n  existing: SessionObserverCursor,\n  incoming: SessionObserverCursor,\n): SessionObserverCursor {\n  const existingObservedMs = parseIsoMs(existing.lastObservedAt);\n  const incomingObservedMs = parseIsoMs(incoming.lastObservedAt);\n  const existingTriggeredMs = parseIsoMs(existing.lastTriggeredAt);\n  const incomingTriggeredMs = parseIsoMs(incoming.lastTriggeredAt);\n  const existingResetMs = parseIsoMs(existing.lastResetAt);\n  const incomingResetMs = parseIsoMs(incoming.lastResetAt);\n\n  const observedAt =\n    incomingObservedMs >= existingObservedMs ? incoming.lastObservedAt : existing.lastObservedAt;\n  const triggeredAt =\n    incomingTriggeredMs >= existingTriggeredMs ? incoming.lastTriggeredAt : existing.lastTriggeredAt;\n\n  // Preserve monotonic cursor progression except for explicit reset observations.\n  const incomingIsNewer = incomingObservedMs >= existingObservedMs;\n  const incomingHasNewerReset = incomingResetMs > existingResetMs;\n  const allowIncomingReset = incomingIsNewer && incomingHasNewerReset;\n  const keepExistingReset =\n    existingResetMs > incomingResetMs && existingObservedMs >= incomingObservedMs;\n\n  let cursorBytes = Math.max(\n    sanitizeNonNegativeInt(existing.cursorBytes),\n    sanitizeNonNegativeInt(incoming.cursorBytes),\n  );\n  let cursorTokens = Math.max(\n    sanitizeNonNegativeInt(existing.cursorTokens),\n    sanitizeNonNegativeInt(incoming.cursorTokens),\n  );\n  if (keepExistingReset) {\n    cursorBytes = sanitizeNonNegativeInt(existing.cursorBytes);\n    cursorTokens = sanitizeNonNegativeInt(existing.cursorTokens);\n  } else if (allowIncomingReset) {\n    cursorBytes = sanitizeNonNegativeInt(incoming.cursorBytes);\n    cursorTokens = sanitizeNonNegativeInt(incoming.cursorTokens);\n  }\n\n  return {\n    sessionKey: existing.sessionKey,\n    cursorBytes,\n    cursorTokens,\n    lastObservedAt: observedAt,\n    lastTriggeredAt: triggeredAt,\n    lastResetAt:\n      incomingResetMs >= existingResetMs ? incoming.lastResetAt : existing.lastResetAt,\n  };\n}\n\nexport function normalizeObserverBands(\n  bands: SessionObserverBandConfig[],\n): SessionObserverBandConfig[] {\n  const normalized = bands\n    .map((band) => ({\n      maxBytes: sanitizeNonNegativeInt(band.maxBytes),\n      triggerDeltaBytes: sanitizeNonNegativeInt(band.triggerDeltaBytes),\n      triggerDeltaTokens: sanitizeNonNegativeInt(band.triggerDeltaTokens),\n    }))\n    .filter((band) => band.maxBytes > 0)\n    .sort((a, b) => a.maxBytes - b.maxBytes);\n\n  if (normalized.length === 0) {\n    return cloneDefaultSessionObserverBands();\n  }\n\n  const last = normalized[normalized.length - 1];\n  if (last && last.maxBytes < 1_000_000_000) {\n    normalized.push({\n      maxBytes: 1_000_000_000,\n      triggerDeltaBytes: last.triggerDeltaBytes,\n      triggerDeltaTokens: last.triggerDeltaTokens,\n    });\n  }\n  return normalized;\n}\n\nexport class SessionObserverState {\n  private readonly statePath: string;\n  private readonly lockPath: string;\n  private readonly lockStaleMs = 120_000;\n  private readonly debounceMs: number;\n  private readonly bands: SessionObserverBandConfig[];\n  private sessions = new Map<string, SessionObserverCursor>();\n  private saveQueue: Promise<void> = Promise.resolve();\n\n  private async readPersistedState(): Promise<SessionObserverPersistedState | null> {\n    try {\n      const raw = await readFile(this.statePath, \"utf-8\");\n      const parsed = JSON.parse(raw) as SessionObserverPersistedState;\n      if (parsed?.version !== 1 || !parsed.sessions || typeof parsed.sessions !== \"object\") {\n        return null;\n      }\n      return parsed;\n    } catch {\n      return null;\n    }\n  }\n\n  private normalizePersistedSessions(\n    sessions: Record<string, SessionObserverCursor>,\n  ): Map<string, SessionObserverCursor> {\n    const next = new Map<string, SessionObserverCursor>();\n    for (const [sessionKey, value] of Object.entries(sessions)) {\n      if (!value || typeof value !== \"object\") continue;\n      next.set(sessionKey, {\n        sessionKey,\n        cursorBytes: sanitizeNonNegativeInt(value.cursorBytes),\n        cursorTokens: sanitizeNonNegativeInt(value.cursorTokens),\n        lastObservedAt:\n          typeof value.lastObservedAt === \"string\" ? value.lastObservedAt : new Date(0).toISOString(),\n        lastTriggeredAt: typeof value.lastTriggeredAt === \"string\" ? value.lastTriggeredAt : undefined,\n        lastResetAt: typeof value.lastResetAt === \"string\" ? value.lastResetAt : undefined,\n      });\n    }\n    return next;\n  }\n\n  constructor(opts: {\n    memoryDir: string;\n    debounceMs: number;\n    bands: SessionObserverBandConfig[];\n  }) {\n    this.statePath = path.join(opts.memoryDir, \"state\", \"session-observer-state.json\");\n    this.lockPath = path.join(opts.memoryDir, \"state\", \"session-observer-state.lock\");\n    this.debounceMs = Math.max(0, Math.floor(opts.debounceMs));\n    this.bands = normalizeObserverBands(opts.bands);\n  }\n\n  private async withSaveLock(fn: () => Promise<void>): Promise<void> {\n    await mkdir(path.dirname(this.lockPath), { recursive: true });\n    for (let attempt = 0; attempt < 80; attempt++) {\n      try {\n        const handle = await open(this.lockPath, \"wx\");\n        try {\n          await fn();\n        } finally {\n          await handle.close();\n          await unlink(this.lockPath).catch(() => {});\n        }\n        return;\n      } catch (err: any) {\n        if (err?.code !== \"EEXIST\") throw err;\n        try {\n          const lockInfo = await stat(this.lockPath);\n          if (Date.now() - lockInfo.mtimeMs > this.lockStaleMs) {\n            await unlink(this.lockPath).catch(() => {});\n            continue;\n          }\n        } catch {\n          // Lock might have been released between EEXIST and stat/read.\n        }\n        await new Promise((resolve) => setTimeout(resolve, 25));\n      }\n    }\n    const error = new Error(\"session observer save lock timeout\");\n    log.debug(error.message);\n    throw error;\n  }\n\n  async load(): Promise<void> {\n    const parsed = await this.readPersistedState();\n    if (!parsed) {\n      this.sessions.clear();\n      return;\n    }\n    this.sessions = this.normalizePersistedSessions(parsed.sessions);\n  }\n\n  async save(): Promise<void> {\n    await this.withSaveLock(async () => {\n      const merged = await this.readMergedSessions();\n      this.sessions = merged;\n\n      await this.writeSessions(merged);\n    });\n  }\n\n  private async readMergedSessions(): Promise<Map<string, SessionObserverCursor>> {\n    const merged = new Map<string, SessionObserverCursor>();\n    const persisted = await this.readPersistedState();\n    if (persisted) {\n      for (const [key, value] of this.normalizePersistedSessions(persisted.sessions).entries()) {\n        merged.set(key, value);\n      }\n    }\n    for (const [key, current] of this.sessions.entries()) {\n      const existing = merged.get(key);\n      if (!existing) {\n        merged.set(key, current);\n        continue;\n      }\n      merged.set(key, mergeSessionCursor(existing, current));\n    }\n    return merged;\n  }\n\n  private async writeSessions(sessionsMap: Map<string, SessionObserverCursor>): Promise<void> {\n    const sessions: Record<string, SessionObserverCursor> = {};\n    for (const [key, value] of sessionsMap.entries()) {\n      sessions[key] = value;\n    }\n    const payload: SessionObserverPersistedState = { version: 1, sessions };\n    await mkdir(path.dirname(this.statePath), { recursive: true });\n    await writeFile(this.statePath, JSON.stringify(payload, null, 2), \"utf-8\");\n  }\n\n  private enqueueObservation(\n    input: SessionObservationInput,\n  ): Promise<SessionObservationDecision> {\n    const operation = this.saveQueue\n      .catch(() => undefined)\n      .then(() => this.observeWithSaveLock(input));\n    this.saveQueue = operation.then(\n      () => undefined,\n      () => undefined,\n    );\n    return operation;\n  }\n\n  private bandForTotalBytes(totalBytes: number): SessionObserverBandConfig {\n    const bytes = sanitizeNonNegativeInt(totalBytes);\n    for (const band of this.bands) {\n      if (bytes <= band.maxBytes) return band;\n    }\n    return this.bands[this.bands.length - 1];\n  }\n\n  async observe(input: SessionObservationInput): Promise<SessionObservationDecision> {\n    return this.enqueueObservation(input);\n  }\n\n  private async observeWithSaveLock(\n    input: SessionObservationInput,\n  ): Promise<SessionObservationDecision> {\n    let decision: SessionObservationDecision | undefined;\n    await this.withSaveLock(async () => {\n      const localExisting = this.sessions.get(input.sessionKey);\n      const sessions = await this.readMergedSessions();\n      decision = await this.observeMerged(\n        input,\n        sessions,\n        localExisting ? { ...localExisting } : undefined,\n      );\n    });\n    if (!decision) {\n      throw new Error(\"session observer decision was not computed\");\n    }\n    return decision;\n  }\n\n  private async observeMerged(\n    input: SessionObservationInput,\n    sessions: Map<string, SessionObserverCursor>,\n    localExisting?: SessionObserverCursor,\n  ): Promise<SessionObservationDecision> {\n    const nowIso = input.observedAt ?? new Date().toISOString();\n    const totalBytes = sanitizeNonNegativeInt(input.totalBytes);\n    const totalTokens = sanitizeNonNegativeInt(input.totalTokens);\n    const band = this.bandForTotalBytes(totalBytes);\n\n    const existing = sessions.get(input.sessionKey);\n    if (!existing) {\n      sessions.set(input.sessionKey, {\n        sessionKey: input.sessionKey,\n        cursorBytes: totalBytes,\n        cursorTokens: totalTokens,\n        lastObservedAt: nowIso,\n      });\n      this.sessions = sessions;\n      await this.writeSessions(sessions);\n      return {\n        triggered: false,\n        deltaBytes: 0,\n        deltaTokens: 0,\n        band,\n        reason: \"baseline\",\n      };\n    }\n\n    const session = { ...existing };\n    const observedMs = parseIsoMs(nowIso);\n    const existingObservedMs = parseIsoMs(session.lastObservedAt);\n    const existingResetMs = parseIsoMs(session.lastResetAt);\n    if (existingResetMs > 0 && observedMs < existingResetMs) {\n      this.sessions = sessions;\n      return { triggered: false, deltaBytes: 0, deltaTokens: 0, band, reason: \"baseline\" };\n    }\n\n    if (totalBytes < session.cursorBytes || totalTokens < session.cursorTokens) {\n      const localSawReset =\n        localExisting !== undefined\n        && (totalBytes < sanitizeNonNegativeInt(localExisting.cursorBytes)\n          || totalTokens < sanitizeNonNegativeInt(localExisting.cursorTokens));\n      const canApplyReset = localSawReset && observedMs >= existingObservedMs;\n\n      if (canApplyReset) {\n        session.cursorBytes = totalBytes;\n        session.cursorTokens = totalTokens;\n        session.lastObservedAt = nowIso;\n        session.lastResetAt = nowIso;\n      } else if (observedMs >= existingObservedMs) {\n        session.lastObservedAt = nowIso;\n      }\n      sessions.set(input.sessionKey, session);\n      this.sessions = sessions;\n      await this.writeSessions(sessions);\n      return { triggered: false, deltaBytes: 0, deltaTokens: 0, band, reason: \"baseline\" };\n    }\n\n    const deltaBytes = totalBytes - session.cursorBytes;\n    const deltaTokens = totalTokens - session.cursorTokens;\n    const crossedThreshold =\n      (band.triggerDeltaBytes > 0 && deltaBytes >= band.triggerDeltaBytes)\n      || (band.triggerDeltaTokens > 0 && deltaTokens >= band.triggerDeltaTokens);\n    session.lastObservedAt = nowIso;\n\n    if (!crossedThreshold) {\n      const unchanged = deltaBytes === 0 && deltaTokens === 0;\n      if (!unchanged) {\n        sessions.set(input.sessionKey, session);\n        this.sessions = sessions;\n        await this.writeSessions(sessions);\n      } else {\n        this.sessions = sessions;\n      }\n      return {\n        triggered: false,\n        deltaBytes,\n        deltaTokens,\n        band,\n      };\n    }\n\n    const nowMs = Date.parse(nowIso);\n    const lastTriggeredMs = session.lastTriggeredAt ? Date.parse(session.lastTriggeredAt) : NaN;\n    const withinDebounce =\n      Number.isFinite(lastTriggeredMs) && nowMs - lastTriggeredMs < this.debounceMs;\n\n    if (withinDebounce) {\n      sessions.set(input.sessionKey, session);\n      this.sessions = sessions;\n      await this.writeSessions(sessions);\n      return {\n        triggered: false,\n        deltaBytes,\n        deltaTokens,\n        band,\n        reason: \"debounced\",\n      };\n    }\n\n    session.lastTriggeredAt = nowIso;\n    session.cursorBytes = totalBytes;\n    session.cursorTokens = totalTokens;\n    sessions.set(input.sessionKey, session);\n    this.sessions = sessions;\n    await this.writeSessions(sessions);\n    return {\n      triggered: true,\n      deltaBytes,\n      deltaTokens,\n      band,\n      reason: \"threshold\",\n    };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-U4SCL7B7.js → chunk-DRD2Q7HQ.js}

@@ -1,12 +1,13 @@
 import {
   expandTildePath
-} from "./chunk-QRNI5JBH.js";
+} from "./chunk-EYIEWJNI.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
 
 // src/shared-context/manager.ts
-import { mkdir, readFile, readdir, appendFile, writeFile, stat } from "fs/promises";
+import { randomUUID } from "crypto";
+import { mkdir, readFile, readdir, appendFile, writeFile, stat, rename, rm } from "fs/promises";
 import path from "path";
 import { z } from "zod";
 var SharedFeedbackEntrySchema = z.object({
@@ -79,6 +80,16 @@ function readFrontmatterScalar(raw, key) {
 function ymd(d) {
   return d.toISOString().slice(0, 10);
 }
+function safeDateSegment(date) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    throw new Error(`Invalid shared-context date: ${JSON.stringify(date)}; expected YYYY-MM-DD`);
+  }
+  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+  if (!Number.isFinite(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== date) {
+    throw new Error(`Invalid shared-context date: ${JSON.stringify(date)}; expected a real calendar date`);
+  }
+  return date;
+}
 var CROSS_SIGNAL_STOPWORDS = /* @__PURE__ */ new Set([
   "a",
   "an",
@@ -278,14 +289,34 @@ function feedbackSeverityPriority(severity) {
 function compareFeedbackPriority(a, b) {
   return feedbackDecisionPriority(b.decision) - feedbackDecisionPriority(a.decision) || feedbackSeverityPriority(b.severity) - feedbackSeverityPriority(a.severity) || a.date.localeCompare(b.date);
 }
+function markdownLineText(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function markdownLineList(values) {
+  return values.map(markdownLineText).filter(Boolean).join(", ");
+}
 function formatFeedbackLine(entry) {
-  const extras = [`feedback: ${entry.date}`];
-  if (entry.severity) extras.push(`severity: ${entry.severity}`);
-  if (entry.refs?.length) extras.push(`refs: ${entry.refs.join(", ")}`);
-  return `- [${entry.agent}] ${entry.decision}: ${entry.reason} [${extras.join("; ")}]`;
+  const extras = [`feedback: ${markdownLineText(entry.date)}`];
+  if (entry.severity) extras.push(`severity: ${markdownLineText(entry.severity)}`);
+  if (entry.refs?.length) extras.push(`refs: ${markdownLineList(entry.refs)}`);
+  return `- [${markdownLineText(entry.agent)}] ${entry.decision}: ${markdownLineText(entry.reason)} [${extras.join("; ")}]`;
 }
 function formatOverlapLine(entry) {
-  return `- \`${entry.token}\` (${entry.agentCount} agents: ${entry.agents.join(", ")}) [sources: ${entry.sourcePaths.join(", ")}]`;
+  return `- \`${entry.token}\` (${entry.agentCount} agents: ${markdownLineList(entry.agents)}) [sources: ${markdownLineList(entry.sourcePaths)}]`;
+}
+async function writeFileAtomic(filePath, content) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = path.join(
+    path.dirname(filePath),
+    `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(tempPath, content, { encoding: "utf-8", flag: "wx" });
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
 }
 function resolveSharedContextDir(config) {
   return typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? expandTildePath(config.sharedContextDir) : path.join(expandTildePath(config.workspaceDir), "shared-context");
@@ -312,6 +343,7 @@ var SharedContextManager = class {
   feedbackDir;
   feedbackInboxPath;
   crossSignalsDir;
+  dailySynthesisChains = /* @__PURE__ */ new Map();
   async ensureStructure() {
     await mkdir(this.dir, { recursive: true });
     await mkdir(this.outputsDir, { recursive: true });
@@ -426,12 +458,37 @@ title: ${formatFrontmatterScalar(opts.title.replace(/\n/g, " ").slice(0, 200))}
     ].join("\n");
     await appendFile(this.prioritiesInboxPath, lines, "utf-8");
   }
+  async withDailySynthesisLock(date, fn) {
+    const previous = this.dailySynthesisChains.get(date) ?? Promise.resolve();
+    let releaseCurrent;
+    const current = new Promise((resolve) => {
+      releaseCurrent = resolve;
+    });
+    const queued = previous.catch(() => void 0).then(() => current);
+    this.dailySynthesisChains.set(date, queued);
+    await previous.catch(() => void 0);
+    try {
+      return await fn();
+    } finally {
+      releaseCurrent();
+      if (this.dailySynthesisChains.get(date) === queued) {
+        this.dailySynthesisChains.delete(date);
+      }
+    }
+  }
   async synthesizeCrossSignals(opts) {
-    const date = opts.date ?? ymd(/* @__PURE__ */ new Date());
+    const date = safeDateSegment(opts.date ?? ymd(/* @__PURE__ */ new Date()));
+    return this.withDailySynthesisLock(date, () => this.synthesizeCrossSignalsUnlocked({
+      date,
+      maxSummaryItems: opts.maxSummaryItems
+    }));
+  }
+  async synthesizeCrossSignalsUnlocked(opts) {
+    const date = opts.date;
     const maxSummaryItems = Math.max(1, opts.maxSummaryItems ?? 8);
     const outputs = [];
     try {
-      const agents = await readdir(this.outputsDir, { withFileTypes: true });
+      const agents = (await readdir(this.outputsDir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
       for (const a of agents) {
         if (!a.isDirectory()) continue;
         const dayDir = path.join(this.outputsDir, a.name, date);
@@ -449,6 +506,9 @@ title: ${formatFrontmatterScalar(opts.title.replace(/\n/g, " ").slice(0, 200))}
       }
     } catch {
     }
+    outputs.sort(
+      (a, b) => a.agent.localeCompare(b.agent) || a.path.localeCompare(b.path) || a.title.localeCompare(b.title)
+    );
     const feedback = [];
     try {
       const raw = await readFile(this.feedbackInboxPath, "utf-8");
@@ -548,14 +608,14 @@ ${body}`)
       }
     };
     const crossSignalsPath = path.join(this.crossSignalsDir, `${date}.json`);
-    await writeFile(crossSignalsPath, `${JSON.stringify(report, null, 2)}
-`, "utf-8");
+    await writeFileAtomic(crossSignalsPath, `${JSON.stringify(report, null, 2)}
+`);
     const recurringThemeLines = mergedOverlaps.length === 0 ? ["- No multi-agent topic overlap detected."] : mergedOverlaps.slice(0, maxSummaryItems).map((entry) => formatOverlapLine(entry));
     const riskSignals = [...feedback].filter((entry) => entry.decision !== "approved" || entry.severity === "high" || entry.severity === "medium").sort(compareFeedbackPriority).slice(0, maxSummaryItems);
     const riskLines = riskSignals.length === 0 ? ["- No explicit blockers or elevated review risks recorded."] : riskSignals.map((entry) => formatFeedbackLine(entry));
     const promotionCandidates = mergedOverlaps.filter((entry) => entry.agentCount >= 3).slice(0, maxSummaryItems);
     const promotionLines = promotionCandidates.length === 0 ? ["- No promotion candidates yet."] : promotionCandidates.map(
-      (entry) => `- Consider promoting \`${entry.token}\` into priorities or operating rules [sources: ${entry.sourcePaths.join(", ")}]`
+      (entry) => `- Consider promoting \`${entry.token}\` into priorities or operating rules [sources: ${markdownLineList(entry.sourcePaths)}]`
     );
     const crossSignalsMarkdown = [
       `# Cross-Signals \u2014 ${date}`,
@@ -578,12 +638,12 @@ ${body}`)
       "",
       "## Sources",
       ...sources.length === 0 ? ["- (none)"] : sources.map(
-        (source) => `- [${source.agent}] ${source.title} (${source.path})`
+        (source) => `- [${markdownLineText(source.agent)}] ${markdownLineText(source.title)} (${markdownLineText(source.path)})`
       ),
       ""
     ].join("\n");
     const crossSignalsMarkdownPath = path.join(this.crossSignalsDir, `${date}.md`);
-    await writeFile(crossSignalsMarkdownPath, crossSignalsMarkdown, "utf-8");
+    await writeFileAtomic(crossSignalsMarkdownPath, crossSignalsMarkdown);
     return {
       date,
       crossSignalsPath,
@@ -593,9 +653,13 @@ ${body}`)
     };
   }
   async curateDaily(opts) {
-    const date = opts.date ?? ymd(/* @__PURE__ */ new Date());
+    const date = safeDateSegment(opts.date ?? ymd(/* @__PURE__ */ new Date()));
+    return this.withDailySynthesisLock(date, () => this.curateDailyUnlocked({ ...opts, date }));
+  }
+  async curateDailyUnlocked(opts) {
+    const date = opts.date;
     const maxChars = Math.max(2e3, opts.maxChars ?? 2e4);
-    const crossSignals = await this.synthesizeCrossSignals({ date });
+    const crossSignals = await this.synthesizeCrossSignalsUnlocked({ date });
     const feedbackLines = crossSignals.report.feedbackEntries.length === 0 ? ["- (none)"] : crossSignals.report.feedbackEntries.map((entry) => formatFeedbackLine(entry));
     const overlapBullets = crossSignals.report.overlaps.length === 0 ? ["- No multi-agent topic overlap detected."] : crossSignals.report.overlaps.slice(0, 8).map((entry) => formatOverlapLine(entry));
     const md = [
@@ -620,7 +684,7 @@ ${body}`)
     const out = md.join("\n");
     const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
     const roundtablePath = path.join(this.roundtableDir, `${date}.md`);
-    await writeFile(roundtablePath, trimmed, "utf-8");
+    await writeFileAtomic(roundtablePath, trimmed);
     log.info(`shared-context curated daily roundtable: ${roundtablePath}`);
     return {
       date,
@@ -637,4 +701,4 @@ export {
   resolveSharedContextDir,
   SharedContextManager
 };
-//# sourceMappingURL=chunk-U4SCL7B7.js.map
+//# sourceMappingURL=chunk-DRD2Q7HQ.js.map