@remnic/core 1.1.2 → 1.1.3

package/dist/chunk-32KD5IHZ.js

@@ -0,0 +1,245 @@
+import {
+  gatherConsoleState
+} from "./chunk-TYEOAFH3.js";
+
+// src/console/tui.ts
+var ANSI_CLEAR_HOME = "\x1B[2J\x1B[H";
+var ANSI_HIDE_CURSOR = "\x1B[?25l";
+var ANSI_SHOW_CURSOR = "\x1B[?25h";
+var FRAME_INNER_WIDTH = 70;
+var DEFAULT_REFRESH_INTERVAL_MS = 2e3;
+function runConsoleTui(orchestrator, options = {}) {
+  const refreshIntervalMs = Math.max(
+    50,
+    options.refreshIntervalMs ?? DEFAULT_REFRESH_INTERVAL_MS
+  );
+  const output = options.output ?? process.stdout;
+  const now = options.now ?? (() => Date.now());
+  const installSigintHandler = options.installSigintHandler ?? true;
+  let stopped = false;
+  let inFlight = false;
+  let inFlightTickPromise = null;
+  let traceWritePending = false;
+  let traceFramesDropped = 0;
+  let resolveDone;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+  safeWrite(output, ANSI_HIDE_CURSOR);
+  const tick = async () => {
+    if (stopped || inFlight) return;
+    inFlight = true;
+    try {
+      let snapshot = null;
+      let renderError = null;
+      try {
+        snapshot = await gatherConsoleState(orchestrator);
+      } catch (err) {
+        renderError = describeError(err);
+      }
+      if (stopped) return;
+      let frame;
+      try {
+        frame = renderFrame({ snapshot, renderError, now });
+      } catch (err) {
+        frame = `remnic console: render failed: ${describeError(err)}
+`;
+      }
+      safeWrite(output, ANSI_CLEAR_HOME);
+      safeWrite(output, frame);
+      if (snapshot && options.traceRecorder && !traceWritePending) {
+        traceWritePending = true;
+        void options.traceRecorder.append(snapshot).catch(() => {
+        }).finally(() => {
+          traceWritePending = false;
+        });
+      } else if (snapshot && options.traceRecorder) {
+        traceFramesDropped += 1;
+      }
+    } finally {
+      inFlight = false;
+    }
+  };
+  const launchTick = () => {
+    const p = runTickSafely(tick);
+    inFlightTickPromise = p;
+    void p.then(() => {
+      if (inFlightTickPromise === p) {
+        inFlightTickPromise = null;
+      }
+    });
+  };
+  launchTick();
+  const handle = setInterval(launchTick, refreshIntervalMs);
+  const sigintHandler = () => {
+    stop();
+  };
+  if (installSigintHandler) {
+    process.on("SIGINT", sigintHandler);
+  }
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(handle);
+    if (installSigintHandler) {
+      try {
+        process.removeListener("SIGINT", sigintHandler);
+      } catch {
+      }
+    }
+    safeWrite(output, ANSI_SHOW_CURSOR);
+    void (async () => {
+      try {
+        const pendingTick = inFlightTickPromise;
+        if (pendingTick) {
+          await pendingTick;
+        }
+      } finally {
+        resolveDone();
+      }
+    })();
+  };
+  return {
+    stop,
+    done,
+    getDroppedTraceFrames: () => traceFramesDropped
+  };
+}
+function renderFrame(input) {
+  const ts = new Date(input.now()).toISOString();
+  const lines = [];
+  lines.push(renderHeader(ts));
+  for (const panel of renderPanels(input)) {
+    lines.push(panel);
+  }
+  lines.push(renderFooter());
+  return lines.join("\n") + "\n";
+}
+function renderHeader(ts) {
+  const title = " remnic console ";
+  const trailing = ` ${ts} `;
+  const fillerLen = Math.max(
+    1,
+    FRAME_INNER_WIDTH - title.length - trailing.length
+  );
+  const filler = "\u2550".repeat(fillerLen);
+  return `\u2554${title}${filler}${trailing}\u2557`;
+}
+function renderFooter() {
+  return `\u255A${"\u2550".repeat(FRAME_INNER_WIDTH)}\u255D`;
+}
+function renderPanels(input) {
+  const lines = [];
+  const snap = input.snapshot;
+  if (input.renderError !== null) {
+    lines.push(panelLine("Error", `refresh failed: ${input.renderError}`));
+    lines.push(panelLine("Buffer", "(unavailable)"));
+    lines.push(panelLine("Extraction", "(unavailable)"));
+    lines.push(panelLine("Dedup", "(unavailable)"));
+    lines.push(panelLine("Maintenance", "(unavailable)"));
+    lines.push(panelLine("QMD", "(unavailable)"));
+    return lines;
+  }
+  if (snap) {
+    lines.push(
+      panelLine(
+        "Buffer",
+        `turns=${snap.bufferState.turnsCount} bytes=${snap.bufferState.byteCount}`
+      )
+    );
+    const verdicts = snap.extractionQueue.recentVerdicts;
+    const accepts = verdicts.filter((v) => v.kind === "accept").length;
+    const rejects = verdicts.filter((v) => v.kind === "reject").length;
+    lines.push(
+      panelLine(
+        "Extraction",
+        `queue=${snap.extractionQueue.depth}  recent verdicts: accept(${accepts})/reject(${rejects})`
+      )
+    );
+    const dedupSummary = formatDedupSummary(snap.dedupRecent, input.now);
+    lines.push(panelLine("Dedup", dedupSummary));
+    const maintSummary = formatMaintenanceTail(snap.maintenanceLedgerTail);
+    lines.push(panelLine("Maintenance", maintSummary));
+    lines.push(panelLine("QMD", formatQmdSummary(snap)));
+  }
+  if (snap && snap.errors.length > 0) {
+    const head = snap.errors[0];
+    lines.push(panelLine("Errors", head ?? ""));
+  }
+  return lines;
+}
+function formatDedupSummary(decisions, now) {
+  if (decisions.length === 0) return "no recent decisions";
+  const last = decisions[decisions.length - 1];
+  if (!last) return "no recent decisions";
+  const ageMs = ageMsFromIso(last.ts, now);
+  const ageStr = ageMs === null ? "T-?" : `T-${Math.round(ageMs / 1e3)}s`;
+  const fp = last.fingerprint ? `hash=${last.fingerprint}` : "hash=?";
+  return `recent: ${fp} decision=${last.decision} (${ageStr})`;
+}
+function formatMaintenanceTail(events) {
+  if (events.length === 0) return "no events";
+  const last = events[events.length - 1];
+  if (!last) return "no events";
+  return `n=${events.length}  last: ${last.category} ${truncate(last.summary, 40)}`;
+}
+function formatQmdSummary(snap) {
+  const probe = snap.qmdProbe.available ? "ok" : "down";
+  const uptimeH = snap.daemon.uptimeMs / 36e5;
+  const uptimeStr = uptimeH < 1 ? `${Math.round(snap.daemon.uptimeMs / 1e3)}s` : `${uptimeH.toFixed(1)}h`;
+  const mode = snap.qmdProbe.daemonMode ? "daemon" : "cli";
+  return `probe=${probe}  mode=${mode}  uptime=${uptimeStr}`;
+}
+function panelLine(label, value) {
+  const LABEL_WIDTH = 13;
+  const labelCol = padRight(label, LABEL_WIDTH);
+  const remaining = FRAME_INNER_WIDTH - LABEL_WIDTH - 2;
+  const valueCol = padRight(truncate(value, remaining), remaining);
+  return `\u2551 ${labelCol}${valueCol} \u2551`;
+}
+function padRight(s, width) {
+  if (s.length >= width) return s;
+  return s + " ".repeat(width - s.length);
+}
+function truncate(s, max) {
+  if (max <= 0) return "";
+  if (s.length <= max) return s;
+  if (max <= 1) return s.slice(0, max);
+  return s.slice(0, max - 1) + "\u2026";
+}
+function ageMsFromIso(iso, now) {
+  const ms = Date.parse(iso);
+  if (!Number.isFinite(ms)) return null;
+  const delta = now() - ms;
+  return delta < 0 ? 0 : delta;
+}
+async function runTickSafely(tick) {
+  try {
+    await tick();
+  } catch {
+  }
+}
+function safeWrite(output, chunk) {
+  try {
+    output.write(chunk);
+  } catch {
+  }
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  try {
+    return String(err);
+  } catch {
+    return "unknown error";
+  }
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
+
+export {
+  runConsoleTui,
+  renderFrame,
+  stripAnsi
+};
+//# sourceMappingURL=chunk-32KD5IHZ.js.map

package/dist/chunk-32KD5IHZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/console/tui.ts"],"sourcesContent":["/**\n * Operator console TUI for issue #688 (PR 2/3).\n *\n * Renders a five-panel one-screen layout that periodically polls\n * `gatherConsoleState` and repaints the terminal. Deliberately uses\n * the minimal-deps \"clear + repaint\" approach (no curses / blessed /\n * ink) — we just emit ANSI control sequences directly to the output\n * stream. This keeps the surface portable and dependency-free.\n *\n * PR 1/3 (#721) shipped `gatherConsoleState` plus the CLI's\n * `--state-only` flag (one-shot JSON snapshot). PR 2/3 wires the\n * interactive surface. Trace replay (`--trace <session-id>`) is\n * deferred to PR 3/3.\n *\n * Design contract:\n *   - Read-only: never mutates orchestrator state.\n *   - Resilient: a thrown error in one refresh cycle must NOT crash\n *     the loop. Errors are surfaced inside the rendered frame.\n *   - Cleanly stoppable: `runConsoleTui` returns a `stop()` that\n *     clears the interval, restores the cursor, and resolves the\n *     pending exit promise. SIGINT triggers the same cleanup.\n *   - No external deps: only ANSI control sequences.\n */\n\nimport type { Writable } from \"node:stream\";\n\nimport {\n  gatherConsoleState,\n  type ConsoleStateOrchestratorLike,\n  type ConsoleStateSnapshot,\n} from \"./state.js\";\n\n/** ANSI: clear screen + move cursor to home (top-left). */\nconst ANSI_CLEAR_HOME = \"\\x1b[2J\\x1b[H\";\n/** ANSI: hide / show the cursor (we hide during the loop, restore on exit). */\nconst ANSI_HIDE_CURSOR = \"\\x1b[?25l\";\nconst ANSI_SHOW_CURSOR = \"\\x1b[?25h\";\n\n/** Total inner width of the rendered frame (between the box borders). */\nconst FRAME_INNER_WIDTH = 70;\n\n/** Default refresh interval in milliseconds. Chosen to match the spec. */\nconst DEFAULT_REFRESH_INTERVAL_MS = 2000;\n\nexport interface RunConsoleTuiOptions {\n  /** Polling interval in milliseconds. Defaults to 2000ms. */\n  refreshIntervalMs?: number;\n  /** Output stream. Defaults to `process.stdout`. */\n  output?: Writable;\n  /**\n   * Optional clock injection — primarily for tests so the rendered\n   * timestamp is deterministic. Defaults to `Date.now`.\n   */\n  now?: () => number;\n  /**\n   * If true, install a SIGINT handler that calls `stop()` and resolves\n   * the returned promise. Defaults to true. Tests typically pass false.\n   */\n  installSigintHandler?: boolean;\n  /**\n   * Optional trace recorder. When provided, every successfully\n   * gathered snapshot is appended to the recorder for later replay\n   * via `replayTrace`. Failed appends are surfaced through the\n   * recorder's `getLastError()` and never crash the loop (issue\n   * #688 PR 3/3).\n   */\n  traceRecorder?: {\n    append: (snapshot: ConsoleStateSnapshot) => Promise<void>;\n  };\n}\n\nexport interface RunConsoleTuiHandle {\n  /**\n   * Stop the refresh loop and restore the cursor. Returns immediately;\n   * callers should `await handle.done` to wait for any in-flight tick\n   * (and its trace append) to finish. Codex P2 (#732 round 4): without\n   * the in-flight await on the `done` path, a Ctrl-C that fires while\n   * a tick is past its `stopped` check could still call\n   * `traceRecorder.append` AFTER the CLI begins closing the recorder.\n   */\n  stop: () => void;\n  /**\n   * Resolves once `stop()` has been invoked, the interval is cleared,\n   * AND any in-flight tick (including its fire-and-forget trace\n   * append) has resolved. Callers that close a trace recorder after\n   * the TUI exits MUST await this promise before initiating close,\n   * otherwise the close path can race a still-running `append` call\n   * and surface phantom \"post-close\" appends to the recorder. Codex\n   * P2 (#732 round 4).\n   */\n  done: Promise<void>;\n  /**\n   * Number of trace frames that were dropped due to backpressure (i.e.\n   * the previous `traceRecorder.append()` had not yet resolved when\n   * the tick fired). Non-zero values indicate the trace recorder is\n   * falling behind — typically caused by a slow or network-backed\n   * filesystem. Codex P2 (PR #732 round 5): exposed so operators can\n   * detect recording lag via `--state-only` snapshots or future\n   * diagnostic surfaces.\n   */\n  getDroppedTraceFrames: () => number;\n}\n\n/**\n * Start the operator console TUI. Returns immediately with a handle\n * exposing `stop()` and a `done` promise that resolves once the loop\n * has been torn down. The caller can `await handle.done` to block\n * until the user (or a SIGINT) exits.\n */\nexport function runConsoleTui(\n  orchestrator: ConsoleStateOrchestratorLike,\n  options: RunConsoleTuiOptions = {},\n): RunConsoleTuiHandle {\n  const refreshIntervalMs = Math.max(\n    50,\n    options.refreshIntervalMs ?? DEFAULT_REFRESH_INTERVAL_MS,\n  );\n  const output: Writable = options.output ?? process.stdout;\n  const now = options.now ?? (() => Date.now());\n  const installSigintHandler = options.installSigintHandler ?? true;\n\n  let stopped = false;\n  let inFlight = false;\n  // Codex P2 (PR #732 round 4): track the in-flight tick promise so\n  // `stop()` can await it before resolving `done`. Without this, a\n  // Ctrl-C that fires while a tick is past its `if (stopped) return`\n  // check can still execute `traceRecorder.append(snapshot)` AFTER\n  // `done` resolves and the CLI shutdown path begins closing the\n  // recorder. By awaiting the tick body, we ensure\n  // `recorder.append()` has at least been called (synchronously\n  // enqueueing the line onto the recorder's internal writeChain)\n  // before `done` resolves; the recorder's `close()` then drains\n  // that writeChain. Without the await, `close()` can begin draining\n  // while the tick is still about to call `append()`, producing a\n  // post-close append.\n  //\n  // We deliberately do NOT also await the resulting fire-and-forget\n  // trace promise. The append is fire-and-forget on purpose\n  // (backpressure: see comment further below); a wedged disk that\n  // stalls the append must not also stall shutdown. The recorder's\n  // own `close()` path (combined with `flushWithTimeout` in the CLI)\n  // is the right place to bound the disk-drain wait.\n  let inFlightTickPromise: Promise<void> | null = null;\n  // Codex P2 (PR #732): backpressure for trace recording. If the\n  // previous fire-and-forget `append()` has not resolved yet, we drop\n  // the current frame instead of enqueuing it onto the recorder's\n  // internal writeChain. Without this guard, a wedged filesystem\n  // would let memory grow unboundedly — every tick adds a JSON line\n  // to a serialized chain that never drains. Dropping is preferable\n  // to OOM; the operator can inspect `getLastError()` to learn that\n  // tracing fell behind.\n  let traceWritePending = false;\n  let traceFramesDropped = 0;\n  let resolveDone!: () => void;\n  const done = new Promise<void>((resolve) => {\n    resolveDone = resolve;\n  });\n\n  // Hide the cursor while the loop runs so the repaint doesn't flicker.\n  safeWrite(output, ANSI_HIDE_CURSOR);\n\n  const tick = async () => {\n    if (stopped || inFlight) return;\n    inFlight = true;\n    // Cursor Low: wrap the entire body in try/finally so a thrown\n    // `renderFrame` (or any other unexpected sync failure after the\n    // gatherConsoleState try/catch) still releases the `inFlight`\n    // latch. Without this guard, a single render-time exception\n    // permanently freezes the loop because every subsequent tick\n    // hits `if (inFlight) return`. Honors the file's design contract\n    // (\"a thrown error in one refresh cycle must NOT crash the loop\").\n    try {\n      let snapshot: ConsoleStateSnapshot | null = null;\n      let renderError: string | null = null;\n      try {\n        snapshot = await gatherConsoleState(orchestrator);\n      } catch (err) {\n        renderError = describeError(err);\n      }\n      if (stopped) return;\n      let frame: string;\n      try {\n        frame = renderFrame({ snapshot, renderError, now });\n      } catch (err) {\n        // If the renderer itself throws (e.g. an invalid clock\n        // injection produced `NaN`), fall back to a minimal error\n        // frame instead of letting the exception escape and reject\n        // the void-floated promise (which would also be unhandled).\n        frame = `remnic console: render failed: ${describeError(err)}\\n`;\n      }\n      safeWrite(output, ANSI_CLEAR_HOME);\n      safeWrite(output, frame);\n      // Codex P2: do NOT await trace writes inside the render tick.\n      // Awaiting holds `inFlight = true` for the duration of the disk\n      // write; on a slow / network-backed filesystem that stretches\n      // the visual refresh interval and skips ticks. Fire-and-forget\n      // preserves the paint cadence; errors are captured via\n      // `getLastError()`.\n      //\n      // Codex P2 (PR #732 follow-up): apply backpressure. If the\n      // previous append is still pending (writeChain not yet\n      // drained), drop this frame instead of queuing another line.\n      // Without this gate, a wedged FS lets the chain grow\n      // unboundedly — one JSON line per tick — until the process\n      // OOMs. Dropping is preferable; the operator can inspect\n      // `getLastError()` to see tracing fell behind.\n      if (snapshot && options.traceRecorder && !traceWritePending) {\n        traceWritePending = true;\n        void options.traceRecorder\n          .append(snapshot)\n          .catch(() => {\n            // already recorded in lastError; defense-in-depth.\n          })\n          .finally(() => {\n            traceWritePending = false;\n          });\n      } else if (snapshot && options.traceRecorder) {\n        traceFramesDropped += 1;\n      }\n    } finally {\n      inFlight = false;\n    }\n  };\n\n  // Kick off an immediate first paint, then schedule the interval.\n  // Codex P1: do NOT call `handle.unref()`. The CLI path keeps the\n  // process alive by `await`-ing `handle.done`, but a pending promise\n  // alone is not enough to keep Node.js running — the interval timer\n  // is the only ref'd handle that holds the event loop open between\n  // ticks. Unref'ing it caused `remnic console` to render once and\n  // exit immediately. Tests that don't want the process held open\n  // can call `handle.stop()` directly when they're done.\n  // Codex P2 (PR #732 round 4): wrap each tick launch so we hold a\n  // reference to the in-flight tick promise. `stop()` awaits this\n  // promise before resolving `done`, ensuring no late\n  // `traceRecorder.append` call races the CLI shutdown path that\n  // closes the recorder once `done` resolves.\n  const launchTick = (): void => {\n    const p = runTickSafely(tick);\n    inFlightTickPromise = p;\n    void p.then(() => {\n      if (inFlightTickPromise === p) {\n        inFlightTickPromise = null;\n      }\n    });\n  };\n  launchTick();\n  const handle = setInterval(launchTick, refreshIntervalMs);\n\n  const sigintHandler = () => {\n    stop();\n  };\n  if (installSigintHandler) {\n    process.on(\"SIGINT\", sigintHandler);\n  }\n\n  const stop = () => {\n    if (stopped) return;\n    stopped = true;\n    clearInterval(handle);\n    if (installSigintHandler) {\n      try {\n        process.removeListener(\"SIGINT\", sigintHandler);\n      } catch {\n        // ignore\n      }\n    }\n    safeWrite(output, ANSI_SHOW_CURSOR);\n    // Codex P2 (PR #732 round 4): wait for any in-flight tick before\n    // resolving `done`. Without this, a Ctrl-C that fires while a\n    // tick is past its `if (stopped) return` check can still execute\n    // `traceRecorder.append(snapshot)` AFTER `done` resolves and the\n    // CLI shutdown path begins closing the recorder, producing a\n    // phantom post-close append. By awaiting the tick body, we\n    // ensure `recorder.append()` has at least been *called*\n    // (synchronously enqueueing the line onto the recorder's\n    // writeChain) before `done` resolves; the recorder's `close()`\n    // then drains that writeChain.\n    //\n    // We do NOT also await the fire-and-forget trace append promise\n    // itself. A wedged disk that stalls the append must not also\n    // stall shutdown — the recorder's `close()` path (bounded by\n    // `flushWithTimeout` in the CLI) is the right place to bound\n    // the disk-drain wait.\n    void (async () => {\n      try {\n        const pendingTick = inFlightTickPromise;\n        if (pendingTick) {\n          await pendingTick;\n        }\n      } finally {\n        resolveDone();\n      }\n    })();\n  };\n\n  return {\n    stop,\n    done,\n    getDroppedTraceFrames: () => traceFramesDropped,\n  };\n}\n\ninterface RenderFrameInput {\n  snapshot: ConsoleStateSnapshot | null;\n  renderError: string | null;\n  now: () => number;\n}\n\n/**\n * Build the full rendered frame as a single string. Pure — exposed\n * for testing.\n */\nexport function renderFrame(input: RenderFrameInput): string {\n  const ts = new Date(input.now()).toISOString();\n  const lines: string[] = [];\n  lines.push(renderHeader(ts));\n  for (const panel of renderPanels(input)) {\n    lines.push(panel);\n  }\n  lines.push(renderFooter());\n  return lines.join(\"\\n\") + \"\\n\";\n}\n\nfunction renderHeader(ts: string): string {\n  // ╔═ remnic console ════════════════════════════════ <ts> ═╗\n  const title = \" remnic console \";\n  const trailing = ` ${ts} `;\n  // 2 corner chars + title + ts + filler. Filler at minimum 1 char.\n  const fillerLen = Math.max(\n    1,\n    FRAME_INNER_WIDTH - title.length - trailing.length,\n  );\n  const filler = \"═\".repeat(fillerLen);\n  return `╔${title}${filler}${trailing}╗`;\n}\n\nfunction renderFooter(): string {\n  return `╚${\"═\".repeat(FRAME_INNER_WIDTH)}╝`;\n}\n\nfunction renderPanels(input: RenderFrameInput): string[] {\n  const lines: string[] = [];\n  const snap = input.snapshot;\n\n  if (input.renderError !== null) {\n    lines.push(panelLine(\"Error\", `refresh failed: ${input.renderError}`));\n    // Even on error we still print the section headers so the layout\n    // stays stable for the operator and tests can locate them.\n    lines.push(panelLine(\"Buffer\", \"(unavailable)\"));\n    lines.push(panelLine(\"Extraction\", \"(unavailable)\"));\n    lines.push(panelLine(\"Dedup\", \"(unavailable)\"));\n    lines.push(panelLine(\"Maintenance\", \"(unavailable)\"));\n    lines.push(panelLine(\"QMD\", \"(unavailable)\"));\n    return lines;\n  }\n\n  // Buffer panel.\n  if (snap) {\n    lines.push(\n      panelLine(\n        \"Buffer\",\n        `turns=${snap.bufferState.turnsCount} bytes=${snap.bufferState.byteCount}`,\n      ),\n    );\n\n    // Extraction panel.\n    const verdicts = snap.extractionQueue.recentVerdicts;\n    const accepts = verdicts.filter((v) => v.kind === \"accept\").length;\n    const rejects = verdicts.filter((v) => v.kind === \"reject\").length;\n    lines.push(\n      panelLine(\n        \"Extraction\",\n        `queue=${snap.extractionQueue.depth}  recent verdicts: accept(${accepts})/reject(${rejects})`,\n      ),\n    );\n\n    // Dedup panel.\n    const dedupSummary = formatDedupSummary(snap.dedupRecent, input.now);\n    lines.push(panelLine(\"Dedup\", dedupSummary));\n\n    // Maintenance panel.\n    const maintSummary = formatMaintenanceTail(snap.maintenanceLedgerTail);\n    lines.push(panelLine(\"Maintenance\", maintSummary));\n\n    // QMD panel.\n    lines.push(panelLine(\"QMD\", formatQmdSummary(snap)));\n  }\n\n  // Surface aggregator-level read errors (e.g. ledger I/O failures)\n  // without crashing the loop. These are not fatal — the snapshot is\n  // still partially usable.\n  if (snap && snap.errors.length > 0) {\n    const head = snap.errors[0];\n    lines.push(panelLine(\"Errors\", head ?? \"\"));\n  }\n\n  return lines;\n}\n\nfunction formatDedupSummary(\n  decisions: ConsoleStateSnapshot[\"dedupRecent\"],\n  now: () => number,\n): string {\n  if (decisions.length === 0) return \"no recent decisions\";\n  const last = decisions[decisions.length - 1];\n  if (!last) return \"no recent decisions\";\n  const ageMs = ageMsFromIso(last.ts, now);\n  const ageStr = ageMs === null ? \"T-?\" : `T-${Math.round(ageMs / 1000)}s`;\n  const fp = last.fingerprint ? `hash=${last.fingerprint}` : \"hash=?\";\n  return `recent: ${fp} decision=${last.decision} (${ageStr})`;\n}\n\nfunction formatMaintenanceTail(\n  events: ConsoleStateSnapshot[\"maintenanceLedgerTail\"],\n): string {\n  if (events.length === 0) return \"no events\";\n  const last = events[events.length - 1];\n  if (!last) return \"no events\";\n  // Show count + most-recent event line.\n  return `n=${events.length}  last: ${last.category} ${truncate(last.summary, 40)}`;\n}\n\nfunction formatQmdSummary(snap: ConsoleStateSnapshot): string {\n  const probe = snap.qmdProbe.available ? \"ok\" : \"down\";\n  const uptimeH = snap.daemon.uptimeMs / 3_600_000;\n  const uptimeStr = uptimeH < 1\n    ? `${Math.round(snap.daemon.uptimeMs / 1000)}s`\n    : `${uptimeH.toFixed(1)}h`;\n  const mode = snap.qmdProbe.daemonMode ? \"daemon\" : \"cli\";\n  return `probe=${probe}  mode=${mode}  uptime=${uptimeStr}`;\n}\n\nfunction panelLine(label: string, value: string): string {\n  // Layout: ║<space><label padded to LABEL_WIDTH><value padded to fill><space>║\n  // Cursor Medium: the closing ║ must be preceded by a trailing space\n  // so the rendered line width matches the header/footer borders.\n  // Without it, every panel line was 71 chars while the borders were\n  // 72, misaligning the right-hand box edge.\n  const LABEL_WIDTH = 13;\n  const labelCol = padRight(label, LABEL_WIDTH);\n  // Two spaces (leading + trailing) inside the box, consuming 2 cols.\n  const remaining = FRAME_INNER_WIDTH - LABEL_WIDTH - 2;\n  const valueCol = padRight(truncate(value, remaining), remaining);\n  return `║ ${labelCol}${valueCol} ║`;\n}\n\nfunction padRight(s: string, width: number): string {\n  if (s.length >= width) return s;\n  return s + \" \".repeat(width - s.length);\n}\n\nfunction truncate(s: string, max: number): string {\n  if (max <= 0) return \"\";\n  if (s.length <= max) return s;\n  if (max <= 1) return s.slice(0, max);\n  return s.slice(0, max - 1) + \"…\";\n}\n\nfunction ageMsFromIso(iso: string, now: () => number): number | null {\n  const ms = Date.parse(iso);\n  if (!Number.isFinite(ms)) return null;\n  const delta = now() - ms;\n  return delta < 0 ? 0 : delta;\n}\n\n/**\n * Run an async tick function and swallow any rejection so the floated\n * `void runTickSafely(tick)` call never produces an unhandled-rejection\n * crash (which Node ≥15 escalates to a process exit). The tick body\n * itself already wraps everything in try/finally, but this is the\n * outermost belt-and-suspenders guard.\n */\nasync function runTickSafely(tick: () => Promise<void>): Promise<void> {\n  try {\n    await tick();\n  } catch {\n    // Any error has already been (or will be) surfaced inside the\n    // rendered frame; never let it escape the timer callback.\n  }\n}\n\nfunction safeWrite(output: Writable, chunk: string): void {\n  try {\n    output.write(chunk);\n  } catch {\n    // Writing to a closed / broken stream is non-fatal for the TUI;\n    // the next tick will retry.\n  }\n}\n\nfunction describeError(err: unknown): string {\n  if (err instanceof Error) return err.message;\n  try {\n    return String(err);\n  } catch {\n    return \"unknown error\";\n  }\n}\n\n/**\n * Strip ANSI escape sequences from a string. Exposed for tests so the\n * rendered frame can be asserted against plain text.\n */\nexport function stripAnsi(s: string): string {\n  // eslint-disable-next-line no-control-regex\n  return s.replace(/\\x1b\\[[0-9;?]*[A-Za-z]/g, \"\");\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-VDX363PS.js → chunk-34F3PLWZ.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-F5VP6YCB.js";
+} from "./chunk-DCE6SQLA.js";
 
 // src/semantic-rule-promotion.ts
 function normalizeRuleWhitespace(value) {
@@ -63,6 +63,13 @@ async function promoteSemanticRuleFromMemory(options) {
     });
     return report;
   }
