@remnic/core 10.0.13 → 10.0.15

package/dist/{chunk-OFEHITAZ.js → chunk-OXNTOHL6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-CYEK6Z3P.js";
+} from "./chunk-VW6VIJOS.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -620,4 +620,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-OFEHITAZ.js.map
+//# sourceMappingURL=chunk-OXNTOHL6.js.map

package/dist/{chunk-FQD2KPQH.js → chunk-P55FACBG.js}

@@ -26,7 +26,7 @@ import {
 } from "./chunk-C7HJ3NEI.js";
 import {
   withHeldFileLock
-} from "./chunk-EHRE7ZG3.js";
+} from "./chunk-5B5WYAHQ.js";
 import {
   MAGIC_HEADER_SIZE,
   SecureStoreLockedError,
@@ -774,4 +774,4 @@ export {
   drainPendingLifecycleLedgerForSync,
   drainPendingLifecycleForSyncOrThrow
 };
-//# sourceMappingURL=chunk-FQD2KPQH.js.map
+//# sourceMappingURL=chunk-P55FACBG.js.map

package/dist/chunk-PGRZ3FYC.js

@@ -0,0 +1,34 @@
+import {
+  abortError
+} from "./chunk-BTTPKDIL.js";
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function sleepAbortable(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError("operation aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    let onAbort = null;
+    if (signal) {
+      onAbort = () => {
+        clearTimeout(timer);
+        reject(abortError("operation aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+
+export {
+  sleep,
+  sleepAbortable
+};
+//# sourceMappingURL=chunk-PGRZ3FYC.js.map

package/dist/chunk-PGRZ3FYC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/sleep.ts"],"sourcesContent":["/** Wait without cancellation; keep the timer referenced so awaited polling can finish. */\nexport function sleep(ms: number): Promise<void> {\n  // Constructor form keeps this reachable utility compatible with ES2022 adapter type graphs.\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nimport { abortError } from \"../abort-error.js\";\n\n/**\n * Wait until `ms` elapses, or reject with `AbortError` when `signal` fires.\n * The timer is cleared on abort so a cancelled wait holds no Timeout handle.\n * Executor form: this module targets ES2022 type graphs (no withResolvers).\n */\nexport function sleepAbortable(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(abortError(\"operation aborted\"));\n      return;\n    }\n    const timer = setTimeout(() => {\n      if (signal && onAbort) signal.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n    let onAbort: (() => void) | null = null;\n    if (signal) {\n      onAbort = () => {\n        clearTimeout(timer);\n        reject(abortError(\"operation aborted\"));\n      };\n      signal.addEventListener(\"abort\", onAbort, { once: true });\n    }\n  });\n}\n"],"mappings":";;;;;AACO,SAAS,MAAM,IAA2B;AAE/C,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD;AASO,SAAS,eAAe,IAAY,QAAqC;AAC9E,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,QAAI,QAAQ,SAAS;AACnB,aAAO,WAAW,mBAAmB,CAAC;AACtC;AAAA,IACF;AACA,UAAM,QAAQ,WAAW,MAAM;AAC7B,UAAI,UAAU,QAAS,QAAO,oBAAoB,SAAS,OAAO;AAClE,cAAQ;AAAA,IACV,GAAG,EAAE;AACL,QAAI,UAA+B;AACnC,QAAI,QAAQ;AACV,gBAAU,MAAM;AACd,qBAAa,KAAK;AAClB,eAAO,WAAW,mBAAmB,CAAC;AAAA,MACxC;AACA,aAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,IAC1D;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/{chunk-JYZSRNR7.js → chunk-PIITB2YZ.js}

@@ -16,7 +16,7 @@ import {
 } from "./chunk-ULM7JCDH.js";
 import {
   resolveEvalStoreDir
-} from "./chunk-4IHBN6WU.js";
+} from "./chunk-JKMIGCK6.js";
 
 // src/eval-trajectory-store.ts
 import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
@@ -237,4 +237,4 @@ export {
   writeEvalTrajectoryReport,
   readEvalTrajectoryReport
 };
-//# sourceMappingURL=chunk-JYZSRNR7.js.map
+//# sourceMappingURL=chunk-PIITB2YZ.js.map

package/dist/{chunk-PBVNVKYN.js → chunk-PIN5OPBA.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   parseQmdExplain
-} from "./chunk-DGRMWDQY.js";
+} from "./chunk-66BCOVW2.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -645,4 +645,4 @@ export {
   appendMemoryToGraphContext,
   resolvePersistedMemoryRelativePath
 };
-//# sourceMappingURL=chunk-PBVNVKYN.js.map
+//# sourceMappingURL=chunk-PIN5OPBA.js.map

package/dist/chunk-PPUNC7UX.js

@@ -0,0 +1,73 @@
+// src/utils/malformed-entity-record.ts
+function entityRecordFlags(content) {
+  const body = entityRecordBody(content);
+  let hasName = false;
+  let hasType = false;
+  let start = 0;
+  while (start <= body.length) {
+    const newline = body.indexOf("\n", start);
+    const end = newline === -1 ? body.length : newline;
+    let line = body.slice(start, end);
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (!hasName && line.startsWith("# ") && line.slice(2).trim().length > 0) hasName = true;
+    if (!hasType && line.startsWith("**Type:**") && line.slice("**Type:**".length).trim().length > 0) {
+      hasType = true;
+    }
+    if (hasName && hasType) return { hasName, hasType };
+    if (newline === -1) break;
+    start = newline + 1;
+  }
+  return { hasName, hasType };
+}
+function isUnnamedEntityRecord(content) {
+  return !entityRecordFlags(content).hasName;
+}
+function entityBodyHasText(content) {
+  const body = entityRecordBody(content);
+  for (let i = 0; i < body.length; i++) {
+    const char = body.charCodeAt(i);
+    if (char !== 32 && char !== 9 && char !== 10 && char !== 13) return true;
+  }
+  return false;
+}
+function isPopulatedUnnamedEntityRecord(content) {
+  return isUnnamedEntityRecord(content) && entityBodyHasText(content);
+}
+function isShapedUnnamedEntityRecord(content) {
+  if (!isUnnamedEntityRecord(content)) return false;
+  const body = entityRecordBody(content);
+  let start = 0;
+  while (start <= body.length) {
+    const newline = body.indexOf("\n", start);
+    const end = newline === -1 ? body.length : newline;
+    let line = body.slice(start, end);
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (line.startsWith("#") || line.startsWith("**Type:**")) return true;
+    if (newline === -1) break;
+    start = newline + 1;
+  }
+  return false;
+}
+function isMalformedEntityRecord(content) {
+  const flags = entityRecordFlags(content);
+  return !flags.hasName || !flags.hasType;
+}
+function entityRecordBody(content) {
+  const firstNewline = content.indexOf("\n");
+  if (firstNewline === -1) return content;
+  const firstLine = content.slice(0, firstNewline).endsWith("\r") ? content.slice(0, firstNewline - 1) : content.slice(0, firstNewline);
+  if (firstLine !== "---") return content;
+  const close = content.indexOf("\n---", firstNewline + 1);
+  if (close === -1) return content;
+  let rest = close + "\n---".length;
+  if (content.charAt(rest) === "\r") rest += 1;
+  if (content.charAt(rest) === "\n") rest += 1;
+  return content.slice(rest);
+}
+
+export {
+  isPopulatedUnnamedEntityRecord,
+  isShapedUnnamedEntityRecord,
+  isMalformedEntityRecord
+};
+//# sourceMappingURL=chunk-PPUNC7UX.js.map

package/dist/chunk-PPUNC7UX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/malformed-entity-record.ts"],"sourcesContent":["/**\n * Heading and type flags for an entity markdown body.\n *\n * The heading rule matches `parseEntityFile`: a line must start with `# `\n * (hash, space) and the remainder must contain a name. A tab after `#`\n * is not a heading. The type rule matches a `**Type:**` line with a\n * non-empty value. A missing type line is still readable: the parser\n * defaults the type to `other`.\n */\nfunction entityRecordFlags(content: string): { hasName: boolean; hasType: boolean } {\n  const body = entityRecordBody(content);\n  let hasName = false;\n  let hasType = false;\n  let start = 0;\n  while (start <= body.length) {\n    const newline = body.indexOf(\"\\n\", start);\n    const end = newline === -1 ? body.length : newline;\n    let line = body.slice(start, end);\n    if (line.endsWith(\"\\r\")) line = line.slice(0, -1);\n    if (!hasName && line.startsWith(\"# \") && line.slice(2).trim().length > 0) hasName = true;\n    if (!hasType && line.startsWith(\"**Type:**\") && line.slice(\"**Type:**\".length).trim().length > 0) {\n      hasType = true;\n    }\n    if (hasName && hasType) return { hasName, hasType };\n    if (newline === -1) break;\n    start = newline + 1;\n  }\n  return { hasName, hasType };\n}\n\n/**\n * No `# ` name. A named file whose type line is absent stays readable:\n * `parseEntityFile` defaults the type to `other`.\n */\nexport function isUnnamedEntityRecord(content: string): boolean {\n  return !entityRecordFlags(content).hasName;\n}\n\nfunction entityBodyHasText(content: string): boolean {\n  const body = entityRecordBody(content);\n  for (let i = 0; i < body.length; i++) {\n    const char = body.charCodeAt(i);\n    if (char !== 32 && char !== 9 && char !== 10 && char !== 13) return true;\n  }\n  return false;\n}\n\n/**\n * Unnamed entity body that still has text. An empty body under frontmatter\n * stays readable so a canonical filename can supply the type. A tab heading,\n * a blank `# ` heading, or prose with no name does not.\n */\nexport function isPopulatedUnnamedEntityRecord(content: string): boolean {\n  return isUnnamedEntityRecord(content) && entityBodyHasText(content);\n}\n\n/**\n * Unnamed file that still looks like an entity record (`#` or `**Type:**`).\n * Direct filename recall keeps unstructured placeholders such as \"content\".\n */\nexport function isShapedUnnamedEntityRecord(content: string): boolean {\n  if (!isUnnamedEntityRecord(content)) return false;\n  const body = entityRecordBody(content);\n  let start = 0;\n  while (start <= body.length) {\n    const newline = body.indexOf(\"\\n\", start);\n    const end = newline === -1 ? body.length : newline;\n    let line = body.slice(start, end);\n    if (line.endsWith(\"\\r\")) line = line.slice(0, -1);\n    if (line.startsWith(\"#\") || line.startsWith(\"**Type:**\")) return true;\n    if (newline === -1) break;\n    start = newline + 1;\n  }\n  return false;\n}\n\n/**\n * Migration gate. Canonical ids are derived from name and type, and the\n * old startup throw required an explicit `**Type:**` line. Files that\n * only have a heading stay on disk and are not renamed. Listing does not\n * use this predicate: `parseEntityFile` defaults a missing type to `other`.\n */\nexport function isMalformedEntityRecord(content: string): boolean {\n  const flags = entityRecordFlags(content);\n  return !flags.hasName || !flags.hasType;\n}\n\nfunction entityRecordBody(content: string): string {\n  const firstNewline = content.indexOf(\"\\n\");\n  if (firstNewline === -1) return content;\n  const firstLine = content.slice(0, firstNewline).endsWith(\"\\r\")\n    ? content.slice(0, firstNewline - 1)\n    : content.slice(0, firstNewline);\n  if (firstLine !== \"---\") return content;\n  const close = content.indexOf(\"\\n---\", firstNewline + 1);\n  if (close === -1) return content;\n  let rest = close + \"\\n---\".length;\n  if (content.charAt(rest) === \"\\r\") rest += 1;\n  if (content.charAt(rest) === \"\\n\") rest += 1;\n  return content.slice(rest);\n}\n"],"mappings":";AASA,SAAS,kBAAkB,SAAyD;AAClF,QAAM,OAAO,iBAAiB,OAAO;AACrC,MAAI,UAAU;AACd,MAAI,UAAU;AACd,MAAI,QAAQ;AACZ,SAAO,SAAS,KAAK,QAAQ;AAC3B,UAAM,UAAU,KAAK,QAAQ,MAAM,KAAK;AACxC,UAAM,MAAM,YAAY,KAAK,KAAK,SAAS;AAC3C,QAAI,OAAO,KAAK,MAAM,OAAO,GAAG;AAChC,QAAI,KAAK,SAAS,IAAI,EAAG,QAAO,KAAK,MAAM,GAAG,EAAE;AAChD,QAAI,CAAC,WAAW,KAAK,WAAW,IAAI,KAAK,KAAK,MAAM,CAAC,EAAE,KAAK,EAAE,SAAS,EAAG,WAAU;AACpF,QAAI,CAAC,WAAW,KAAK,WAAW,WAAW,KAAK,KAAK,MAAM,YAAY,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG;AAChG,gBAAU;AAAA,IACZ;AACA,QAAI,WAAW,QAAS,QAAO,EAAE,SAAS,QAAQ;AAClD,QAAI,YAAY,GAAI;AACpB,YAAQ,UAAU;AAAA,EACpB;AACA,SAAO,EAAE,SAAS,QAAQ;AAC5B;AAMO,SAAS,sBAAsB,SAA0B;AAC9D,SAAO,CAAC,kBAAkB,OAAO,EAAE;AACrC;AAEA,SAAS,kBAAkB,SAA0B;AACnD,QAAM,OAAO,iBAAiB,OAAO;AACrC,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,OAAO,KAAK,WAAW,CAAC;AAC9B,QAAI,SAAS,MAAM,SAAS,KAAK,SAAS,MAAM,SAAS,GAAI,QAAO;AAAA,EACtE;AACA,SAAO;AACT;AAOO,SAAS,+BAA+B,SAA0B;AACvE,SAAO,sBAAsB,OAAO,KAAK,kBAAkB,OAAO;AACpE;AAMO,SAAS,4BAA4B,SAA0B;AACpE,MAAI,CAAC,sBAAsB,OAAO,EAAG,QAAO;AAC5C,QAAM,OAAO,iBAAiB,OAAO;AACrC,MAAI,QAAQ;AACZ,SAAO,SAAS,KAAK,QAAQ;AAC3B,UAAM,UAAU,KAAK,QAAQ,MAAM,KAAK;AACxC,UAAM,MAAM,YAAY,KAAK,KAAK,SAAS;AAC3C,QAAI,OAAO,KAAK,MAAM,OAAO,GAAG;AAChC,QAAI,KAAK,SAAS,IAAI,EAAG,QAAO,KAAK,MAAM,GAAG,EAAE;AAChD,QAAI,KAAK,WAAW,GAAG,KAAK,KAAK,WAAW,WAAW,EAAG,QAAO;AACjE,QAAI,YAAY,GAAI;AACpB,YAAQ,UAAU;AAAA,EACpB;AACA,SAAO;AACT;AAQO,SAAS,wBAAwB,SAA0B;AAChE,QAAM,QAAQ,kBAAkB,OAAO;AACvC,SAAO,CAAC,MAAM,WAAW,CAAC,MAAM;AAClC;AAEA,SAAS,iBAAiB,SAAyB;AACjD,QAAM,eAAe,QAAQ,QAAQ,IAAI;AACzC,MAAI,iBAAiB,GAAI,QAAO;AAChC,QAAM,YAAY,QAAQ,MAAM,GAAG,YAAY,EAAE,SAAS,IAAI,IAC1D,QAAQ,MAAM,GAAG,eAAe,CAAC,IACjC,QAAQ,MAAM,GAAG,YAAY;AACjC,MAAI,cAAc,MAAO,QAAO;AAChC,QAAM,QAAQ,QAAQ,QAAQ,SAAS,eAAe,CAAC;AACvD,MAAI,UAAU,GAAI,QAAO;AACzB,MAAI,OAAO,QAAQ,QAAQ;AAC3B,MAAI,QAAQ,OAAO,IAAI,MAAM,KAAM,SAAQ;AAC3C,MAAI,QAAQ,OAAO,IAAI,MAAM,KAAM,SAAQ;AAC3C,SAAO,QAAQ,MAAM,IAAI;AAC3B;","names":[]}

package/dist/{chunk-EQWEIIKQ.js → chunk-PQM3B54K.js}

@@ -1,3 +1,7 @@
+import {
+  isMacOsReplicationJunkBasename
+} from "./chunk-QUIRIG2P.js";
+
 // src/maintenance/dreams-ledger.ts
 import path from "path";
 import { createReadStream } from "fs";
@@ -289,6 +293,7 @@ async function listMemoryFiles(memoryDir) {
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
+      if (isMacOsReplicationJunkBasename(entry.name)) continue;
       const full = path.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "state" || entry.name === "archive" || entry.name === "namespaces" || entry.name === ".git") continue;
@@ -313,4 +318,4 @@ export {
   runDreamsPhase,
   summarizeGovernanceResultForDreams
 };
-//# sourceMappingURL=chunk-EQWEIIKQ.js.map
+//# sourceMappingURL=chunk-PQM3B54K.js.map

package/dist/chunk-PQM3B54K.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/dreams-ledger.ts"],"sourcesContent":["/**\n * dreams-ledger.ts — per-phase telemetry for the Dreams consolidation pipeline.\n *\n * Every scheduled or manual phase run appends one JSONL entry to\n *   <memoryDir>/state/dreams-ledger.jsonl\n *\n * The entry records which phase ran, how long it took, and a small\n * itemsProcessed counter so `remnic dreams status` can aggregate the last\n * 24-hour window without scanning the full memory corpus.\n *\n * This module is intentionally side-effect-free on import (no fs calls at\n * module load time) so tests can import it without touching the filesystem.\n */\n\nimport path from \"node:path\";\nimport { createReadStream, type ReadStream } from \"node:fs\";\nimport { appendFile, lstat, mkdir, readdir, readFile } from \"node:fs/promises\";\nimport { createInterface } from \"node:readline\";\nimport { isMacOsReplicationJunkBasename } from \"../utils/macos-replication-junk.js\";\n\n// ── Types ─────────────────────────────────────────────────────────────────────\n\n/** The three named phases of the Dreams consolidation pipeline. */\nexport type DreamsPhase = \"lightSleep\" | \"rem\" | \"deepSleep\";\n\n/**\n * One entry written to the dreams ledger for every phase run.\n * Older entries that predate this field simply won't have it (no backfill).\n */\nexport interface DreamsLedgerEntry {\n  /** Schema version — always 1 for entries written by this module. */\n  schemaVersion: 1;\n  /** ISO-8601 timestamp when the phase run started. */\n  startedAt: string;\n  /** ISO-8601 timestamp when the phase run completed. */\n  completedAt: string;\n  /** Wall-clock duration in milliseconds. */\n  durationMs: number;\n  /**\n   * Which Dreams phase this entry represents.\n   * - `lightSleep` — recent activity scoring + clustering\n   * - `rem`        — cross-session synthesis, supersession, consolidation\n   * - `deepSleep`  — tier migration, page-version snapshots, archive\n   */\n  phase: DreamsPhase;\n  /** How many memory items were evaluated (scored / clustered / migrated). */\n  itemsProcessed: number;\n  /** Whether this was a dry-run (no writes committed). */\n  dryRun: boolean;\n  /**\n   * How the phase was triggered.\n   * - `scheduled` — invoked by the governance cron or orchestrator maintenance pass\n   * - `manual`    — invoked via `remnic dreams run`\n   */\n  trigger: \"scheduled\" | \"manual\";\n  /** Free-form notes for debugging (optional, never required). */\n  notes?: string;\n}\n\n/** Aggregated stats for a single phase over a time window. */\nexport interface DreamsPhaseStatus {\n  phase: DreamsPhase;\n  /** Number of phase runs in the window. */\n  runCount: number;\n  /** Total wall-clock milliseconds across all runs in the window. */\n  totalDurationMs: number;\n  /** Total items processed across all runs in the window. */\n  totalItemsProcessed: number;\n  /** ISO-8601 timestamp of the most recent completed run, or null if none. */\n  lastRunAt: string | null;\n  /** Duration of the most recent run in ms, or null if none. */\n  lastDurationMs: number | null;\n}\n\n/** Shape returned by `getDreamsStatus` — the canonical telemetry response. */\nexport interface DreamsStatusResult {\n  /** ISO-8601 start of the query window (inclusive). */\n  windowStart: string;\n  /** ISO-8601 end of the query window (exclusive). */\n  windowEnd: string;\n  /** Per-phase summaries, always present for all three phases. */\n  phases: {\n    lightSleep: DreamsPhaseStatus;\n    rem: DreamsPhaseStatus;\n    deepSleep: DreamsPhaseStatus;\n  };\n}\n\n// ── Path helpers ──────────────────────────────────────────────────────────────\n\nexport function dreamsLedgerPath(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"dreams-ledger.jsonl\");\n}\n\n// ── Writer ────────────────────────────────────────────────────────────────────\n\n/**\n * Append a single entry to the dreams ledger.\n * Creates the file (and its parent directory) if needed.\n * Uses `appendFile` (O_APPEND) so concurrent callers never overwrite each other.\n */\nexport async function appendDreamsLedgerEntry(\n  memoryDir: string,\n  entry: DreamsLedgerEntry,\n): Promise<void> {\n  const ledgerPath = dreamsLedgerPath(memoryDir);\n  await mkdir(path.dirname(ledgerPath), { recursive: true });\n  await appendFile(ledgerPath, JSON.stringify(entry) + \"\\n\", \"utf-8\");\n}\n\n// ── Reader ────────────────────────────────────────────────────────────────────\n\n/**\n * Parse and validate one ledger line into a `DreamsLedgerEntry`, or `null` when\n * blank/malformed/incomplete. Shared by the streaming reader and the windowed\n * status aggregator so both apply the identical fail-open guard.\n */\nfunction parseDreamsLedgerLine(line: string): DreamsLedgerEntry | null {\n  const trimmed = line.trim();\n  if (!trimmed) return null;\n  let parsed: Record<string, unknown>;\n  try {\n    const raw = JSON.parse(trimmed);\n    if (typeof raw !== \"object\" || raw === null) return null;\n    parsed = raw as Record<string, unknown>;\n  } catch {\n    return null; // Malformed JSON — skip (fail-open).\n  }\n\n  // Required, strongly-typed fields. A row missing or mistyping any of these is\n  // not a usable telemetry entry.\n  const phase = parsed.phase;\n  if (phase !== \"lightSleep\" && phase !== \"rem\" && phase !== \"deepSleep\") return null;\n  if (\n    typeof parsed.startedAt !== \"string\" ||\n    typeof parsed.completedAt !== \"string\" ||\n    typeof parsed.durationMs !== \"number\" ||\n    typeof parsed.itemsProcessed !== \"number\"\n  ) {\n    return null;\n  }\n\n  // Optional fields: absence is tolerated (older entries predate them, no\n  // backfill), but a PRESENT value with the wrong type/value marks the row\n  // malformed and skips it — never silently coerced to a default (issue #1910).\n  if (\"schemaVersion\" in parsed && parsed.schemaVersion !== 1) return null;\n  if (\"dryRun\" in parsed && typeof parsed.dryRun !== \"boolean\") return null;\n  if (\"trigger\" in parsed && parsed.trigger !== \"manual\" && parsed.trigger !== \"scheduled\") {\n    return null;\n  }\n\n  return {\n    schemaVersion: 1,\n    startedAt: parsed.startedAt,\n    completedAt: parsed.completedAt,\n    durationMs: parsed.durationMs,\n    phase,\n    itemsProcessed: parsed.itemsProcessed,\n    dryRun: parsed.dryRun === true,\n    trigger: parsed.trigger === \"manual\" ? \"manual\" : \"scheduled\",\n    notes: typeof parsed.notes === \"string\" ? parsed.notes : undefined,\n  };\n}\n\n/**\n * Stream the dreams ledger line-by-line. The ledger is plaintext `appendFile`\n * (never encrypted), so a raw line stream is safe at any size — heap stays\n * O(1) in the file, unlike the previous whole-file `readFile` + `split`.\n * Yields nothing when the ledger does not exist yet.\n */\nexport async function* streamDreamsLedgerLines(memoryDir: string): AsyncGenerator<string> {\n  const ledgerPath = dreamsLedgerPath(memoryDir);\n  let input: ReadStream;\n  try {\n    input = createReadStream(ledgerPath, { encoding: \"utf8\" });\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return;\n    throw err;\n  }\n  const rl = createInterface({ input, crlfDelay: Infinity });\n  try {\n    for await (const line of rl) yield line;\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return;\n    throw err;\n  } finally {\n    // Close the readline interface AND destroy the underlying stream. When a\n    // consumer stops early (e.g. `getDreamsStatus` breaks out), the generator's\n    // `.return()` runs this finally; `rl.close()` alone leaves the file\n    // descriptor open, so destroy the stream to release it (issue #1910).\n    rl.close();\n    input.destroy();\n  }\n}\n\n/**\n * Parse all valid `DreamsLedgerEntry` rows from the ledger file. Thin wrapper\n * over the line stream so any caller that genuinely needs every row still\n * works; `getDreamsStatus` streams directly and filters in-window instead.\n * Malformed lines are silently skipped (resilience over strictness for\n * telemetry).\n */\nexport async function readDreamsLedgerEntries(memoryDir: string): Promise<DreamsLedgerEntry[]> {\n  const entries: DreamsLedgerEntry[] = [];\n  for await (const line of streamDreamsLedgerLines(memoryDir)) {\n    const entry = parseDreamsLedgerLine(line);\n    if (entry) entries.push(entry);\n  }\n  return entries;\n}\n\n// ── Aggregator ────────────────────────────────────────────────────────────────\n\nconst ALL_PHASES: DreamsPhase[] = [\"lightSleep\", \"rem\", \"deepSleep\"];\nconst MAX_WINDOW_HOURS = 24 * 365 * 100;\n\nexport function normalizeDreamsStatusWindowHours(value: unknown, fallback = 24): number {\n  const raw = value === undefined || value === null ? fallback : value;\n  if (\n    typeof raw !== \"number\" ||\n    !Number.isFinite(raw) ||\n    !Number.isInteger(raw) ||\n    raw < 1 ||\n    raw > MAX_WINDOW_HOURS\n  ) {\n    throw new RangeError(`windowHours must be a positive integer no greater than ${MAX_WINDOW_HOURS}`);\n  }\n  return raw;\n}\n\n/**\n * Build per-phase 24-hour summary.\n *\n * @param memoryDir   The memory directory (parent of `state/`).\n * @param windowHours How many hours to look back (default 24).\n * @param now         Reference time (default `new Date()`).\n */\nexport async function getDreamsStatus(\n  memoryDir: string,\n  windowHours = 24,\n  now: Date = new Date(),\n): Promise<DreamsStatusResult> {\n  const boundedWindowHours = normalizeDreamsStatusWindowHours(windowHours);\n  const nowMs = now.getTime();\n  if (!Number.isFinite(nowMs)) {\n    throw new RangeError(\"now must be a valid Date\");\n  }\n  const windowMs = boundedWindowHours * 60 * 60 * 1000;\n  const windowStart = new Date(nowMs - windowMs);\n  const windowEnd = now;\n  if (!Number.isFinite(windowStart.getTime())) {\n    throw new RangeError(\"windowHours produces an invalid status window\");\n  }\n\n  const windowStartMs = windowStart.getTime();\n  const windowEndMs = windowEnd.getTime();\n\n  const statusMap = new Map<DreamsPhase, DreamsPhaseStatus>();\n  for (const phase of ALL_PHASES) {\n    statusMap.set(phase, {\n      phase,\n      runCount: 0,\n      totalDurationMs: 0,\n      totalItemsProcessed: 0,\n      lastRunAt: null,\n      lastDurationMs: null,\n    });\n  }\n\n  // Stream the ledger and aggregate every in-window row inline, so heap use is\n  // O(number of phases) regardless of window or file size (issue #1910) — no\n  // per-row array and no row cap, so a large in-window window is still counted\n  // in full rather than truncated.\n  for await (const line of streamDreamsLedgerLines(memoryDir)) {\n    const entry = parseDreamsLedgerLine(line);\n    if (!entry) continue;\n    const ts = Date.parse(entry.completedAt);\n    if (!Number.isFinite(ts) || ts < windowStartMs || ts >= windowEndMs) continue;\n    const status = statusMap.get(entry.phase);\n    if (!status) continue;\n    status.runCount += 1;\n    status.totalDurationMs += entry.durationMs;\n    status.totalItemsProcessed += entry.itemsProcessed;\n    // Track the most recent run (by completedAt).\n    if (status.lastRunAt === null || ts > Date.parse(status.lastRunAt)) {\n      status.lastRunAt = entry.completedAt;\n      status.lastDurationMs = entry.durationMs;\n    }\n  }\n\n  return {\n    windowStart: windowStart.toISOString(),\n    windowEnd: windowEnd.toISOString(),\n    phases: {\n      lightSleep: statusMap.get(\"lightSleep\")!,\n      rem: statusMap.get(\"rem\")!,\n      deepSleep: statusMap.get(\"deepSleep\")!,\n    },\n  };\n}\n\n// ── Phase runner (PR 4/4: manual invocation) ─────────────────────────────────\n\nexport interface DreamsRunOptions {\n  memoryDir: string;\n  phase: DreamsPhase;\n  dryRun?: boolean;\n}\n\n/** Public result shape — identical to what HTTP, MCP, and CLI surfaces expose. */\nexport interface DreamsRunResult {\n  phase: DreamsPhase;\n  dryRun: boolean;\n  durationMs: number;\n  itemsProcessed: number;\n  notes?: string;\n}\n\n/** Internal result shape returned by `runDreamsPhase` — includes the raw ledger entry. */\nexport interface DreamsRunResultInternal extends DreamsRunResult {\n  ledgerEntry?: DreamsLedgerEntry;\n}\n\nexport async function recordDreamsPhaseRun(options: {\n  memoryDir: string;\n  phase: DreamsPhase;\n  trigger: DreamsLedgerEntry[\"trigger\"];\n  dryRun?: boolean;\n  itemsProcessed: number;\n  notes?: string;\n  startedAt?: string;\n  completedAt?: string;\n}): Promise<DreamsLedgerEntry> {\n  const startedAt = options.startedAt ?? new Date().toISOString();\n  const completedAt = options.completedAt ?? new Date().toISOString();\n  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));\n  const ledgerEntry: DreamsLedgerEntry = {\n    schemaVersion: 1,\n    startedAt,\n    completedAt,\n    durationMs: Number.isFinite(durationMs) ? durationMs : 0,\n    phase: options.phase,\n    itemsProcessed: Math.max(0, Math.floor(options.itemsProcessed)),\n    dryRun: options.dryRun === true,\n    trigger: options.trigger,\n    notes: options.notes,\n  };\n  if (!ledgerEntry.dryRun) {\n    await appendDreamsLedgerEntry(options.memoryDir, ledgerEntry);\n  }\n  return ledgerEntry;\n}\n\n/**\n * Manually invoke a single Dreams phase pass.\n *\n * For light sleep and REM: runs a lightweight scan against the observation\n * ledger and returns a count of items that would be (or were, if not dry-run)\n * processed.  The actual heavy consolidation is long-running and orchestrator-\n * bound; the manual surface delegates to existing ledger utilities and returns\n * the phase telemetry so callers get the same shape as a scheduled run.\n *\n * For deep sleep: delegates to the memory governance run (shadow mode when\n * dryRun is true, apply mode otherwise).\n */\nexport async function runDreamsPhase(\n  options: DreamsRunOptions,\n  governanceRunner?: (opts: { memoryDir: string; dryRun: boolean }) => Promise<{ scannedMemories: number; appliedActionCount: number; notes?: string }>,\n  phaseRunner?: (opts: { memoryDir: string; phase: Exclude<DreamsPhase, \"deepSleep\"> }) => Promise<{ itemsProcessed: number; notes?: string }>,\n): Promise<DreamsRunResultInternal> {\n  const { memoryDir, phase, dryRun = false } = options;\n  const startedAt = new Date().toISOString();\n\n  let itemsProcessed = 0;\n  let notes: string | undefined;\n\n  if (phase === \"lightSleep\") {\n    // Dry-run light sleep counts recent observation entries as a preview.\n    // Live runs must be backed by the orchestrator phase runner so the command\n    // never reports success without executing the phase.\n    if (!dryRun) {\n      if (!phaseRunner) {\n        throw new Error(\"light-sleep manual runs require a phase runner\");\n      }\n      const result = await phaseRunner({ memoryDir, phase });\n      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));\n      notes = result.notes ?? `scored ${itemsProcessed} memories`;\n    } else {\n      // Light sleep: count observation ledger entries from the last 24h as a\n      // proxy for \"items scored\". The live value-scoring pass runs through the\n      // phase runner above.\n      try {\n        const ledgerPath = path.join(memoryDir, \"state\", \"observation-ledger\", \"rebuilt-observations.jsonl\");\n        let raw = \"\";\n        try {\n          raw = await readFile(ledgerPath, \"utf-8\");\n        } catch {\n          // No ledger yet — zero items.\n        }\n        const lines = raw.split(\"\\n\").filter((l) => l.trim().length > 0);\n        const nowMs = Date.now();\n        const cutoff = nowMs - 24 * 60 * 60 * 1000;\n        itemsProcessed = lines.filter((line) => {\n          try {\n            const obj = JSON.parse(line) as {\n              hour?: string;\n              timestamp?: string;\n              ts?: string;\n            };\n            const timestamp = typeof obj.hour === \"string\"\n              ? obj.hour\n              : typeof obj.ts === \"string\"\n                ? obj.ts\n                : typeof obj.timestamp === \"string\"\n                  ? obj.timestamp\n                  : null;\n            if (!timestamp) return false;\n            const ms = Date.parse(timestamp);\n            return Number.isFinite(ms) && ms >= cutoff && ms < nowMs;\n          } catch {\n            return false;\n          }\n        }).length;\n        notes = `dry-run: would score ${itemsProcessed} observation entries`;\n      } catch (err) {\n        throw new Error(`light-sleep scan failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    }\n  } else if (phase === \"rem\") {\n    if (!dryRun) {\n      if (!phaseRunner) {\n        throw new Error(\"REM manual runs require a phase runner\");\n      }\n      const result = await phaseRunner({ memoryDir, phase });\n      itemsProcessed = Math.max(0, Math.floor(result.itemsProcessed));\n      notes = result.notes ?? `REM pass assessed ${itemsProcessed} memories`;\n    } else {\n      // REM dry-runs estimate candidates without synthesizing or archiving.\n      try {\n        const stateFilePath = path.join(memoryDir, \"state\", \"semantic-consolidation-last-run.json\");\n        let lastRunAt: string | null = null;\n        try {\n          const stateRaw = await readFile(stateFilePath, \"utf-8\");\n          const stateData = JSON.parse(stateRaw) as { lastRunAt?: string };\n          lastRunAt = stateData.lastRunAt ?? null;\n        } catch {\n          // No state file — never run.\n        }\n        const memFiles = await listMemoryFiles(memoryDir);\n        itemsProcessed = memFiles.length;\n        notes = `dry-run: ${itemsProcessed} memories would enter REM consolidation pass${lastRunAt ? ` (last run: ${lastRunAt})` : \" (never run)\"}`;\n      } catch (err) {\n        throw new Error(`REM scan failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    }\n  } else {\n    // deep sleep\n    if (governanceRunner) {\n      try {\n        const result = await governanceRunner({ memoryDir, dryRun });\n        itemsProcessed = result.scannedMemories;\n        notes = result.notes ?? (dryRun ? `dry-run: ${result.appliedActionCount} actions proposed` : `${result.appliedActionCount} actions applied`);\n      } catch (err) {\n        throw new Error(`deep-sleep governance run failed: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    } else {\n      // Fallback: count memory files.\n      const memFiles = await listMemoryFiles(memoryDir);\n      itemsProcessed = memFiles.length;\n      notes = dryRun\n        ? `dry-run: ${itemsProcessed} memories eligible for deep-sleep governance`\n        : `assessed ${itemsProcessed} memories for deep-sleep governance`;\n    }\n  }\n\n  const completedAt = new Date().toISOString();\n  const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));\n  let ledgerEntry: DreamsLedgerEntry | undefined;\n  try {\n    ledgerEntry = await recordDreamsPhaseRun({\n      memoryDir,\n      startedAt,\n      completedAt,\n      phase,\n      itemsProcessed,\n      dryRun,\n      trigger: \"manual\",\n      notes,\n    });\n  } catch {\n    // Telemetry is best-effort: the phase work has already completed.\n  }\n\n  return {\n    phase,\n    dryRun,\n    durationMs: ledgerEntry?.durationMs ?? durationMs,\n    itemsProcessed,\n    notes,\n    ledgerEntry,\n  };\n}\n\n// ── Shared governance result mapping ──────────────────────────────────────────\n\nexport function summarizeGovernanceResultForDreams(\n  govResult: {\n    summary?: { scannedMemories?: number };\n    proposedActions: unknown[];\n    appliedActions: unknown[];\n    reviewQueue: unknown[];\n  },\n  dryRun: boolean,\n): { scannedMemories: number; appliedActionCount: number; notes?: string } {\n  const proposedCount = govResult.proposedActions.length;\n  const appliedCount = govResult.appliedActions.length;\n  const scannedCount =\n    typeof govResult.summary?.scannedMemories === \"number\" &&\n    Number.isFinite(govResult.summary.scannedMemories)\n      ? Math.max(0, Math.floor(govResult.summary.scannedMemories))\n      : govResult.reviewQueue.length;\n  return {\n    scannedMemories: scannedCount,\n    appliedActionCount: appliedCount,\n    notes: dryRun\n      ? `shadow mode: ${proposedCount} actions proposed`\n      : `applied ${appliedCount} actions`,\n  };\n}\n\n// ── Internal helpers ──────────────────────────────────────────────────────────\n\nasync function listMemoryFiles(memoryDir: string): Promise<string[]> {\n  const out: string[] = [];\n  try {\n    const root = await lstat(memoryDir);\n    if (root.isSymbolicLink()) {\n      throw new Error(`memoryDir must not be a symlink: ${memoryDir}`);\n    }\n    if (!root.isDirectory()) return out;\n  } catch (err) {\n    if (err instanceof Error && /must not be a symlink/.test(err.message)) {\n      throw err;\n    }\n    return out;\n  }\n\n  async function walk(dir: string): Promise<void> {\n    let entries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean; isSymbolicLink(): boolean }>;\n    try {\n      entries = (await readdir(dir, { withFileTypes: true })) as typeof entries;\n    } catch {\n      return;\n    }\n    for (const entry of entries) {\n      if (entry.isSymbolicLink()) continue;\n      if (isMacOsReplicationJunkBasename(entry.name)) continue;\n      const full = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        // Skip state/ and archive/ subdirs.\n        if (\n          entry.name === \"state\" ||\n          entry.name === \"archive\" ||\n          entry.name === \"namespaces\" ||\n          entry.name === \".git\"\n        ) continue;\n        await walk(full);\n      } else if (entry.isFile() && entry.name.endsWith(\".md\")) {\n        out.push(full);\n      }\n    }\n  }\n\n  await walk(memoryDir);\n  return out;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-4TTGRETU.js → chunk-PRU7OF3Y.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-LZACDIM2.js";
 import {
   composeSalvagedEnvelope
-} from "./chunk-ZSJGYC3C.js";
+} from "./chunk-OQJKY3Z5.js";
 import {
   resolveDefaultNamespaceRoot
-} from "./chunk-X3VID2TT.js";
+} from "./chunk-RI2KCQHP.js";
 import {
   StorageManager,
   readRawMemoryDocument
-} from "./chunk-Y3VDGK2O.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-BJMBJZ2Y.js";
 import {
   readMaybeEncryptedLines
-} from "./chunk-FQD2KPQH.js";
+} from "./chunk-P55FACBG.js";
 import {
   assertPathInsideRoot
 } from "./chunk-C7HJ3NEI.js";
@@ -1869,4 +1869,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-4TTGRETU.js.map
+//# sourceMappingURL=chunk-PRU7OF3Y.js.map

package/dist/{chunk-K2FSASGZ.js → chunk-PVHQSLNN.js}

@@ -1,21 +1,21 @@
 import {
   resolveWorkProductLedgerDir,
   validateWorkProductLedgerEntry
-} from "./chunk-G7NYVKD6.js";
+} from "./chunk-B2NXOVZN.js";
 import {
   TranscriptManager
-} from "./chunk-Q4E24IRR.js";
+} from "./chunk-HDN7IVIO.js";
 import {
   resolveCommitmentLedgerDir,
   validateCommitmentLedgerEntry
-} from "./chunk-NHLLKEKK.js";
+} from "./chunk-ZAJLJ35W.js";
 import {
   parseConfig
-} from "./chunk-FZB4TS2W.js";
+} from "./chunk-VPXIKBPX.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
-} from "./chunk-HM7RHKS4.js";
+} from "./chunk-4RNBLLZR.js";
 import {
   assertIsoRecordedAt,
   assertSafePathSegment,
@@ -28,7 +28,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-B6O2YLUR.js";
+} from "./chunk-2Z5DIDQD.js";
 
 // src/resume-bundles.ts
 import path from "path";
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-K2FSASGZ.js.map
+//# sourceMappingURL=chunk-PVHQSLNN.js.map

