@remnic/core 9.69.12 → 9.69.13

package/dist/{chunk-X4FIZAVQ.js → chunk-7JV4JST3.js}

@@ -101,7 +101,7 @@ import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-GR4C3FHT.js";
+} from "./chunk-ZKZCJRRO.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -134,7 +134,7 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-HFRGCNFY.js";
+} from "./chunk-OAKATRAN.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -197,11 +197,16 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   parseConfig
-} from "./chunk-PGCZLHRB.js";
+} from "./chunk-W272SWN7.js";
+import {
+  expandVaultTemplateTokens,
+  resolveVaultNotePath,
+  validateRegionName
+} from "./chunk-OGUKSLYZ.js";
 import {
   EngramAccessHttpServer,
   MeetingsInputError
-} from "./chunk-DH3V7RCQ.js";
+} from "./chunk-F2ERDKY2.js";
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
@@ -211,10 +216,11 @@ import {
   loadChatSession,
   processChatMessage,
   sessionBelongsToPrincipal
-} from "./chunk-5HO3QBAD.js";
+} from "./chunk-W6GEMUZM.js";
 import {
-  EngramAccessService
-} from "./chunk-5P2KNFJZ.js";
+  EngramAccessService,
+  journalPath
+} from "./chunk-MSDIETFC.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -310,6 +316,10 @@ import {
 import {
   getCausalTrajectoryStoreStatus
 } from "./chunk-P6GKRT2H.js";
+import {
+  activityDateInTimezone,
+  isValidActivityDate
+} from "./chunk-P6FHFTZ7.js";
 import {
   padEndDisplay,
   truncateGraphemeSafe
@@ -379,9 +389,9 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/cli.ts
-import path6 from "path";
+import path8 from "path";
 import { access, lstat as lstat3, readFile as readFile2, readdir as readdir3, realpath as realpath3, unlink } from "fs/promises";
-import { createHash } from "crypto";
+import { createHash as createHash3 } from "crypto";
 
 // src/wearables/registry.ts
 var registrations = /* @__PURE__ */ new Map();
@@ -2058,11 +2068,800 @@ function registerCreationLedgerCommands(cmd, orchestrator) {
   });
 }
 