+  if (sourceMemory.frontmatter.status === "forgotten") {
+    report.skipped.push({
+      sourceMemoryId: options.sourceMemoryId,
+      reason: "source-memory-forgotten"
+    });
+    return report;
+  }
   if (sourceMemory.frontmatter.status === "archived" || sourceMemory.frontmatter.memoryKind !== "episode") {
     report.skipped.push({
       sourceMemoryId: options.sourceMemoryId,
@@ -80,7 +87,7 @@ async function promoteSemanticRuleFromMemory(options) {
   }
   const ruleKey = canonicalizeRuleKey(content);
   const existingRule = (await storage.readAllMemories()).find(
-    (memory) => memory.frontmatter.category === "rule" && memory.frontmatter.status !== "archived" && canonicalizeRuleKey(memory.content) === ruleKey
+    (memory) => memory.frontmatter.category === "rule" && memory.frontmatter.status !== "archived" && memory.frontmatter.status !== "forgotten" && canonicalizeRuleKey(memory.content) === ruleKey
   );
   if (existingRule) {
     report.skipped.push({
@@ -125,4 +132,4 @@ async function promoteSemanticRuleFromMemory(options) {
 export {
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-VDX363PS.js.map
+//# sourceMappingURL=chunk-34F3PLWZ.js.map

package/dist/chunk-34F3PLWZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/semantic-rule-promotion.ts"],"sourcesContent":["import { StorageManager } from \"./storage.js\";\nimport type { MemoryFile, MemoryLink } from \"./types.js\";\n\nexport interface SemanticRulePromotionCandidate {\n  id: string;\n  sourceMemoryId: string;\n  content: string;\n  confidence: number;\n  tags: string[];\n  memoryKind: \"note\";\n  lineage: string[];\n}\n\nexport interface SemanticRulePromotionSkip {\n  sourceMemoryId: string;\n  reason:\n    | \"disabled\"\n    | \"source-memory-missing\"\n    | \"source-memory-forgotten\"\n    | \"source-memory-not-episode\"\n    | \"no-explicit-rule\"\n    | \"duplicate-rule\";\n  existingRuleId?: string;\n}\n\nexport interface SemanticRulePromotionReport {\n  enabled: boolean;\n  dryRun: boolean;\n  promoted: SemanticRulePromotionCandidate[];\n  skipped: SemanticRulePromotionSkip[];\n}\n\nfunction normalizeRuleWhitespace(value: string): string {\n  return value.replace(/\\s+/g, \" \").trim();\n}\n\nfunction stripTrailingClausePunctuation(value: string): string {\n  return value.replace(/[,:;]+$/g, \"\").trim();\n}\n\nfunction canonicalizeRuleContent(value: string): string {\n  return extractExplicitIfThenRule(value) ?? normalizeRuleWhitespace(value);\n}\n\nfunction canonicalizeRuleKey(value: string): string {\n  return canonicalizeRuleContent(value).toLowerCase();\n}\n\nfunction extractExplicitIfThenRule(content: string): string | null {\n  const match = content.match(/\\bif\\b([\\s\\S]+?)\\bthen\\b([\\s\\S]+?)(?:[.!?](?:\\s|$)|$)/i);\n  if (!match) return null;\n  const condition = stripTrailingClausePunctuation(normalizeRuleWhitespace(match[1] ?? \"\"));\n  const outcome = stripTrailingClausePunctuation(normalizeRuleWhitespace(match[2] ?? \"\"));\n  if (condition.length === 0 || outcome.length === 0) return null;\n  return `IF ${condition} THEN ${outcome}.`;\n}\n\nfunction promotionConfidence(memory: MemoryFile): number {\n  const base = Number.isFinite(memory.frontmatter.confidence) ? memory.frontmatter.confidence : 0.8;\n  return Math.max(0.6, Math.min(0.98, base));\n}\n\nfunction promotionTags(memory: MemoryFile): string[] {\n  return Array.from(new Set([...(memory.frontmatter.tags ?? []), \"semantic-rule\", \"promoted-rule\"]));\n}\n\nfunction buildSupportLinks(sourceMemoryId: string, confidence: number): MemoryLink[] {\n  return [\n    {\n      targetId: sourceMemoryId,\n      linkType: \"supports\",\n      strength: confidence,\n      reason: \"Promoted from verified episodic memory\",\n    },\n  ];\n}\n\nexport async function promoteSemanticRuleFromMemory(options: {\n  memoryDir: string;\n  enabled: boolean;\n  sourceMemoryId: string;\n  dryRun?: boolean;\n}): Promise<SemanticRulePromotionReport> {\n  const report: SemanticRulePromotionReport = {\n    enabled: options.enabled,\n    dryRun: options.dryRun === true,\n    promoted: [],\n    skipped: [],\n  };\n  if (!options.enabled) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"disabled\",\n    });\n    return report;\n  }\n\n  const storage = new StorageManager(options.memoryDir);\n  const sourceMemory = await storage.getMemoryById(options.sourceMemoryId);\n  if (!sourceMemory) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"source-memory-missing\",\n    });\n    return report;\n  }\n  if (sourceMemory.frontmatter.status === \"forgotten\") {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"source-memory-forgotten\",\n    });\n    return report;\n  }\n  if (\n    sourceMemory.frontmatter.status === \"archived\" ||\n    sourceMemory.frontmatter.memoryKind !== \"episode\"\n  ) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"source-memory-not-episode\",\n    });\n    return report;\n  }\n\n  const content = extractExplicitIfThenRule(sourceMemory.content);\n  if (!content) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"no-explicit-rule\",\n    });\n    return report;\n  }\n\n  const ruleKey = canonicalizeRuleKey(content);\n  const existingRule = (await storage.readAllMemories()).find(\n    (memory) =>\n      memory.frontmatter.category === \"rule\" &&\n      memory.frontmatter.status !== \"archived\" &&\n      memory.frontmatter.status !== \"forgotten\" &&\n      canonicalizeRuleKey(memory.content) === ruleKey,\n  );\n  if (existingRule) {\n    report.skipped.push({\n      sourceMemoryId: options.sourceMemoryId,\n      reason: \"duplicate-rule\",\n      existingRuleId: existingRule.frontmatter.id,\n    });\n    return report;\n  }\n\n  const confidence = promotionConfidence(sourceMemory);\n  const candidateBase = {\n    sourceMemoryId: options.sourceMemoryId,\n    content,\n    confidence,\n    tags: promotionTags(sourceMemory),\n    memoryKind: \"note\" as const,\n    lineage: [options.sourceMemoryId],\n  };\n\n  if (options.dryRun === true) {\n    report.promoted.push({\n      id: `dry-run:${options.sourceMemoryId}`,\n      ...candidateBase,\n    });\n    return report;\n  }\n\n  const id = await storage.writeMemory(\"rule\", content, {\n    confidence,\n    tags: candidateBase.tags,\n    source: \"semantic-rule-promotion\",\n    lineage: candidateBase.lineage,\n    sourceMemoryId: options.sourceMemoryId,\n    memoryKind: \"note\",\n    links: buildSupportLinks(options.sourceMemoryId, confidence),\n  });\n  report.promoted.push({\n    id,\n    ...candidateBase,\n  });\n  return report;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-3KIS4VGT.js

@@ -0,0 +1,228 @@
+import {
+  createVersion
+} from "./chunk-FAAFWE4G.js";
+import {
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot,
+  fromPosixRelPath,
+  isPathInsideRoot,
+  sha256String
+} from "./chunk-457A4P3L.js";
+import {
+  parseExportBundle
+} from "./chunk-OA3L7BFR.js";
+import {
+  decryptCapsuleFileInMemory,
+  isEncryptedCapsuleFile
+} from "./chunk-KNKUID7G.js";
+
+// src/transfer/capsule-import.ts
+import { lstat, mkdir, readFile, realpath, stat, writeFile } from "fs/promises";
+import path from "path";
+import { createHash, randomUUID } from "crypto";
+import { gunzipSync } from "zlib";
+async function importCapsule(opts) {
+  const archiveAbs = path.resolve(opts.archivePath);
+  const rootAbs = path.resolve(opts.root);
+  await assertIsDirectoryNotSymlink(rootAbs, "importCapsule", "root");
+  const mode = opts.mode ?? "skip";
+  if (mode !== "skip" && mode !== "overwrite" && mode !== "fork") {
+    throw new Error(
+      `importCapsule: unknown mode ${JSON.stringify(mode)}; expected "skip", "overwrite", or "fork"`
+    );
+  }
+  const encrypted = await isEncryptedCapsuleFile(archiveAbs);
+  let raw;
+  if (encrypted) {
+    if (!opts.memoryDir) {
+      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.`
+      );
+    }
+    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir);
+  } else {
+    raw = await readFile(archiveAbs);
+  }
+  const json = gunzipSync(raw).toString("utf-8");
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(json);
+  } catch (cause) {
+    throw new Error(
+      `importCapsule: archive is not valid JSON after gunzip: ${archiveAbs}`,
+      { cause }
+    );
+  }
+  const parsed = parseExportBundle(parsedJson);
+  if (parsed.capsuleVersion !== 2) {
+    throw new Error(
+      "importCapsule: archive is V1; only V2 capsule archives are supported"
+    );
+  }
+  const bundle = parsed.bundle;
+  const manifest = bundle.manifest;
+  const capsule = manifest.capsule;
+  const manifestIndex = /* @__PURE__ */ new Map();
+  for (const f of manifest.files) {
+    manifestIndex.set(f.path, f);
+  }
+  if (manifestIndex.size !== manifest.files.length) {
+    throw new Error(
+      "importCapsule: manifest contains duplicate file paths"
+    );
+  }
+  const recordPaths = /* @__PURE__ */ new Set();
+  for (const rec of bundle.records) {
+    if (recordPaths.has(rec.path)) {
+      throw new Error(
+        `importCapsule: bundle contains duplicate record path: ${rec.path}`
+      );
+    }
+    recordPaths.add(rec.path);
+  }
+  const rootReal = await realpath(rootAbs).catch(() => rootAbs);
+  const seenTargetPaths = /* @__PURE__ */ new Map();
+  for (const rec of bundle.records) {
+    const entry = manifestIndex.get(rec.path);
+    if (!entry) {
+      throw new Error(
+        `importCapsule: archive checksum mismatch (record without manifest entry: ${rec.path})`
+      );
+    }
+    const { sha256, bytes } = sha256String(rec.content);
+    if (sha256 !== entry.sha256 || bytes !== entry.bytes) {
+      throw new Error(
+        `importCapsule: archive checksum mismatch for ${rec.path}: expected sha256=${entry.sha256} bytes=${entry.bytes}, got sha256=${sha256} bytes=${bytes}`
+      );
+    }
+    if (rec.path.includes("\\")) {
+      throw new Error(
+        `importCapsule: record path contains backslash separators (Windows-style paths are not allowed): ${rec.path}`
+      );
+    }
+    const posixNormalized = path.posix.normalize(rec.path);
+    if (rec.path.startsWith("/") || rec.path.split("/").some((seg) => seg === "..") || posixNormalized.startsWith("..") || posixNormalized.startsWith("/")) {
+      throw new Error(
+        `importCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    const targetRel = computeTargetPath(rec.path, mode, capsule.id);
+    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
+    if (!isPathInsideRoot(rootReal, targetAbs)) {
+      throw new Error(
+        `importCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, "importCapsule");
+    const targetLstat = await lstat(targetAbs).catch(() => null);
+    if (targetLstat !== null && targetLstat.isSymbolicLink()) {
+      throw new Error(
+        `importCapsule: record target is a symlink and cannot be written to safely: ${rec.path}`
+      );
+    }
+    const dedupKey = targetAbs.toLowerCase();
+    const firstSourcePath = seenTargetPaths.get(dedupKey);
+    if (firstSourcePath !== void 0) {
+      throw new Error(
+        `importCapsule: manifest contains two entries that resolve to the same target path: "${firstSourcePath}" and "${rec.path}" both map to "${targetRel}"`
+      );
+    }
+    seenTargetPaths.set(dedupKey, rec.path);
+  }
+  for (const f of manifest.files) {
+    if (!recordPaths.has(f.path)) {
+      throw new Error(
+        `importCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`
+      );
+    }
+  }
+  const imported = [];
+  const skipped = [];
+  const sortedRecords = [...bundle.records].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  for (const rec of sortedRecords) {
+    const targetRel = computeTargetPath(rec.path, mode, capsule.id);
+    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
+    const exists = await fileExistsAt(targetAbs);
+    if ((mode === "skip" || mode === "fork") && exists) {
+      skipped.push({ path: rec.path, reason: "exists" });
+      continue;
+    }
+    let snapshotted = false;
+    if (mode === "overwrite" && exists) {
+      if (opts.versioning && opts.versioning.enabled) {
+        const prior = await readFile(targetAbs, "utf-8").catch(() => "");
+        await createVersion(
+          targetAbs,
+          prior,
+          "manual",
+          opts.versioning,
+          opts.log,
+          `capsule-import: ${capsule.id}`,
+          rootReal
+        );
+        snapshotted = true;
+      }
+    }
+    let contentToWrite = rec.content;
+    let rewroteId = false;
+    if (mode === "fork") {
+      const forked = rewriteFrontmatterIdForFork(rec.content, capsule.id, opts.now);
+      contentToWrite = forked.content;
+      rewroteId = forked.rewrote;
+    }
+    await mkdir(path.dirname(targetAbs), { recursive: true });
+    await writeFile(targetAbs, contentToWrite, "utf-8");
+    imported.push({
+      sourcePath: rec.path,
+      targetPath: targetRel,
+      snapshotted,
+      rewroteId
+    });
+  }
+  skipped.sort((a, b) => a.path.localeCompare(b.path));
+  return { imported, skipped, manifest };
+}
+function computeTargetPath(sourcePosix, mode, capsuleId) {
+  if (mode === "fork") return `forks/${capsuleId}/${sourcePosix}`;
+  return sourcePosix;
+}
+async function fileExistsAt(absPath) {
+  const st = await stat(absPath).catch(() => null);
+  return st !== null && st.isFile();
+}
+function rewriteFrontmatterIdForFork(content, capsuleId, now) {
+  const crlfMatch = /^---(\r\n|\r|\n)/.exec(content);
+  const eol = crlfMatch ? crlfMatch[1] : "\n";
+  const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/.exec(content);
+  if (!fmMatch) return { content, rewrote: false };
+  const fmBody = fmMatch[1];
+  const fmTrailer = fmMatch[2];
+  const fmStart = fmMatch.index;
+  const fmEnd = fmStart + fmMatch[0].length;
+  const idLineRe = /^id:[ \t]*([^\r\n]*)$/m;
+  const idMatch = idLineRe.exec(fmBody);
+  if (!idMatch) return { content, rewrote: false };
+  const newId = mintForkId(capsuleId, idMatch[1]?.trim() ?? "", now);
+  const replacedBody = fmBody.replace(idLineRe, `id: ${newId}`);
+  const prefix = content.slice(0, fmStart);
+  const tail = content.slice(fmEnd);
+  const rebuilt = `${prefix}---${eol}${replacedBody}${eol}---${fmTrailer}${tail}`;
+  return { content: rebuilt, rewrote: true };
+}
+function mintForkId(capsuleId, originalId, now) {
+  const base = originalId.length > 0 ? originalId : "fork";
+  if (now === void 0) {
+    const suffix2 = randomUUID().slice(0, 8);
+    return `${base}-fork-${capsuleId}-${suffix2}`;
+  }
+  const payload = JSON.stringify({ c: capsuleId, i: originalId, n: now });
+  const suffix = createHash("sha256").update(payload, "utf-8").digest("hex").slice(0, 8);
+  return `${base}-fork-${capsuleId}-${suffix}`;
+}
+
+export {
+  importCapsule
+};
+//# sourceMappingURL=chunk-3KIS4VGT.js.map