package/dist/{chunk-SVDU4OHO.js → chunk-Q35L7TYB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-DBB5JPSL.js";
 import {
   isGenericRecallExcludedPath
-} from "./chunk-OAIWPB2I.js";
+} from "./chunk-FT4UQYOV.js";
 import {
   isChangeOrientedQuery
 } from "./chunk-EH3HNCAM.js";
@@ -69,4 +69,4 @@ export {
   filterRecentScanMemoriesForStateView,
   indexStateViewAnnotatedResults
 };
-//# sourceMappingURL=chunk-SVDU4OHO.js.map
+//# sourceMappingURL=chunk-Q35L7TYB.js.map

package/dist/{chunk-5VC7J76U.js → chunk-QPH52AZB.js}

@@ -10,7 +10,7 @@ import {
 import {
   readJsonFile,
   writeJsonFileAtomic
-} from "./chunk-B6O2YLUR.js";
+} from "./chunk-2Z5DIDQD.js";
 import {
   isPathInsideStorageRoot,
   isSafeLegacyPathSegment
@@ -131,4 +131,4 @@ export {
   readHarmonicSourceMemory,
   readUnresolvedHarmonicSources
 };
-//# sourceMappingURL=chunk-5VC7J76U.js.map
+//# sourceMappingURL=chunk-QPH52AZB.js.map

package/dist/{chunk-6T42L5FI.js → chunk-QS3OLP5I.js}

@@ -1,7 +1,7 @@
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-QWWMS4AE.js";
+} from "./chunk-3MO4LWYU.js";
 
 // src/recall-navigate-disclosure.ts
 function disclosureRank(level) {
@@ -27,4 +27,4 @@ export {
   disclosureRank,
   planDisclosureStep
 };
-//# sourceMappingURL=chunk-6T42L5FI.js.map
+//# sourceMappingURL=chunk-QS3OLP5I.js.map

package/dist/{chunk-P34FDDB5.js → chunk-QSEUUQUF.js}

@@ -1,6 +1,6 @@
 import {
   listNamespaces
-} from "./chunk-XHWJRUVP.js";
+} from "./chunk-V3TXIXXY.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-IG747LRN.js";
@@ -282,4 +282,4 @@ export {
   computeServiceCorpusWatermarks,
   computeServiceCorpusCensus
 };