-// src/maintenance/rebuild-memory-lifecycle-ledger-cli.ts
+// src/activity/timeline/publish-cli.ts
+import { existsSync, readFileSync as readFileSync4 } from "fs";
+
+// src/activity/vault-publisher.ts
+import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { chmodSync, chownSync, lstatSync, mkdirSync, readFileSync as readFileSync3, realpathSync, renameSync as renameSync2, statSync as statSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "fs";
+import path5 from "path";
+
+// src/activity/vault-publish.ts
+import { createHash, randomBytes } from "crypto";
+import { readFileSync as readFileSync2, renameSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync } from "fs";
 import path4 from "path";
+function applyManagedRegion(fileText, opts) {
+  if (opts.strategy === "heading") return applyHeadingRegion(fileText, opts.name, opts.content);
+  const startMarker = `<!-- remnic:${opts.name}:start -->`;
+  const endMarker = `<!-- remnic:${opts.name}:end -->`;
+  const rows = fileLines(fileText);
+  let startRow;
+  let endRow;
+  for (const row of rows) {
+    if (row.fenced) continue;
+    const trimmed = row.line.trim();
+    if (startRow === void 0) {
+      if (trimmed === startMarker) startRow = row;
+    } else if (endRow === void 0 && trimmed === endMarker) {
+      endRow = row;
+      break;
+    }
+  }
+  if (startRow === void 0 || endRow === void 0) {
+    return { ok: false, reason: "no_marker", text: fileText };
+  }
+  const { body, eol } = ownedBody(fileText, opts.content);
+  return {
+    ok: true,
+    text: `${fileText.slice(0, startRow.start + startRow.line.length)}${eol}${body}${eol}${fileText.slice(endRow.start)}`
+  };
+}
+function applyHeadingRegion(fileText, name, content) {
+  const wanted = name.trim();
+  const rows = fileLines(fileText);
+  const hits = [];
+  for (const row of rows) {
+    if (row.fenced) continue;
+    const heading = parseAtxHeading(row.line);
+    if (heading && heading.text === wanted) {
+      hits.push({ line: row.number, level: heading.level, next: row.next });
+    }
+  }
+  if (hits.length === 0) return { ok: false, reason: "no_heading", text: fileText };
+  if (hits.length > 1) {
+    return { ok: false, reason: "duplicate_heading", lines: hits.map((hit2) => hit2.line), text: fileText };
+  }
+  const hit = hits[0];
+  let sectionEnd = fileText.length;
+  for (const row of rows) {
+    if (row.start < hit.next || row.fenced) continue;
+    const heading = parseAtxHeading(row.line);
+    if (heading && heading.level <= hit.level) {
+      sectionEnd = row.start;
+      break;
+    }
+  }
+  const { body, eol } = ownedBody(fileText, demoteOwnedHeadings(content, hit.level));
+  const prefix = hit.next === fileText.length && !fileText.endsWith("\n") && !fileText.endsWith("\r") ? `${fileText}${eol}` : fileText.slice(0, hit.next);
+  return { ok: true, text: `${prefix}${body}${eol}${fileText.slice(sectionEnd)}` };
+}
+function demoteOwnedHeadings(content, owningLevel) {
+  const rows = fileLines(content);
+  let out = "";
+  let cursor = 0;
+  for (const row of rows) {
+    const heading = row.fenced ? null : parseAtxHeading(row.line);
+    if (heading === null) continue;
+    const level = Math.min(owningLevel + heading.level, 6);
+    const replacement = level > owningLevel ? `${"#".repeat(level)} ${heading.text}` : `**${heading.text}**`;
+    out += content.slice(cursor, row.start) + replacement;
+    cursor = row.start + row.line.length;
+  }
+  return out + content.slice(cursor);
+}
+function ownedBody(fileText, content) {
+  const eol = fileText.includes("\r\n") ? "\r\n" : "\n";
+  let body = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\r\n") body = body.replace(/\n/g, "\r\n");
+  if (body.endsWith(eol)) body = body.slice(0, -eol.length);
+  return { body, eol };
+}
+function fileLines(fileText) {
+  const rows = [];
+  let start = 0;
+  let number = 1;
+  let fence = null;
+  while (start < fileText.length) {
+    let i = start;
+    while (i < fileText.length && fileText[i] !== "\n" && fileText[i] !== "\r") i++;
+    let next = i;
+    if (fileText[i] === "\r" && fileText[i + 1] === "\n") next = i + 2;
+    else if (fileText[i] === "\n" || fileText[i] === "\r") next = i + 1;
+    else next = fileText.length;
+    const line = fileText.slice(start, i);
+    const indentedCode = indentColumn(line) >= 4;
+    const run = indentedCode ? null : fenceRun(line);
+    let fenced;
+    if (fence === null) {
+      if (run !== null && !(run.char === "`" && run.info.includes("`"))) {
+        fence = { char: run.char, len: run.len };
+      }
+      fenced = fence !== null || indentedCode;
+    } else {
+      fenced = true;
+      if (run !== null && run.char === fence.char && run.len >= fence.len && run.info.length === 0) {
+        fence = null;
+      }
+    }
+    rows.push({ line, start, next, number, fenced });
+    number += 1;
+    start = next;
+  }
+  return rows;
+}
+function indentColumn(line) {
+  let col = 0;
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i];
+    if (ch === " ") col += 1;
+    else if (ch === "	") col += 4 - col % 4;
+    else break;
+  }
+  return col;
+}
+function fenceRun(line) {
+  const body = line.trimStart();
+  const char = body[0];
+  if (char !== "`" && char !== "~") return null;
+  let len = 0;
+  while (len < body.length && body[len] === char) len++;
+  if (len < 3) return null;
+  return { char, len, info: body.slice(len).trim() };
+}
+function parseAtxHeading(line) {
+  let at = 0;
+  let indent = 0;
+  while (at < line.length && (line[at] === " " || line[at] === "	")) {
+    indent += line[at] === " " ? 1 : 4 - indent % 4;
+    if (indent >= 4) return null;
+    at += 1;
+  }
+  let level = 0;
+  while (level < 6 && line[at + level] === "#") level++;
+  if (level === 0) return null;
+  const after = line[at + level];
+  if (after !== " " && after !== "	") return null;
+  let start = at + level + 1;
+  let end = line.length;
+  while (start < end && (line[start] === " " || line[start] === "	")) start++;
+  while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
+  let hashEnd = end;
+  while (hashEnd > start && line[hashEnd - 1] === "#") hashEnd--;
+  if (hashEnd < end && hashEnd > start && (line[hashEnd - 1] === " " || line[end - 1] === "	")) {
+    end = hashEnd;
+    while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
+  }
+  return { level, text: line.slice(start, end) };
+}
+function publishVaultRegion(input) {
+  const vault = expandTildePath(input.vaultPath);
+  try {
+    if (!statSync2(vault).isDirectory()) return { ok: false, reason: "not_directory" };
+  } catch {
+    return { ok: false, reason: "not_directory" };
+  }
+  if (input.relativeFile.length === 0 || path4.isAbsolute(input.relativeFile)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  const root = path4.resolve(vault);
+  const dest = path4.resolve(root, input.relativeFile);
+  const rel = path4.relative(root, dest);
+  if (rel.length === 0 || rel.startsWith("..") || path4.isAbsolute(rel)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  let existing;
+  try {
+    if (!statSync2(dest).isFile()) return { ok: false, reason: "missing_file" };
+    existing = readFileSync2(dest, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { ok: false, reason: "missing_file" };
+    throw err;
+  }
+  const applied = applyManagedRegion(existing, {
+    strategy: "markers",
+    name: input.name,
+    content: input.content
+  });
+  if (!applied.ok) return { ok: false, reason: "no_marker" };
+  const prevHash = createHash("sha256").update(existing, "utf8").digest("hex");
+  const nextHash = createHash("sha256").update(applied.text, "utf8").digest("hex");
+  if (prevHash === nextHash) return { ok: true, status: "unchanged" };
+  const tmpPath = path4.join(path4.dirname(dest), `.remnic-vault-${randomBytes(8).toString("hex")}.tmp`);
+  writeFileSync(tmpPath, applied.text);
+  try {
+    renameSync(tmpPath, dest);
+  } catch (renameErr) {
+    try {
+      unlinkSync2(tmpPath);
+    } catch {
+    }
+    throw renameErr;
+  }
+  return { ok: true, status: "updated" };
+}
+
+// src/activity/vault-insert.ts
+function insertMarkersUnderHeading(fileText, opts) {
+  if (typeof opts.heading !== "string" || opts.heading.length === 0) {
+    throw new RangeError("Heading must be non-empty.");
+  }
+  if (typeof opts.name !== "string" || opts.name.length === 0) {
+    throw new RangeError("Region name must be non-empty.");
+  }
+  const startMarker = `<!-- remnic:${opts.name}:start -->`;
+  const endMarker = `<!-- remnic:${opts.name}:end -->`;
+  const rows = fileLines(fileText);
+  const present = rows.some((row) => !row.fenced && row.line.includes(startMarker)) && rows.some((row) => !row.fenced && row.line.includes(endMarker));
+  if (present) return { ok: true, text: fileText, inserted: false };
+  const hits = [];
+  for (const row of rows) {
+    if (row.fenced) continue;
+    const heading = parseAtxHeading(row.line);
+    if (heading && heading.text === opts.heading) {
+      hits.push({ row, level: heading.level });
+    }
+  }
+  if (hits.length === 0) return { ok: false, reason: "no_heading", text: fileText };
+  if (hits.length > 1) {
+    return { ok: false, reason: "duplicate_heading", lines: hits.map((hit2) => hit2.row.number), text: fileText };
+  }
+  const hit = hits[0];
+  const eol = fileText.includes("\r\n") ? "\r\n" : "\n";
+  const prefix = hit.row.next === fileText.length && !fileText.endsWith("\n") && !fileText.endsWith("\r") ? `${fileText}${eol}` : fileText.slice(0, hit.row.next);
+  let content = opts.content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\r\n") content = content.replace(/\n/g, "\r\n");
+  if (content.length > 0 && !content.endsWith(eol)) content += eol;
+  const text = `${prefix}${startMarker}${eol}${content}${endMarker}${eol}${fileText.slice(hit.row.next)}`;
+  return { ok: true, text, inserted: true };
+}
+
+// src/activity/vault-region-pair.ts
+function assertBeginEndPair({ beginName, endName }) {
+  const begin = beginName.trim();
+  const end = endName.trim();
+  if (begin.length === 0 || end.length === 0) {
+    throw new RangeError("Region name must be non-empty.");
+  }
+  if (begin !== end) {
+    return { ok: false, error: "name_mismatch" };
+  }
+  return { ok: true };
+}
+
+// src/activity/vault-status.ts
+var VAULT_PUBLISH_OUTCOMES = ["updated", "unchanged", "skipped", "error"];
+function compareEntries(a, b) {
+  if (a.path !== b.path) return a.path < b.path ? -1 : 1;
+  const rankA = VAULT_PUBLISH_OUTCOMES.indexOf(a.outcome);
+  const rankB = VAULT_PUBLISH_OUTCOMES.indexOf(b.outcome);
+  if (rankA !== rankB) return rankA < rankB ? -1 : 1;
+  const reasonA = a.reason ?? "";
+  const reasonB = b.reason ?? "";
+  if (reasonA !== reasonB) return reasonA < reasonB ? -1 : 1;
+  return 0;
+}
+function summarizeVaultPublish(results) {
+  if (!Array.isArray(results)) {
+    throw new TypeError(`summarizeVaultPublish expects an array of results (got ${typeof results})`);
+  }
+  const entries = [];
+  for (const entry of results) {
+    if (typeof entry !== "object" || entry === null) {
+      throw new TypeError(`vault publish result entries must be objects (got ${typeof entry})`);
+    }
+    if (typeof entry.path !== "string" || entry.path.trim() === "") {
+      throw new RangeError(`vault publish result requires a non-blank path (got ${JSON.stringify(entry.path)})`);
+    }
+    const outcome = VAULT_PUBLISH_OUTCOMES.find((candidate) => candidate === entry.outcome);
+    if (outcome === void 0) {
+      throw new TypeError(
+        `unknown vault publish outcome ${JSON.stringify(entry.outcome)}; expected one of: ${VAULT_PUBLISH_OUTCOMES.join(", ")}`
+      );
+    }
+    if (outcome === "skipped" || outcome === "error") {
+      if (typeof entry.reason !== "string" || entry.reason.trim() === "") {
+        throw new TypeError(
+          `vault publish outcome "${outcome}" requires a non-blank reason, e.g. "no_marker" (got ${JSON.stringify(entry.reason)})`
+        );
+      }
+      entries.push({ path: entry.path, outcome, reason: entry.reason });
+    } else {
+      if (entry.reason !== void 0) {
+        throw new TypeError(
+          `vault publish outcome "${outcome}" must not carry a reason (got ${JSON.stringify(entry.reason)})`
+        );
+      }
+      entries.push({ path: entry.path, outcome });
+    }
+  }
+  const sorted = [...entries].sort(compareEntries);
+  const counts = {};
+  for (const outcome of VAULT_PUBLISH_OUTCOMES) counts[outcome] = 0;
+  for (const entry of sorted) counts[entry.outcome] += 1;
+  return {
+    results: sorted,
+    counts,
+    hasError: counts.error > 0
+  };
+}
+
+// src/activity/vault-publisher.ts
+var START_MARKER_RE = /^<!--\s{0,8}remnic:(.+):start\s{0,8}-->$/;
+var END_MARKER_RE = /^<!--\s{0,8}remnic:(.+):end\s{0,8}-->$/;
+function publishVaultNote(input) {
+  if (typeof input !== "object" || input === null) {
+    throw new TypeError("publishVaultNote requires an input object.");
+  }
+  if (!Array.isArray(input.sections) || input.sections.length === 0) {
+    throw new RangeError("publishVaultNote requires at least one section.");
+  }
+  const strategy = input.strategy ?? "markers";
+  const propertiesMode = input.propertiesMode ?? "off";
+  const prefix = input.propertiesPrefix ?? "remnic_";
+  if (typeof prefix !== "string" || prefix.length === 0) {
+    throw new RangeError("propertiesPrefix must be a non-empty string.");
+  }
+  for (const section of input.sections) {
+    const name = validateRegionName(section.name);
+    if (!name.ok) {
+      throw new RangeError(`Section name ${JSON.stringify(section.name)} is not a valid region name.`);
+    }
+  }
+  const relative = resolveVaultNotePath(input.notePathTemplate, input.date);
+  const result = publishRelative(input, relative, { strategy, propertiesMode, prefix });
+  return summarizeVaultPublish(result);
+}
+function publishRelative(input, relative, opts) {
+  const vault = expandTildePath(input.vaultPath);
+  try {
+    const rootStat = lstatSync(vault);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) return refuse(relative, "error", "not_directory");
+  } catch {
+    return refuse(relative, "error", "not_directory");
+  }
+  const root = path5.resolve(vault);
+  const dest = path5.resolve(root, relative);
+  const lexical = path5.relative(root, dest);
+  if (lexical.length === 0 || lexical === ".." || lexical.startsWith(`..${path5.sep}`) || path5.isAbsolute(lexical)) {
+    return refuse(relative, "error", "path_escape");
+  }
+  if (!containedBySymlinks(root, dest)) {
+    return refuse(relative, "error", "symlink_escape");
+  }
+  let currentText = null;
+  let expected = null;
+  try {
+    if (lstatSync(dest).isSymbolicLink()) {
+      return refuse(relative, "error", "symlinked_note");
+    }
+    const st = statSync3(dest);
+    if (st.isFile()) {
+      currentText = readFileSync3(dest, "utf8");
+      expected = {
+        ino: st.ino,
+        mtimeMs: st.mtimeMs,
+        size: st.size,
+        sha256: createHash2("sha256").update(currentText, "utf8").digest("hex")
+      };
+    } else return refuse(relative, "error", "not_a_file");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  let created = false;
+  if (currentText === null) {
+    if (input.createMissingNotes === true && typeof input.noteTemplate === "string" && input.noteTemplate.length > 0) {
+      const templatePath = path5.resolve(root, input.noteTemplate);
+      const templateRel = path5.relative(root, templatePath);
+      if (templateRel === ".." || templateRel.startsWith(`..${path5.sep}`) || path5.isAbsolute(templateRel) || templateRel.length === 0 || !containedBySymlinks(root, templatePath)) {
+        return refuse(relative, "error", "template_escape");
+      }
+      try {
+        const templateText = readFileSync3(templatePath, "utf8");
+        currentText = expandVaultTemplateTokens(templateText, input.date);
+        if (!currentText.endsWith("\n")) currentText += "\n";
+        created = true;
+      } catch {
+        return refuse(relative, "error", "template_unreadable");
+      }
+    } else {
+      return refuse(relative, "skipped", "missing_file");
+    }
+  }
+  const original = currentText;
+  let text = original;
+  const failures = [];
+  const appliedSections = [];
+  for (const section of input.sections) {
+    const prefixed = opts.propertiesMode === "off" || !section.properties ? void 0 : Object.fromEntries(
+      Object.entries(section.properties).map(([key, value]) => [`${opts.prefix}${key}`, value])
+    );
+    const content = decorate(section, prefixed, opts.propertiesMode);
+    const step = applySection(text, section, content, opts.strategy, input.insertUnderHeading, created);
+    if (step.ok) {
+      text = step.text;
+      appliedSections.push(section);
+    } else {
+      failures.push({ outcome: step.outcome, reason: step.reason });
+    }
+  }
+  if (failures.length > 0 && appliedSections.length === 0) {
+    const worst = failures.find((f) => f.outcome === "error") ?? failures[0];
+    return [{ path: relative, outcome: worst.outcome, reason: failures.map((f) => f.reason).join("; ") }];
+  }
+  if (failures.some((f) => f.outcome === "error")) {
+    return [{ path: relative, outcome: "error", reason: failures.map((f) => f.reason).join("; ") }];
+  }
+  const skippedReason = failures.length > 0 ? failures.map((f) => f.reason).join("; ") : void 0;
+  const withSkipped = (rows) => skippedReason === void 0 ? rows : [...rows, { path: relative, outcome: "skipped", reason: skippedReason }];
+  if (opts.propertiesMode === "frontmatter") {
+    const updates = frontmatterUpdates(appliedSections, opts.prefix);
+    if (Object.keys(updates).length > 0) {
+      const merged = mergeFrontmatterKeys(text, updates);
+      if (!merged.ok) {
+        return [{ path: relative, outcome: "error", reason: merged.reason }];
+      }
+      text = merged.text;
+    }
+  }
+  const prevHash = createHash2("sha256").update(original, "utf8").digest("hex");
+  const nextHash = createHash2("sha256").update(text, "utf8").digest("hex");
+  if (prevHash === nextHash) {
+    return withSkipped([{ path: relative, outcome: "unchanged" }]);
+  }
+  if (input.dryRun === true) {
+    return withSkipped([{ path: relative, outcome: "updated" }]);
+  }
+  if (created) {
+    try {
+      mkdirSync(path5.dirname(dest), { recursive: true });
+    } catch {
+      return refuse(relative, "error", "mkdir_failed");
+    }
+  }
+  const write = writeAtomic(dest, text, expected);
+  if (write === "concurrent") {
+    return [{ path: relative, outcome: "error", reason: "concurrent_write" }];
+  }
+  if (write !== "written") {
+    return [{ path: relative, outcome: "error", reason: "rename_failed" }];
+  }
+  return withSkipped([{ path: relative, outcome: "updated" }]);
+}
+function refuse(relative, outcome, reason) {
+  return [{ path: relative, outcome, reason }];
+}
+function decorate(section, prefixed, mode) {
+  const parts = [section.content];
+  if (prefixed !== void 0 && mode === "dataview-inline") {
+    for (const [key, value] of Object.entries(prefixed)) {
+      parts.push(`${key}:: ${value}`);
+    }
+  }
+  if (section.provenance !== void 0) {
+    parts.push(
+      `*(generated by Remnic timeline \xB7 ${section.provenance.generatorVersion} \xB7 ${section.provenance.generatedAt})*`
+    );
+  }
+  return parts.join("\n");
+}
+function applySection(text, section, content, strategy, insertUnderHeading, freshNote) {
+  if (strategy === "markers") {
+    const mismatch = findMarkerMismatch(text);
+    if (mismatch !== null) {
+      return { ok: false, outcome: "skipped", reason: mismatch };
+    }
+    const applied2 = applyManagedRegion(text, { strategy: "markers", name: section.name, content });
+    if (applied2.ok) return { ok: true, text: applied2.text };
+    if (typeof insertUnderHeading === "string" && insertUnderHeading.length > 0) {
+      const inserted = insertMarkersUnderHeading(text, {
+        heading: insertUnderHeading,
+        name: section.name,
+        content
+      });
+      if (inserted.ok) return { ok: true, text: inserted.text };
+      if (inserted.reason === "duplicate_heading") {
+        return {
+          ok: false,
+          outcome: "error",
+          reason: `duplicate_heading:${inserted.lines.join(",")}`
+        };
+      }
+      return { ok: false, outcome: "skipped", reason: "no_marker" };
+    }
+    if (freshNote) {
+      const suffix = `${text.endsWith("\n") ? "" : "\n"}<!-- remnic:${section.name}:start -->
+${content}
+<!-- remnic:${section.name}:end -->
+`;
+      return { ok: true, text: text + suffix };
+    }
+    return { ok: false, outcome: "skipped", reason: "no_marker" };
+  }
+  const applied = applyManagedRegion(text, { strategy: "heading", name: section.name, content });
+  if (applied.ok) return { ok: true, text: applied.text };
+  if (applied.reason === "duplicate_heading") {
+    return { ok: false, outcome: "error", reason: `duplicate_heading:${applied.lines.join(",")}` };
+  }
+  return { ok: false, outcome: "skipped", reason: "no_heading" };
+}
+function findMarkerMismatch(text) {
+  let begin = null;
+  for (const row of fileLines(text)) {
+    if (row.fenced) continue;
+    const trimmed = row.line.trim();
+    const start = START_MARKER_RE.exec(trimmed);
+    if (start) {
+      const name = start[1];
+      if (begin !== null) return `nested_start:${begin}:${name}`;
+      begin = name;
+      continue;
+    }
+    const match = END_MARKER_RE.exec(trimmed);
+    if (!match) {
+      if (looksLikeRemnicMarkerLine(trimmed)) return `unparsable_marker:${trimmed}`;
+      continue;
+    }
+    const end = match[1];
+    if (begin === null) return `orphan_end:${end}`;
+    if (begin.trim().length === 0 || end.trim().length === 0) return `name_mismatch:${begin}:${end}`;
+    if (!assertBeginEndPair({ beginName: begin, endName: end }).ok) return `name_mismatch:${begin}:${end}`;
+    begin = null;
+  }
+  return null;
+}
+function looksLikeRemnicMarkerLine(trimmed) {
+  if (!trimmed.startsWith("<!--") || !trimmed.endsWith("-->")) return false;
+  const inner = trimmed.slice(4, -3).trim();
+  if (!inner.startsWith("remnic:")) return false;
+  return inner.endsWith(":start") || inner.endsWith(":end");
+}
+function frontmatterUpdates(sections, prefix) {
+  const updates = {};
+  for (const section of sections) {
+    if (!section.properties) continue;
+    for (const [key, value] of Object.entries(section.properties)) {
+      updates[`${prefix}${key}`] = value;
+    }
+  }
+  return updates;
+}
+function mergeFrontmatterKeys(noteText, updates) {
+  const entries = Object.entries(updates);
+  if (entries.length === 0) return { ok: true, text: noteText };
+  for (const [key] of entries) {
+    if (key.includes("\n") || key.includes("\r") || key.trim() !== key || key.length === 0) {
+      return { ok: false, reason: "invalid_property_key" };
+    }
+  }
+  const eol = noteText.includes("\r\n") ? "\r\n" : "\n";
+  const openRe = /^---\r?$/;
+  const firstLineEnd = noteText.indexOf("\n");
+  const firstLine = firstLineEnd === -1 ? noteText : noteText.slice(0, firstLineEnd);
+  if (!openRe.test(firstLine)) {
+    const block = ["---", ...entries.map(([key, value]) => `${key}: ${value}`), "---", ""].join(eol);
+    return { ok: true, text: block + eol + noteText };
+  }
+  const lines = noteText.split(eol);
+  let closeIdx = -1;
+  for (let i = 1; i < lines.length; i += 1) {
+    if (openRe.test(lines[i])) {
+      closeIdx = i;
+      break;
+    }
+  }
+  if (closeIdx === -1) {
+    return { ok: false, reason: "malformed_frontmatter" };
+  }
+  const pending = new Map(entries);
+  for (let i = 1; i < closeIdx; i += 1) {
+    const line = lines[i];
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const rawKey = line.slice(0, idx);
+    if (rawKey !== rawKey.trimStart()) continue;
+    const key = rawKey.trimEnd();
+    if (!pending.has(key)) continue;
+    lines[i] = `${rawKey}: ${pending.get(key)}`;
+    pending.delete(key);
+  }
+  const insertAt = closeIdx;
+  const added = [];
+  for (const [key, value] of pending.entries()) {
+    added.push(`${key}: ${value}`);
+  }
+  lines.splice(insertAt, 0, ...added);
+  return { ok: true, text: lines.join(eol) };
+}
+function containedBySymlinks(root, dest) {
+  const realRoot = realpathSync(root);
+  let probe = dest;
+  for (; ; ) {
+    try {
+      if (lstatSync(probe).isSymbolicLink() || statSync3(probe).isFile() || statSync3(probe).isDirectory()) {
+        const real = realpathSync(probe);
+        return real === realRoot || real.startsWith(`${realRoot}${path5.sep}`);
+      }
+    } catch {
+    }
+    const parent = path5.dirname(probe);
+    if (parent === probe) return false;
+    probe = parent;
+  }
+}
+var vaultPublisherTestHooks = null;
+function setVaultPublisherTestHooks(hooks) {
+  vaultPublisherTestHooks = hooks;
+}
+function writeAtomic(dest, text, expect) {
+  const tmpPath = path5.join(path5.dirname(dest), `.remnic-vault-${randomBytes2(8).toString("hex")}.tmp`);
+  writeFileSync2(tmpPath, text);
+  let prev = null;
+  try {
+    prev = statSync3(dest);
+  } catch {
+    prev = null;
+  }
+  if (prev !== null) {
+    try {
+      chmodSync(tmpPath, prev.mode & 4095);
+      chownSync(tmpPath, prev.uid, prev.gid);
+    } catch {
+    }
+  }
+  vaultPublisherTestHooks?.beforeReplaceVerify?.(dest);
+  try {
+    const concurrent = expect === null ? prev !== null : prev === null || // the note vanished since it was read
+    prev.ino !== expect.ino || prev.mtimeMs !== expect.mtimeMs || prev.size !== expect.size || createHash2("sha256").update(readFileSync3(dest, "utf8"), "utf8").digest("hex") !== expect.sha256;
+    if (concurrent) {
+      try {
+        unlinkSync3(tmpPath);
+      } catch {
+      }
+      return "concurrent";
+    }
+  } catch {
+    try {
+      unlinkSync3(tmpPath);
+    } catch {
+    }
+    return "concurrent";
+  }
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      renameSync2(tmpPath, dest);
+      return "written";
+    } catch (err) {
+      const code = err.code;
+      if (attempt === 1 || code !== "EBUSY" && code !== "EPERM") {
+        try {
+          unlinkSync3(tmpPath);
+        } catch {
+        }
+        if (code === "EBUSY" || code === "EPERM") return "failed";
+        throw err;
+      }
+    }
+  }
+  return "failed";
+}
+
+// src/activity/timeline/publish-cli.ts
+var AVAILABLE_KINDS = ["timeline"];
+var KNOWN_KINDS = ["timeline", "standup", "weekly", "locations"];
+var UNLANDED_REASONS = {
+  standup: "the standup renderer lands with timeline phase 3",
+  weekly: "the weekly review renderer lands with timeline phase 4",
+  locations: "the location day renderer is not wired to publishing yet"
+};
+function runTimelinePublishCli(config, options, io) {
+  const vault = config.activity?.timeline?.vault;
+  if (options.week !== void 0) {
+    io.stderr.write("--week is not available yet: the weekly review renderer lands with timeline phase 4.\n");
+    return 1;
+  }
+  if (!vault || vault.enabled !== true) {
+    io.stderr.write(
+      "Vault publishing is disabled: set activity.timeline.vault.enabled=true and configure vaultPath first.\n"
+    );
+    return 1;
+  }
+  const date = typeof options.date === "string" && options.date.length > 0 ? options.date : activityDateInTimezone(/* @__PURE__ */ new Date(), config.activity?.timezone ?? "UTC");
+  if (!isValidActivityDate(date)) {
+    io.stderr.write(`Invalid --date "${date}"; expected YYYY-MM-DD.
+`);
+    return 1;
+  }
+  const requested = parseKinds(typeof options.what === "string" && options.what.length > 0 ? options.what : "timeline");
+  if (typeof requested !== "string") {
+    io.stderr.write(requested.error);
+    return 1;
+  }
+  const kinds = requested.split(",");
+  const sections = [];
+  let notePathTemplate = vault.dailyNotePath;
+  for (const kind of kinds) {
+    if (AVAILABLE_KINDS.indexOf(kind) === -1) {
+      io.stderr.write(`--what ${kind} is not available yet: ${UNLANDED_REASONS[kind] ?? "unknown kind"}.
+`);
+      return 1;
+    }
+    const target = vault.publish[kind];
+    if (target.enabled !== true) {
+      io.stderr.write(`--what ${kind} is disabled: enable activity.timeline.vault.publish.${kind}.enabled.
+`);
+      return 1;
+    }
+    notePathTemplate = target.target === "weekly" ? vault.weeklyNotePath : vault.dailyNotePath;
+    const source = journalPath(config.memoryDir, date);
+    if (!existsSync(source)) {
+      io.stderr.write(
+        `No timeline artifact for ${date}: run the journal recap generation first (${kind} target reads the persisted day recap).
+`
+      );
+      return 1;
+    }
+    sections.push({ name: target.section, content: readFileSync4(source, "utf8").trimEnd() });
+  }
+  const status = publishVaultNote({
+    vaultPath: vault.vaultPath,
+    notePathTemplate,
+    date,
+    sections,
+    strategy: vault.sectionStrategy,
+    insertUnderHeading: vault.insertUnderHeading.length > 0 ? vault.insertUnderHeading : void 0,
+    createMissingNotes: vault.createMissingNotes,
+    noteTemplate: vault.noteTemplate.length > 0 ? vault.noteTemplate : void 0,
+    propertiesMode: vault.properties.mode,
+    propertiesPrefix: vault.properties.prefix,
+    dryRun: options.dryRun === true
+  });
+  for (const row of status.results) {
+    const label = row.outcome === "updated" && options.dryRun === true ? "would update" : row.outcome;
+    io.stdout.write(`${label}  ${row.path}${row.reason ? `  (${row.reason})` : ""}
+`);
+  }
+  io.stdout.write(
+    `updated=${status.counts.updated} unchanged=${status.counts.unchanged} skipped=${status.counts.skipped} error=${status.counts.error}
+`
+  );
+  return status.hasError ? 1 : 0;
+}
+function parseKinds(raw) {
+  const kinds = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  for (const kind of kinds) {
+    if (KNOWN_KINDS.indexOf(kind) === -1) {
+      return { error: `Unknown --what kind "${kind}"; valid kinds are ${KNOWN_KINDS.join(", ")}.
+` };
+    }
+  }
+  if (new Set(kinds).size !== kinds.length) {
+    return { error: "--what must not repeat a kind.\n" };
+  }
+  if (kinds.length === 0) {
+    return { error: `--what must name at least one artifact; valid kinds are ${KNOWN_KINDS.join(", ")}.
+` };
+  }
+  return kinds.join(",");
+}
+
+// src/cli/timeline-publish-commands.ts
+function registerTimelineCommands(cmd, orchestrator) {
+  const timelineCmd = cmd.command("timeline").description("Timeline artifacts: publish the day's recap into a markdown vault (issue #1985)");
+  timelineCmd.command("publish").description("Publish timeline artifacts into the vault daily note via managed regions").option("--date <date>", "Local day to publish (YYYY-MM-DD; defaults to today)").option("--week <week>", "ISO week to publish (YYYY-Www)").option("--what <kinds>", "Comma-separated artifacts to publish (default: timeline)").option("--dry-run", "Report per-file outcomes without writing").action((...args) => {
+    const options = args[0] ?? {};
+    const code = runTimelinePublishCli(orchestrator.config, options, {
+      stdout: process.stdout,
+      stderr: process.stderr
+    });
+    if (code !== 0) process.exitCode = code;
+  });
+}
+
+// src/maintenance/rebuild-memory-lifecycle-ledger-cli.ts
+import path6 from "path";
 async function runRebuildMemoryLifecycleLedgerCliCommand(options) {
   const storage = options.storage;
-  const ledgerPath = path4.join(options.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+  const ledgerPath = path6.join(options.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
   const encrypted = await probeEncryptedRegularFileHeader(ledgerPath);
   if (encrypted && !(storage?.isSecureStoreUnlocked() ?? false)) {
     throw new Error(
@@ -2560,7 +3359,7 @@ assistant> ${result.reply}
 // src/training-export/converter.ts
 import { constants } from "fs";
 import { lstat as lstat2, open, readdir as readdir2, realpath as realpath2 } from "fs/promises";
-import path5 from "path";
+import path7 from "path";
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
   if (!match) return null;
@@ -2600,7 +3399,7 @@ async function safeRealpath(p) {
   }
 }
 function isContainedPath(real, containmentRoot) {
-  return real === containmentRoot || real.startsWith(containmentRoot + path5.sep);
+  return real === containmentRoot || real.startsWith(containmentRoot + path7.sep);
 }
 async function collectMarkdownFiles(dir, containmentRoot) {
   const files = [];
@@ -2620,7 +3419,7 @@ async function collectMarkdownFiles(dir, containmentRoot) {
     }
     const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of sorted) {
-      const full = path5.join(d, entry.name);
+      const full = path7.join(d, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
         await walk(full);
@@ -2702,9 +3501,9 @@ async function convertMemoriesToRecords(options) {
   const { memoryDir } = options;
   const containmentRoot = await safeRealpath(memoryDir);
   if (!containmentRoot) return [];
-  const dirs = RECALL_FALLBACK_DIRS.map((dir) => path5.join(memoryDir, dir));
+  const dirs = RECALL_FALLBACK_DIRS.map((dir) => path7.join(memoryDir, dir));
   if (options.includeEntities) {
-    dirs.push(path5.join(memoryDir, "entities"));
+    dirs.push(path7.join(memoryDir, "entities"));
   }
   const allFiles = [];
   for (const dir of dirs) {
@@ -2967,14 +3766,14 @@ async function runTrainingExportCliCommand(opts) {
       `Unknown training-export format "${opts.format}". ${validList}`
     );
   }
-  const { statSync: statSync2, existsSync } = await import("fs");
-  if (!existsSync(expandedMemoryDir)) {
+  const { statSync: statSync4, existsSync: existsSync2 } = await import("fs");
+  if (!existsSync2(expandedMemoryDir)) {
     throw new Error(
       `--memory-dir "${opts.memoryDir}" does not exist. Provide the path to an existing memory directory.`
     );
   }
   try {
-    if (!statSync2(expandedMemoryDir).isDirectory()) {
+    if (!statSync4(expandedMemoryDir).isDirectory()) {
       throw new Error(
         `--memory-dir "${opts.memoryDir}" is not a directory. Provide the path to a memory directory, not a file.`
       );
@@ -3022,9 +3821,9 @@ async function runTrainingExportCliCommand(opts) {
   const formatted = adapter.formatRecords(records);
   const { writeFile: fsWriteFile } = await import("fs/promises");
   const { dirname } = await import("path");
-  const { mkdirSync } = await import("fs");
+  const { mkdirSync: mkdirSync2 } = await import("fs");
   try {
-    mkdirSync(dirname(expandedOutput), { recursive: true });
+    mkdirSync2(dirname(expandedOutput), { recursive: true });
   } catch {
   }
   await fsWriteFile(expandedOutput, formatted, "utf-8");
@@ -3709,10 +4508,10 @@ function effectivePolicyValuesForVersion(values, config) {
 }
 function policyVersionForValues(values, config) {
   const normalized = effectivePolicyValuesForVersion(values, config);
-  return createHash("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
+  return createHash3("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path6.join(config.memoryDir, "state", fileName);
+  const filePath = path8.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -4489,7 +5288,7 @@ async function exists(p) {
   }
 }
 function assertSafeNamespaceSegment(namespace) {
-  if (namespace.length === 0 || namespace === "." || namespace === ".." || namespace.includes("/") || namespace.includes("\\") || path6.isAbsolute(namespace) || path6.win32.isAbsolute(namespace)) {
+  if (namespace.length === 0 || namespace === "." || namespace === ".." || namespace.includes("/") || namespace.includes("\\") || path8.isAbsolute(namespace) || path8.win32.isAbsolute(namespace)) {
     throw new Error(`invalid namespace: ${namespace}`);
   }
 }
@@ -4539,7 +5338,7 @@ async function walkMemoryMarkdownFiles(memoryDir, visit) {
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path6.join(dir, entryName);
+      const fullPath = path8.join(dir, entryName);
       try {
         assertPathInsideRoot(memoryRootReal, await realpath3(fullPath), fullPath);
       } catch (err) {
@@ -4554,7 +5353,7 @@ async function walkMemoryMarkdownFiles(memoryDir, visit) {
       await visit(fullPath);
     }
   };
-  for (const root of RECALL_FALLBACK_DIRS.map((dir) => path6.join(memoryDir, dir))) {
+  for (const root of RECALL_FALLBACK_DIRS.map((dir) => path8.join(memoryDir, dir))) {
     await walk(root);
   }
 }
@@ -5164,7 +5963,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         if (plan.moved.length > 0) {
           console.log("\nEntries:");
           for (const move of plan.moved) {
-            console.log(`- ${path6.basename(move.from)}`);
+            console.log(`- ${path8.basename(move.from)}`);
           }
         }
         if (dryRun) {
@@ -5465,15 +6264,15 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const capsulesDir = defaultCapsulesDir(memoryDir);
         const { stat: statMerge } = await import("fs/promises");
         let sourceArchive = expandTildePath(parsed.archive);
-        const looksLikePath = sourceArchive.startsWith("/") || sourceArchive.startsWith("./") || sourceArchive.startsWith("../") || sourceArchive.includes(path6.sep);
+        const looksLikePath = sourceArchive.startsWith("/") || sourceArchive.startsWith("./") || sourceArchive.startsWith("../") || sourceArchive.includes(path8.sep);
         if (!looksLikePath) {
-          const cwdResolved = path6.resolve(sourceArchive);
+          const cwdResolved = path8.resolve(sourceArchive);
           const cwdSt = await statMerge(cwdResolved).catch(() => null);
           if (cwdSt && cwdSt.isFile()) {
             sourceArchive = cwdResolved;
           } else {
-            const byId = path6.join(capsulesDir, `${sourceArchive}.capsule.json.gz`);
-            const byIdEnc = path6.join(capsulesDir, `${sourceArchive}.capsule.json.gz.enc`);
+            const byId = path8.join(capsulesDir, `${sourceArchive}.capsule.json.gz`);
+            const byIdEnc = path8.join(capsulesDir, `${sourceArchive}.capsule.json.gz.enc`);
             const stId = await statMerge(byId).catch(() => null);
             if (stId && stId.isFile()) {
               sourceArchive = byId;
@@ -5554,10 +6353,10 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         ).sort();
         const entries = [];
         for (const archiveName of archives) {
-          const archivePath = path6.join(capsulesDir, archiveName);
+          const archivePath = path8.join(capsulesDir, archiveName);
           const id = archiveName.replace(/\.capsule\.json\.gz\.enc$/, "").replace(/\.capsule\.json\.gz$/, "");
           const manifestName = `${id}.manifest.json`;
-          const manifestPath = path6.join(capsulesDir, manifestName);
+          const manifestPath = path8.join(capsulesDir, manifestName);
           let createdAt = null;
           let pluginVersion = null;
           let fileCount = null;
@@ -5612,15 +6411,15 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const parsed = parseCapsuleInspectOptions(archiveArg, opts);
         const { stat } = await import("fs/promises");
         let archivePath = expandTildePath(parsed.archive);
-        const looksLikePath = archivePath.startsWith("/") || archivePath.startsWith("./") || archivePath.startsWith("../") || archivePath.includes(path6.sep);
+        const looksLikePath = archivePath.startsWith("/") || archivePath.startsWith("./") || archivePath.startsWith("../") || archivePath.includes(path8.sep);
         if (!looksLikePath) {
-          const cwdResolved = path6.resolve(archivePath);
+          const cwdResolved = path8.resolve(archivePath);
           const cwdSt = await stat(cwdResolved).catch(() => null);
           if (cwdSt && cwdSt.isFile()) {
             archivePath = cwdResolved;
           } else {
-            const byId = path6.join(capsulesDir, `${archivePath}.capsule.json.gz`);
-            const byIdEnc = path6.join(capsulesDir, `${archivePath}.capsule.json.gz.enc`);
+            const byId = path8.join(capsulesDir, `${archivePath}.capsule.json.gz`);
+            const byIdEnc = path8.join(capsulesDir, `${archivePath}.capsule.json.gz.enc`);
             const st = await stat(byId).catch(() => null);
             if (st && st.isFile()) {
               archivePath = byId;
@@ -6571,6 +7370,7 @@ ${doc.content}` : doc.content,
       registerMeetingsCommands(cmd, orchestrator);
       registerOkfCommands(cmd, orchestrator);
       registerDeepRecallCommands(cmd, orchestrator);
+      registerTimelineCommands(cmd, orchestrator);
       cmd.command("trust-zone-promote").description("Dry-run or apply a trust-zone promotion with provenance enforcement").requiredOption("--record-id <recordId>", "Source trust-zone record id").requiredOption("--target-zone <targetZone>", "Promotion target zone (working|trusted)").requiredOption("--reason <reason>", "Human-readable promotion reason").option("--recorded-at <isoTimestamp>", "Promotion timestamp (defaults to now)").option("--summary <summary>", "Optional replacement summary for the promoted record").option("--dry-run", "Show the promotion plan without writing the promoted record").action(async (...args) => {
         const options = args[0] ?? {};
         const result = await runTrustZonePromoteCliCommand({
@@ -7612,7 +8412,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           return;
         }
         const expandedTarget = expandTildePath(rawTarget);
-        const targetPath = path6.isAbsolute(expandedTarget) ? expandedTarget : path6.join(orchestrator.config.memoryDir, expandedTarget);
+        const targetPath = path8.isAbsolute(expandedTarget) ? expandedTarget : path8.join(orchestrator.config.memoryDir, expandedTarget);
         const { runConsolidationUndo, formatConsolidationUndoResult } = await import("./consolidation-undo.js");
         const result = await runConsolidationUndo({
           storage: orchestrator.storage,
@@ -7650,7 +8450,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path6.join(resolveHomeDir(), ".openclaw", "workspace");
+        const workspaceDir = path8.join(resolveHomeDir(), ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -7873,8 +8673,8 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path6.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path6.join(memoryDir, "threads"));
+        const memoryDir = path8.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path8.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -8807,6 +9607,18 @@ export {
   runMeetingsCliCommand,
   runOkfCliCommand,
   runHarmonicSearchCliCommand,
+  applyManagedRegion,
+  fileLines,
+  parseAtxHeading,
+  publishVaultRegion,
+  insertMarkersUnderHeading,
+  assertBeginEndPair,
+  VAULT_PUBLISH_OUTCOMES,
+  summarizeVaultPublish,
+  publishVaultNote,
+  mergeFrontmatterKeys,
+  setVaultPublisherTestHooks,
+  runTimelinePublishCli,
   runRebuildMemoryLifecycleLedgerCliCommand,
   convertMemoriesToRecords,
   registerTrainingExportAdapter,
@@ -8904,4 +9716,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-X4FIZAVQ.js.map
+//# sourceMappingURL=chunk-7JV4JST3.js.map