-//# sourceMappingURL=chunk-P34FDDB5.js.map
+//# sourceMappingURL=chunk-QSEUUQUF.js.map

package/dist/chunk-QUIRIG2P.js

@@ -0,0 +1,31 @@
+// src/utils/macos-replication-junk.ts
+var warnedJunkDirectories = /* @__PURE__ */ new Set();
+function isMacOsReplicationJunkBasename(basename) {
+  return basename === ".DS_Store" || basename.startsWith("._");
+}
+function withoutMacOsReplicationJunk(entries, basenameOf) {
+  const kept = [];
+  let ignored = 0;
+  for (const entry of entries) {
+    if (isMacOsReplicationJunkBasename(basenameOf(entry))) {
+      ignored += 1;
+      continue;
+    }
+    kept.push(entry);
+  }
+  return { kept, ignored };
+}
+function warnIgnoredMacOsReplicationJunk(directoryKey, count, warn) {
+  if (count <= 0) return;
+  const key = `${directoryKey}\0${count}`;
+  if (warnedJunkDirectories.has(key)) return;
+  warnedJunkDirectories.add(key);
+  warn(`ignored ${count} macOS replication junk file(s) (._* and .DS_Store)`);
+}
+
+export {
+  isMacOsReplicationJunkBasename,
+  withoutMacOsReplicationJunk,
+  warnIgnoredMacOsReplicationJunk
+};
+//# sourceMappingURL=chunk-QUIRIG2P.js.map

package/dist/chunk-QUIRIG2P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/macos-replication-junk.ts"],"sourcesContent":["/**\n * macOS Finder metadata that arrives through Mac-to-Linux copies.\n *\n * AppleDouble sidecars are named `._` plus the real file's basename\n * (`._project-notes.md` beside `project-notes.md`). Finder also writes\n * `.DS_Store` into any directory it opens. Neither is a Remnic record.\n * Directory scanners and replication must ignore them so they are never\n * parsed as entities, memories, or sync objects.\n *\n * QMD's own indexer already drops every hidden path (`dot: false` plus a\n * hidden-segment filter). Callers that build index inputs themselves still\n * use this helper so the non-QMD scanners stay in parity.\n */\n\nconst warnedJunkDirectories = new Set<string>();\n\n/** True for an AppleDouble sidecar or a Finder `.DS_Store` file. */\nexport function isMacOsReplicationJunkBasename(basename: string): boolean {\n  return basename === \".DS_Store\" || basename.startsWith(\"._\");\n}\n\n/** True when the final path segment is macOS replication junk. */\nexport function isMacOsReplicationJunkRelativePath(relPath: string): boolean {\n  const normalized = relPath.includes(\"\\\\\") ? relPath.replaceAll(\"\\\\\", \"/\") : relPath;\n  const slash = normalized.lastIndexOf(\"/\");\n  const basename = slash === -1 ? normalized : normalized.slice(slash + 1);\n  return isMacOsReplicationJunkBasename(basename);\n}\n\n/**\n * Drop junk names from a directory listing. `ignored` is the count of\n * names removed, so the caller can emit one summary warning.\n */\nexport function withoutMacOsReplicationJunk<T>(\n  entries: readonly T[],\n  basenameOf: (entry: T) => string\n): { kept: T[]; ignored: number } {\n  const kept: T[] = [];\n  let ignored = 0;\n  for (const entry of entries) {\n    if (isMacOsReplicationJunkBasename(basenameOf(entry))) {\n      ignored += 1;\n      continue;\n    }\n    kept.push(entry);\n  }\n  return { kept, ignored };\n}\n\n/**\n * Emit at most one junk warning per directory and count. A later scan of\n * the same directory (entity migration, then entity load) stays quiet\n * instead of repeating the same summary.\n */\nexport function warnIgnoredMacOsReplicationJunk(\n  directoryKey: string,\n  count: number,\n  warn: (message: string) => void\n): void {\n  if (count <= 0) return;\n  const key = `${directoryKey}\\0${count}`;\n  if (warnedJunkDirectories.has(key)) return;\n  warnedJunkDirectories.add(key);\n  warn(`ignored ${count} macOS replication junk file(s) (._* and .DS_Store)`);\n}\n"],"mappings":";AAcA,IAAM,wBAAwB,oBAAI,IAAY;AAGvC,SAAS,+BAA+B,UAA2B;AACxE,SAAO,aAAa,eAAe,SAAS,WAAW,IAAI;AAC7D;AAcO,SAAS,4BACd,SACA,YACgC;AAChC,QAAM,OAAY,CAAC;AACnB,MAAI,UAAU;AACd,aAAW,SAAS,SAAS;AAC3B,QAAI,+BAA+B,WAAW,KAAK,CAAC,GAAG;AACrD,iBAAW;AACX;AAAA,IACF;AACA,SAAK,KAAK,KAAK;AAAA,EACjB;AACA,SAAO,EAAE,MAAM,QAAQ;AACzB;AAOO,SAAS,gCACd,cACA,OACA,MACM;AACN,MAAI,SAAS,EAAG;AAChB,QAAM,MAAM,GAAG,YAAY,KAAK,KAAK;AACrC,MAAI,sBAAsB,IAAI,GAAG,EAAG;AACpC,wBAAsB,IAAI,GAAG;AAC7B,OAAK,WAAW,KAAK,qDAAqD;AAC5E;","names":[]}

package/dist/{chunk-PAAJWQH5.js → chunk-QUMKDRCF.js}

@@ -1,7 +1,7 @@
 import {
   CONVERGE_CONFLICT_POLICIES,
   DEFAULT_CONVERGE_CONFLICT_POLICY
-} from "./chunk-6MINUTGJ.js";
+} from "./chunk-EHHQJTAU.js";
 import {
   validateArchiveRelativePath
 } from "./chunk-GCGJW34D.js";
@@ -435,4 +435,4 @@ export {
   summarizeReconcilePlan,
   planReconciliation
 };
-//# sourceMappingURL=chunk-PAAJWQH5.js.map
+//# sourceMappingURL=chunk-QUMKDRCF.js.map

package/dist/{chunk-KZEMFD6E.js → chunk-R2H4ZFBJ.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-OFEHITAZ.js";
+} from "./chunk-OXNTOHL6.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-QWWMS4AE.js";
+} from "./chunk-3MO4LWYU.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-KZEMFD6E.js.map
+//# sourceMappingURL=chunk-R2H4ZFBJ.js.map

package/dist/{chunk-X3VID2TT.js → chunk-RI2KCQHP.js}

@@ -1,13 +1,13 @@
 import {
   StorageManager
-} from "./chunk-Y3VDGK2O.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   keyring_exports,
   secureStoreDir
 } from "./chunk-BJMBJZ2Y.js";
 import {
   MutationSerializer
-} from "./chunk-EHRE7ZG3.js";
+} from "./chunk-5B5WYAHQ.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-PCXDUHQH.js";
@@ -20,6 +20,9 @@ import {
   resolveNamespaceCapabilities,
   resolveRecallAuxiliaryCapabilities
 } from "./chunk-C5LWPYS3.js";
+import {
+  isMacOsReplicationJunkBasename
+} from "./chunk-QUIRIG2P.js";
 import {
   ALL_CATEGORY_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -42,6 +45,7 @@ async function hasStoredEntries(p) {
     if (!entry.isDirectory()) return true;
     const children = await readdir(p, { withFileTypes: true });
     for (const child of children) {
+      if (isMacOsReplicationJunkBasename(child.name)) continue;
       const childPath = path.join(p, child.name);
       if (child.isSymbolicLink() || child.isFile()) return true;
       if (child.isDirectory() && await hasStoredEntries(childPath)) return true;
@@ -412,4 +416,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-X3VID2TT.js.map
+//# sourceMappingURL=chunk-RI2KCQHP.js.map