@vortex-os/base 0.12.0 → 0.13.0

package/dist/index.js

@@ -8,7 +8,10 @@ import {
   recordGuardDenial,
   runFailureCli,
   scanFailures
-} from "./chunk-UV76ZEDC.js";
+} from "./chunk-T4TJZUPP.js";
+import {
+  catchUpSessions
+} from "./chunk-3L5DLEGP.js";
 import {
   SESSION_END_COMMAND,
   SESSION_START_COMMAND,
@@ -27,7 +30,7 @@ import {
   serializeSettings,
   sniffEffortFromTranscript,
   statuslineCommand
-} from "./chunk-EAKDR5B2.js";
+} from "./chunk-OFID33QA.js";
 import {
   GUARD_WRITE_COMMAND,
   GUARD_WRITE_MATCHER,
@@ -37,7 +40,7 @@ import {
   resolveInstanceRoot,
   runGuardCli,
   scanToolInput
-} from "./chunk-2FVNWW77.js";
+} from "./chunk-JKQAB5OK.js";
 import {
   atomicWriteFile,
   dist_exports,
@@ -50,10 +53,7 @@ import {
   resolveEnvironment,
   serializeFrontmatter,
   validateDataRelativePath
-} from "./chunk-T53UWSTR.js";
-import {
-  catchUpSessions
-} from "./chunk-3L5DLEGP.js";
+} from "./chunk-IZIAMK3L.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -4024,6 +4024,7 @@ __export(dist_exports14, {
   agendaCommand: () => agendaCommand,
   aggregateHandoff: () => aggregateHandoff,
   applyGlobalSetup: () => applyGlobalSetup,
+  archiveRelPath: () => archiveRelPath,
   argvToSlash: () => argvToSlash,
   autoReindexMemory: () => autoReindexMemory,
   buildDenyDecision: () => buildDenyDecision,
@@ -4057,6 +4058,7 @@ __export(dist_exports14, {
   formatTokens: () => formatTokens,
   formatWindow: () => formatWindow,
   gapWindowSinceArg: () => gapWindowSinceArg,
+  gitOut: () => gitOut,
   globalMemoryPath: () => globalMemoryPath,
   globalSettingsHasHook: () => globalSettingsHasHook,
   globalSettingsPath: () => globalSettingsPath,
@@ -4092,6 +4094,7 @@ __export(dist_exports14, {
   repairOwnershipManifest: () => repairOwnershipManifest,
   resolveInstanceRoot: () => resolveInstanceRoot,
   resolveRepoRoot: () => resolveRepoRoot,
+  runArchiveSync: () => runArchiveSync,
   runCurateAccept: () => runCurateAccept,
   runCurateCandidates: () => runCurateCandidates,
   runCurateDecline: () => runCurateDecline,
@@ -4109,6 +4112,8 @@ __export(dist_exports14, {
   sessionStartCommand: () => sessionStartCommand,
   sniffEffortFromTranscript: () => sniffEffortFromTranscript,
   statuslineCommand: () => statuslineCommand,
+  sweepOrphanTempFiles: () => sweepOrphanTempFiles,
+  sweepRawArchive: () => sweepRawArchive,
   templateDestRelPath: () => templateDestRelPath,
   upsertGlobalBlock: () => upsertGlobalBlock,
   validateCuratePayload: () => validateCuratePayload,
@@ -6009,9 +6014,13 @@ async function seedInstanceConfig(repoRoot, templatesDir) {
           decision: true,
           ambientRecall: true,
           archive: true,
+          archiveCommit: true,
+          archiveAtEnd: true,
+          archiveRawRetentionDays: 30,
           vectorize: true
         },
         updates: { check: "session" },
+        sync: { autoPush: false },
         environments: []
       }, null, 2) + "\n", "utf8");
     }
@@ -6246,10 +6255,36 @@ async function runUpdate(input, tokens) {
   const dryRun = tokens.includes("--dry-run");
   const adopt = parseAdoptArgs(tokens);
   const templatesDir = resolveTemplatesDir();
-  const result = await runTemplatesUpdate(input.context, templatesDir, {
+  let result = await runTemplatesUpdate(input.context, templatesDir, {
     dryRun,
     adopt: adopt.size > 0 ? adopt : void 0
   });
+  if (!dryRun) {
+    try {
+      const settingsPath = join24(input.context.repoRoot, ".claude", "settings.json");
+      const existingText = existsSync11(settingsPath) ? await readFile21(settingsPath, "utf8") : null;
+      const { settings, added, alreadyWired } = ensureVortexHooks(parseSettings(existingText), { guard: true });
+      if (!alreadyWired) {
+        await mkdir9(join24(input.context.repoRoot, ".claude"), { recursive: true });
+        await writeFile10(settingsPath, serializeSettings(settings), "utf8");
+        result = {
+          ...result,
+          nextActions: [
+            ...result.nextActions,
+            `Wired missing ${added.join(" + ")} hook(s) into .claude/settings.json` + (added.includes("PreToolUse") ? " \u2014 the write guard now denies literal control bytes in file writes (remove the PreToolUse group to opt out)." : ".")
+          ]
+        };
+      }
+    } catch (e) {
+      result = {
+        ...result,
+        nextActions: [
+          ...result.nextActions,
+          `\u26A0\uFE0F Could not verify/wire session hooks: ${e.message}`
+        ]
+      };
+    }
+  }
   if (dryRun || result.status === "no-manifest" || result.status === "no-templates")
     return result;
   if (!loadVortexConfig(input.context).autoRecord.commitFrameworkChanges)
@@ -7585,23 +7620,280 @@ function createRitualRegistry(options) {
 }
 
 // ../plugins/session-rituals/dist/cli-dispatch.js
-import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync3, mkdirSync, openSync, writeSync, closeSync, linkSync, rmSync, statSync } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync16, readFileSync as readFileSync4, mkdirSync as mkdirSync2, openSync as openSync2, writeSync as writeSync2, closeSync as closeSync2, linkSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
 import { createRequire } from "module";
 import { hostname } from "os";
-import { isAbsolute as isAbsolute4, join as join28 } from "path";
+import { join as join29 } from "path";
+
+// ../plugins/session-rituals/dist/archive-sync.js
+import { closeSync, existsSync as existsSync12, mkdirSync, openSync, readdirSync, readFileSync as readFileSync2, renameSync, rmSync, statSync, writeSync } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
+import { isAbsolute as isAbsolute4, join as join25, relative as relative5, sep as sep4 } from "path";
+function gitOut(cwd, gitArgs) {
+  return execFileSync2("git", [...gitArgs], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+}
+function detectInterruptedGitOp(repoRoot) {
+  const markers = [
+    "MERGE_HEAD",
+    "rebase-merge",
+    "rebase-apply",
+    "CHERRY_PICK_HEAD",
+    "REVERT_HEAD",
+    "BISECT_LOG",
+    "index.lock"
+  ];
+  try {
+    const args = ["rev-parse", ...markers.flatMap((m2) => ["--git-path", m2])];
+    const resolved = gitOut(repoRoot, args).split(/\r?\n/).map((s) => s.trim());
+    for (let i = 0; i < markers.length; i++) {
+      const p = resolved[i];
+      if (p && existsSync12(isAbsolute4(p) ? p : join25(repoRoot, p)))
+        return markers[i];
+    }
+  } catch {
+  }
+  return null;
+}
+var NOTHING = {
+  ran: false,
+  lockSkipped: false,
+  catchUp: null,
+  rawPruned: 0,
+  retentionDays: 0,
+  committed: false,
+  pushed: false
+};
+var ARCHIVE_SYNC_LOCK_TTL_MS = 10 * 60 * 1e3;
+function lockPath(dataDir) {
+  return join25(dataDir, "_session-archive", ".sync.lock");
+}
+function archiveRelPath(ctx) {
+  return relative5(ctx.repoRoot, join25(ctx.dataDir, "_session-archive")).split(sep4).join("/");
+}
+function sweepRawArchive(dataDir, retentionDays, nowMs = Date.now()) {
+  if (!(retentionDays > 0))
+    return 0;
+  const rawDir = join25(dataDir, "_session-archive", "raw");
+  const cutoff = nowMs - retentionDays * 864e5;
+  let pruned = 0;
+  const walk5 = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = join25(dir, e.name);
+      if (e.isDirectory()) {
+        walk5(p);
+      } else if (e.isFile()) {
+        try {
+          if (statSync(p).mtimeMs < cutoff) {
+            rmSync(p, { force: true });
+            pruned++;
+          }
+        } catch {
+        }
+      }
+    }
+  };
+  walk5(rawDir);
+  return pruned;
+}
+function sweepOrphanTempFiles(dataDir, nowMs = Date.now()) {
+  let removed = 0;
+  const sweep = (dir, recurse, minAgeMs) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = join25(dir, e.name);
+      if (e.isDirectory()) {
+        if (recurse)
+          sweep(p, recurse, minAgeMs);
+      } else if (e.isFile() && /\.tmp-\d+$/.test(e.name)) {
+        try {
+          if (minAgeMs === 0 || nowMs - statSync(p).mtimeMs >= minAgeMs) {
+            rmSync(p, { force: true });
+            removed++;
+          }
+        } catch {
+        }
+      }
+    }
+  };
+  sweep(join25(dataDir, "_session-archive", "raw"), true, 0);
+  sweep(join25(dataDir, "_session-archive", "normalized"), true, 0);
+  sweep(join25(dataDir, "_session-archive", ".tmp"), false, ARCHIVE_SYNC_LOCK_TTL_MS);
+  return removed;
+}
+function isDetachedHead(repoRoot) {
+  try {
+    gitOut(repoRoot, ["symbolic-ref", "-q", "HEAD"]);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function pushCurrentBranch(repoRoot) {
+  try {
+    if (!gitOut(repoRoot, ["remote"]).trim())
+      return { pushed: false, skip: "no-remote" };
+  } catch {
+    return { pushed: false, skip: "git-error" };
+  }
+  try {
+    gitOut(repoRoot, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]);
+  } catch {
+    return { pushed: false, skip: "no-upstream" };
+  }
+  const counts = () => {
+    const [a, b2] = gitOut(repoRoot, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]).trim().split(/\s+/);
+    return { ahead: Number(a ?? 0) || 0, behind: Number(b2 ?? 0) || 0 };
+  };
+  try {
+    let { ahead, behind } = counts();
+    if (behind > 0) {
+      try {
+        gitOut(repoRoot, ["pull", "--ff-only"]);
+      } catch {
+        return { pushed: false, skip: "diverged" };
+      }
+      ({ ahead, behind } = counts());
+    }
+    if (ahead === 0)
+      return { pushed: false, skip: "no-commit" };
+    gitOut(repoRoot, ["push"]);
+    return { pushed: true };
+  } catch {
+    return { pushed: false, skip: "git-error" };
+  }
+}
+async function runArchiveSync(ctx, config, _phase, opts) {
+  const lock = lockPath(ctx.dataDir);
+  const token = `${process.pid}-${process.hrtime.bigint()}`;
+  let lockFd;
+  try {
+    mkdirSync(join25(ctx.dataDir, "_session-archive"), { recursive: true });
+    lockFd = openSync(lock, "wx");
+  } catch (e) {
+    if (e.code !== "EEXIST") {
+      return { ...NOTHING, lockSkipped: true };
+    }
+    let stale = true;
+    try {
+      stale = Date.now() - statSync(lock).mtimeMs >= ARCHIVE_SYNC_LOCK_TTL_MS;
+    } catch {
+      stale = true;
+    }
+    if (!stale)
+      return { ...NOTHING, lockSkipped: true };
+    const claimed = `${lock}.stale-${process.pid}`;
+    try {
+      renameSync(lock, claimed);
+      rmSync(claimed, { force: true });
+    } catch {
+      return { ...NOTHING, lockSkipped: true };
+    }
+    try {
+      lockFd = openSync(lock, "wx");
+    } catch {
+      return { ...NOTHING, lockSkipped: true };
+    }
+  }
+  let tokenWritten = false;
+  const releaseLock = () => {
+    try {
+      const cur = existsSync12(lock) ? readFileSync2(lock, "utf8").trim() : "";
+      if (cur === token || cur === "" && !tokenWritten)
+        rmSync(lock, { force: true });
+    } catch {
+    }
+  };
+  try {
+    try {
+      writeSync(lockFd, token + "\n");
+      tokenWritten = true;
+    } finally {
+      closeSync(lockFd);
+    }
+    let catchUp = null;
+    try {
+      const { catchUpSessions: catchUpSessions2 } = await import("./catch-up-GDDKPZHJ.js");
+      catchUp = await catchUpSessions2(ctx, opts?.catchUp);
+    } catch {
+    }
+    const retentionDays = config.autoRecord.archiveRawRetentionDays;
+    let rawPruned = 0;
+    try {
+      rawPruned = sweepRawArchive(ctx.dataDir, retentionDays);
+    } catch {
+    }
+    try {
+      sweepOrphanTempFiles(ctx.dataDir);
+    } catch {
+    }
+    let committed = false;
+    let commitSkipped;
+    if (!config.autoRecord.archiveCommit) {
+      commitSkipped = "off";
+    } else if (detectInterruptedGitOp(ctx.repoRoot)) {
+      commitSkipped = "git-busy";
+    } else if (isDetachedHead(ctx.repoRoot)) {
+      commitSkipped = "detached-head";
+    } else {
+      const rel = archiveRelPath(ctx);
+      const paths = [`${rel}/raw`, `${rel}/normalized`].filter((p) => existsSync12(join25(ctx.repoRoot, ...p.split("/"))));
+      const ingested = catchUp?.ingestedLocal ?? 0;
+      const result = commitFrameworkPaths(ctx.repoRoot, paths, `chore(vortex): session archive sync (${ingested} ingested, ${rawPruned} raw pruned)`);
+      committed = result.committed;
+      if (!result.committed) {
+        commitSkipped = result.reason === "nothing-to-commit" || result.reason === "no-paths" ? "nothing-to-commit" : result.reason === "not-a-git-repo" ? "not-a-git-repo" : "git-error";
+      }
+    }
+    let pushed = false;
+    let pushSkipped;
+    if (!config.sync.autoPush) {
+      pushSkipped = "off";
+    } else {
+      ({ pushed, skip: pushSkipped } = pushCurrentBranch(ctx.repoRoot));
+    }
+    return {
+      ran: true,
+      lockSkipped: false,
+      catchUp,
+      rawPruned,
+      retentionDays,
+      committed,
+      ...commitSkipped !== void 0 ? { commitSkipped } : {},
+      pushed,
+      ...pushSkipped !== void 0 ? { pushSkipped } : {}
+    };
+  } finally {
+    releaseLock();
+  }
+}
 
 // ../plugins/session-rituals/dist/update-check.js
 import { execSync } from "child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync2 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync3 } from "fs";
+import { join as join26 } from "path";
 var PKG = "@vortex-os/base";
 var NPM_TIMEOUT_MS = 4e3;
 function readInstalledBaseVersion(templatesDir = resolveTemplatesDir()) {
   if (!templatesDir)
     return null;
   try {
-    const m2 = JSON.parse(readFileSync2(join25(templatesDir, "manifest.json"), "utf8"));
+    const m2 = JSON.parse(readFileSync3(join26(templatesDir, "manifest.json"), "utf8"));
     return typeof m2.baseVersion === "string" && parseCore(m2.baseVersion) ? m2.baseVersion.trim() : null;
   } catch {
     return null;
@@ -7673,8 +7965,8 @@ function isStableUpdate(latest, installed) {
   return compareSemver(latest, installed) === 1;
 }
 function buildInstallCommand(repoRoot) {
-  const has = (f) => existsSync12(join25(repoRoot, f));
-  const local = existsSync12(join25(repoRoot, "node_modules", "@vortex-os", "base"));
+  const has = (f) => existsSync13(join26(repoRoot, f));
+  const local = existsSync13(join26(repoRoot, "node_modules", "@vortex-os", "base"));
   let installPart;
   if (!local) {
     installPart = `npm i -g ${PKG}@latest`;
@@ -7702,9 +7994,9 @@ function checkBaseUpdate(ctx) {
 }
 
 // ../plugins/session-rituals/dist/session-start-report.js
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { readdir as readdir17, readFile as readFile22, stat as stat9 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var COUNTED_DIRS2 = ["_memory", "worklog", "decision-log"];
 var DEFAULT_GAP_WINDOW_DAYS = 30;
 function gapWindowSinceArg() {
@@ -7721,8 +8013,8 @@ async function collectSessionStartReport(ctx, opts) {
   const counts = {};
   const missing = [];
   for (const name of COUNTED_DIRS2) {
-    const dir = join26(ctx.dataDir, name);
-    if (!existsSync13(dir)) {
+    const dir = join27(ctx.dataDir, name);
+    if (!existsSync14(dir)) {
       missing.push(name);
       counts[name] = 0;
       continue;
@@ -7732,7 +8024,7 @@ async function collectSessionStartReport(ctx, opts) {
   const { recent, recentGroup, recentWorklogsOmitted, dates, latestBodies } = await scanWorklog(ctx.dataDir);
   const cutoff = isoDate2(addDays2(now, -(opts?.gapWindowDays ?? DEFAULT_GAP_WINDOW_DAYS)));
   const recentWorklogDates = dates.filter((d2) => d2 >= cutoff);
-  const mem = await scanMemoryTiers(join26(ctx.dataDir, "_memory"));
+  const mem = await scanMemoryTiers(join27(ctx.dataDir, "_memory"));
   const ho = await scanHandoffs(ctx.dataDir);
   const handoffs = ho.active.map((h) => ({
     date: h.date,
@@ -7799,7 +8091,7 @@ async function scanMemoryTiers(memoryDir) {
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".md"))
       continue;
-    const full = join26(memoryDir, e.name);
+    const full = join27(memoryDir, e.name);
     if (e.name === "_INDEX.md") {
       indexExists = true;
       try {
@@ -7970,6 +8262,7 @@ function renderSessionStartReport(report, extras) {
       lines.push(`  - \u2026(+${fl.omitted} more \u2014 \`vortex failure list\`)`);
   }
   const cu = extras?.catchUp;
+  const as = extras?.archiveSync;
   if (cu && (cu.ingestedLocal > 0 || cu.indexedPulled > 0 || cu.errors > 0)) {
     const parts = [];
     if (cu.ingestedLocal > 0)
@@ -7978,9 +8271,19 @@ function renderSessionStartReport(report, extras) {
       parts.push(`${cu.indexedPulled} pulled`);
     const n = cu.ingestedLocal + cu.indexedPulled;
     let line = `- caught up: archived ${parts.join(" + ")} conversation${n === 1 ? "" : "s"}`;
+    if (as?.committed)
+      line += as.pushed ? " \xB7 committed & pushed" : " \xB7 committed";
     if (cu.errors > 0)
       line += ` (${cu.errors} error${cu.errors === 1 ? "" : "s"})`;
     lines.push(line);
+  } else if (as?.committed) {
+    lines.push(`- archive: changes committed${as.pushed ? " & pushed" : ""}`);
+  }
+  if (as && as.rawPruned > 0) {
+    lines.push(`- \u{1F9F9} archive: removed ${as.rawPruned} raw transcript cop${as.rawPruned === 1 ? "y" : "ies"} older than ${as.retentionDays}d (local duplicates; the normalized archive keeps everything)`);
+  }
+  if (as && !as.pushed && as.pushSkipped && as.pushSkipped !== "off" && as.pushSkipped !== "no-commit") {
+    lines.push(`- \u26A0\uFE0F auto-push is on but could not push (${as.pushSkipped}) \u2014 push manually or check the remote.`);
   }
   const vec = extras?.vectorized;
   if (vec && vec.sessionChunks > 0) {
@@ -8038,15 +8341,15 @@ async function countMarkdown3(dir, recursive) {
     } else if (e.isDirectory() && recursive) {
       if (e.name.startsWith(".") || e.name.startsWith("_"))
         continue;
-      total += await countMarkdown3(join26(dir, e.name), recursive);
+      total += await countMarkdown3(join27(dir, e.name), recursive);
     }
   }
   return total;
 }
 var MAX_GROUP_READ = 20;
 async function scanWorklog(dataDir) {
-  const root = join26(dataDir, "worklog");
-  if (!existsSync13(root))
+  const root = join27(dataDir, "worklog");
+  if (!existsSync14(root))
     return { recent: null, recentGroup: [], recentWorklogsOmitted: 0, dates: [], latestBodies: [] };
   const dates = /* @__PURE__ */ new Set();
   const consistent = [];
@@ -8061,7 +8364,7 @@ async function scanWorklog(dataDir) {
     for (const e of entries) {
       const childRel = rel ? `${rel}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        await walk5(join26(absDir, e.name), childRel);
+        await walk5(join27(absDir, e.name), childRel);
       } else if (e.isFile()) {
         const m2 = e.name.match(/^(\d{4})-(\d{2})-(\d{2})(?:_\d{4})?-.+\.md$/);
         if (!m2)
@@ -8090,7 +8393,7 @@ async function scanWorklog(dataDir) {
   const recentGroup = [];
   const latestBodies = [];
   for (const g of group) {
-    const { title, body } = await readWorklogTitleAndBody(join26(root, g.rel));
+    const { title, body } = await readWorklogTitleAndBody(join27(root, g.rel));
     recentGroup.push({ path: defangReportPath(`worklog/${g.rel}`), title });
     latestBodies.push(body);
   }
@@ -8169,10 +8472,10 @@ function isoDate2(d2) {
 }
 
 // ../plugins/session-rituals/dist/curate-cli.js
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { createHash as createHash3 } from "crypto";
 import { readFile as readFile23, readdir as readdir18 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var SYSTEM_META_DIRS2 = /* @__PURE__ */ new Set([
   "worklog",
   "decision-log",
@@ -8252,10 +8555,10 @@ function joinRel(...parts) {
 }
 async function runCurateCandidates(repoRoot, options) {
   const maxEntries = options?.maxEntries ?? 200;
-  const dataDir = join27(repoRoot, "data");
+  const dataDir = join28(repoRoot, "data");
   const candidates = [];
   let truncated = false;
-  if (existsSync14(dataDir)) {
+  if (existsSync15(dataDir)) {
     async function visit(absDir, relDir) {
       if (candidates.length >= maxEntries) {
         truncated = true;
@@ -8278,7 +8581,7 @@ async function runCurateCandidates(repoRoot, options) {
             continue;
           if (atRoot && (SYSTEM_META_DIRS2.has(e.name) || e.name.startsWith("_")))
             continue;
-          await visit(join27(absDir, e.name), joinRel(relDir, e.name));
+          await visit(join28(absDir, e.name), joinRel(relDir, e.name));
         } else if (e.isFile() && e.name.endsWith(".md")) {
           if (NON_DOC_FILES.has(e.name))
             continue;
@@ -8287,7 +8590,7 @@ async function runCurateCandidates(repoRoot, options) {
           let topic = null;
           let tags = [];
           try {
-            const raw = await readFile23(join27(absDir, e.name), "utf8");
+            const raw = await readFile23(join28(absDir, e.name), "utf8");
             const parsed = parseFrontmatter(raw);
             if (typeof parsed.frontmatter.topic === "string") {
               topic = parsed.frontmatter.topic.trim().toLowerCase();
@@ -8325,7 +8628,7 @@ async function runCuratePreview(repoRoot, payload, now = /* @__PURE__ */ new Dat
     };
   }
   try {
-    validateDataRelativePath(join27(repoRoot, "data"), v2.effectiveRelPath);
+    validateDataRelativePath(join28(repoRoot, "data"), v2.effectiveRelPath);
   } catch (e) {
     return {
       subcommand: "curate-preview",
@@ -8342,10 +8645,10 @@ async function runCuratePreview(repoRoot, payload, now = /* @__PURE__ */ new Dat
   let targetExists;
   let wouldDo;
   if (payload.action === "create-file") {
-    targetExists = existsSync14(join27(repoRoot, "data", v2.effectiveRelPath));
+    targetExists = existsSync15(join28(repoRoot, "data", v2.effectiveRelPath));
     wouldDo = targetExists ? `create-file at ${v2.effectiveRelPath} \u2014 but the file already EXISTS, so accept would REFUSE (no overwrite).` : `create a new document at data/${v2.effectiveRelPath}.`;
   } else {
-    targetExists = existsSync14(join27(repoRoot, "data", v2.effectiveRelPath));
+    targetExists = existsSync15(join28(repoRoot, "data", v2.effectiveRelPath));
     wouldDo = targetExists ? `append a "## ${payload.sectionHeader}" section to data/${v2.effectiveRelPath}.` : `append-section to data/${v2.effectiveRelPath} \u2014 but the file does NOT exist, so accept would FAIL (append-section never creates).`;
   }
   const nextActions = [];
@@ -8490,13 +8793,13 @@ function readCuratePayload(args) {
       break;
     }
     if (t === "--payload-file" && i + 1 < args.length) {
-      raw = readFileSync3(args[++i], "utf8");
+      raw = readFileSync4(args[++i], "utf8");
       break;
     }
   }
   if (raw === null) {
     try {
-      raw = readFileSync3(0, "utf8");
+      raw = readFileSync4(0, "utf8");
     } catch {
       raw = "";
     }
@@ -8520,18 +8823,18 @@ async function runVortexCli(argv, io) {
   const err = io?.stderr ?? ((s) => process.stderr.write(s));
   try {
     if (argv[0] === "statusline") {
-      const { runStatuslineCli: runStatuslineCli2 } = await import("./statusline-6KSHISXO.js");
+      const { runStatuslineCli: runStatuslineCli2 } = await import("./statusline-6BGWOOLA.js");
       const statuslineRoot = process.env.VORTEX_REPO_ROOT?.trim() || process.cwd();
       return runStatuslineCli2(argv.slice(1), statuslineRoot, out, err);
     }
     if (argv[0] === "guard") {
-      const { runGuardCli: runGuardCli2 } = await import("./guard-IMJR6ET7.js");
+      const { runGuardCli: runGuardCli2 } = await import("./guard-S6NGMDXR.js");
       return runGuardCli2(argv.slice(1), out, err);
     }
     const repoRoot = resolveRepoRoot();
     if (argv[0] === "failure") {
-      const { runFailureCli: runFailureCli2 } = await import("./failures-PMURLMVB.js");
-      const { resolveInstanceRoot: resolveInstanceRoot2 } = await import("./guard-IMJR6ET7.js");
+      const { runFailureCli: runFailureCli2 } = await import("./failures-DBXJKFYX.js");
+      const { resolveInstanceRoot: resolveInstanceRoot2 } = await import("./guard-S6NGMDXR.js");
       const root = resolveInstanceRoot2(process.cwd()) ?? repoRoot;
       const ctx = makeContext(root);
       return runFailureCli2(argv.slice(1), ctx.dataDir, out, err);
@@ -8544,6 +8847,10 @@ async function runVortexCli(argv, io) {
       await runSessionEnd(repoRoot, out);
       return 0;
     }
+    if (argv[0] === "catch-up") {
+      await runCatchUpCli(repoRoot, out);
+      return 0;
+    }
     if (argv[0] === "check-updates") {
       const result2 = checkBaseUpdate(makeContext(repoRoot));
       out(JSON.stringify(result2, null, 2) + "\n");
@@ -8571,8 +8878,9 @@ async function runVortexCli(argv, io) {
 
 Commands:
 ${names}
-  session-start  \u2014  emit the start-of-session boot report (git pull + data counts + catch-up)
-  session-end    \u2014  no-op (kept for hook compatibility; worklog gap handling is at session-start)
+  session-start  \u2014  emit the start-of-session boot report (git pull + data counts + archive sync)
+  session-end    \u2014  best-effort archive sync at wind-down (ingest closed sessions + auto-commit; crash-safe \u2014 session-start repeats it)
+  catch-up       \u2014  explicit archive sync now (ingest closed sessions, sweep raw copies, auto-commit, opt-in push); run before a manual sync
   check-updates  \u2014  check the npm registry for a newer @vortex-os/base (read-only; prints the exact update command)
   statusline     \u2014  render the Claude Code status bar from stdin JSON (\`lite\` for 1-line; \`install [--lite]\` wires .claude/settings.json)
   failure        \u2014  failure ledger (\`record\` an occurrence by recurrence key / \`list\` open groups with their escalation stage)
@@ -8643,14 +8951,14 @@ function memoryExtendedPresent() {
 }
 var VECTORIZE_LOCK_TTL_MS = 6 * 60 * 60 * 1e3;
 function vectorizeLockPath(ctx) {
-  return join28(ctx.dataDir, "_indexes", ".vectorize.lock");
+  return join29(ctx.dataDir, "_indexes", ".vectorize.lock");
 }
 function vectorizeSetupInProgress(ctx) {
   const lock = vectorizeLockPath(ctx);
   try {
-    if (!existsSync15(lock))
+    if (!existsSync16(lock))
       return false;
-    return Date.now() - statSync(lock).mtimeMs < VECTORIZE_LOCK_TTL_MS;
+    return Date.now() - statSync2(lock).mtimeMs < VECTORIZE_LOCK_TTL_MS;
   } catch {
     return false;
   }
@@ -8669,24 +8977,24 @@ function spawnVectorizeSetup(repoRoot) {
 }
 async function runVectorizeSetup(repoRoot, out, err) {
   const ctx = makeContext(repoRoot);
-  const indexDir = join28(ctx.dataDir, "_indexes");
-  const finalDb = join28(indexDir, "memory.sqlite");
-  if (existsSync15(finalDb)) {
+  const indexDir = join29(ctx.dataDir, "_indexes");
+  const finalDb = join29(indexDir, "memory.sqlite");
+  if (existsSync16(finalDb)) {
     out("recall index already present \u2014 nothing to do\n");
     return;
   }
-  mkdirSync(indexDir, { recursive: true });
-  const lockPath = vectorizeLockPath(ctx);
+  mkdirSync2(indexDir, { recursive: true });
+  const lockPath2 = vectorizeLockPath(ctx);
   const token = `${process.pid}-${process.hrtime.bigint()}`;
   let lockFd;
   try {
-    lockFd = openSync(lockPath, "wx");
+    lockFd = openSync2(lockPath2, "wx");
   } catch (e) {
     if (e.code !== "EEXIST")
       throw e;
     let stale = true;
     try {
-      stale = Date.now() - statSync(lockPath).mtimeMs >= VECTORIZE_LOCK_TTL_MS;
+      stale = Date.now() - statSync2(lockPath2).mtimeMs >= VECTORIZE_LOCK_TTL_MS;
     } catch {
       stale = true;
     }
@@ -8694,38 +9002,38 @@ async function runVectorizeSetup(repoRoot, out, err) {
       out("another recall setup is already in progress \u2014 skipping\n");
       return;
     }
-    rmSync(lockPath, { force: true });
+    rmSync2(lockPath2, { force: true });
     try {
-      lockFd = openSync(lockPath, "wx");
+      lockFd = openSync2(lockPath2, "wx");
     } catch {
       out("another recall setup just started \u2014 skipping\n");
       return;
     }
   }
-  const tmpDb = join28(indexDir, `memory.sqlite.building-${process.pid}`);
+  const tmpDb = join29(indexDir, `memory.sqlite.building-${process.pid}`);
   const tmpSidecars = [tmpDb + "-wal", tmpDb + "-shm", tmpDb + "-journal"];
   const cleanTmp = () => {
-    rmSync(tmpDb, { force: true });
+    rmSync2(tmpDb, { force: true });
     for (const s of tmpSidecars)
-      rmSync(s, { force: true });
+      rmSync2(s, { force: true });
   };
   let tokenWritten = false;
   const releaseLock = () => {
     try {
-      const cur = existsSync15(lockPath) ? readFileSync3(lockPath, "utf8").trim() : "";
+      const cur = existsSync16(lockPath2) ? readFileSync4(lockPath2, "utf8").trim() : "";
       if (cur === token || cur === "" && !tokenWritten)
-        rmSync(lockPath, { force: true });
+        rmSync2(lockPath2, { force: true });
     } catch {
     }
   };
   try {
     try {
-      writeSync(lockFd, token + "\n");
+      writeSync2(lockFd, token + "\n");
       tokenWritten = true;
     } finally {
-      closeSync(lockFd);
+      closeSync2(lockFd);
     }
-    if (existsSync15(finalDb)) {
+    if (existsSync16(finalDb)) {
       out("recall index already present \u2014 nothing to do\n");
       return;
     }
@@ -8741,7 +9049,7 @@ async function runVectorizeSetup(repoRoot, out, err) {
     } finally {
       db.close();
     }
-    if (existsSync15(tmpDb + "-wal")) {
+    if (existsSync16(tmpDb + "-wal")) {
       throw new Error("temp index retained a WAL sidecar after consolidation; refusing to publish");
     }
     try {
@@ -8754,7 +9062,7 @@ async function runVectorizeSetup(repoRoot, out, err) {
       }
       throw e;
     }
-    rmSync(tmpDb, { force: true });
+    rmSync2(tmpDb, { force: true });
     out(`recall index built \u2014 semantic search ready (memories: ${result.memories}, conversation chunks: ${result.sessionChunks})
 `);
   } catch (e) {
@@ -8790,7 +9098,8 @@ async function runSessionStart(repoRoot, out) {
   } catch {
   }
   const bookkeepingPrefix = frameworkBookkeepingPrefix(ctx);
-  const carryover = collectCarryover(repoRoot, (p) => p.startsWith(bookkeepingPrefix));
+  const archivePrefix = archiveRelPath(ctx) + "/";
+  const carryover = collectCarryover(repoRoot, (p) => p.startsWith(bookkeepingPrefix) || p.startsWith(archivePrefix));
   if (config.autoRecord.reindex && !git2?.conflict) {
     await autoReindexMemory(ctx);
   }
@@ -8804,14 +9113,14 @@ async function runSessionStart(repoRoot, out) {
     } catch {
     }
   }
-  let catchUp = null;
+  let archiveSync = null;
   if (config.autoRecord.archive) {
     try {
-      const { catchUpSessions: catchUpSessions2 } = await import("./catch-up-GDDKPZHJ.js");
-      catchUp = await catchUpSessions2(ctx);
+      archiveSync = await runArchiveSync(ctx, config, "start");
     } catch {
     }
   }
+  const catchUp = archiveSync?.catchUp ?? null;
   let handoffPrune = null;
   if (config.autoRecord.handoff) {
     try {
@@ -8825,7 +9134,7 @@ async function runSessionStart(repoRoot, out) {
   let vectorized = null;
   let vectorizeSetupStarted = false;
   if (config.autoRecord.vectorize) {
-    const dbExists = existsSync15(join28(ctx.dataDir, "_indexes", "memory.sqlite"));
+    const dbExists = existsSync16(join29(ctx.dataDir, "_indexes", "memory.sqlite"));
     const action = decideVectorizeAction({
       vectorizeOn: true,
       dbExists,
@@ -8851,7 +9160,7 @@ async function runSessionStart(repoRoot, out) {
   let failures = null;
   if (config.autoRecord.failures) {
     try {
-      const { scanFailures: scanFailures2, failureReportSlice: failureReportSlice2 } = await import("./failures-PMURLMVB.js");
+      const { scanFailures: scanFailures2, failureReportSlice: failureReportSlice2 } = await import("./failures-DBXJKFYX.js");
       const slice = failureReportSlice2(await scanFailures2(ctx.dataDir));
       if (slice.warnings.length > 0)
         failures = slice;
@@ -8891,6 +9200,13 @@ async function runSessionStart(repoRoot, out) {
     baseVersion,
     missingWorklogDays,
     catchUp: catchUp ?? void 0,
+    archiveSync: archiveSync ? {
+      committed: archiveSync.committed,
+      pushed: archiveSync.pushed,
+      pushSkipped: archiveSync.pushSkipped,
+      rawPruned: archiveSync.rawPruned,
+      retentionDays: archiveSync.retentionDays
+    } : void 0,
     vectorized: vectorized ?? void 0,
     vectorizeSetup: vectorizeSetupStarted || void 0,
     templateUpdate: templateUpdate ?? void 0,
@@ -8901,36 +9217,48 @@ async function runSessionStart(repoRoot, out) {
     failures: failures ?? void 0
   }));
 }
-async function runSessionEnd(_repoRoot, _out) {
-}
-function gitOut(cwd, gitArgs) {
-  return execFileSync2("git", [...gitArgs], {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-}
-function detectInterruptedGitOp(repoRoot) {
-  const markers = [
-    "MERGE_HEAD",
-    "rebase-merge",
-    "rebase-apply",
-    "CHERRY_PICK_HEAD",
-    "REVERT_HEAD",
-    "BISECT_LOG",
-    "index.lock"
-  ];
+async function runSessionEnd(repoRoot, out) {
   try {
-    const args = ["rev-parse", ...markers.flatMap((m2) => ["--git-path", m2])];
-    const resolved = gitOut(repoRoot, args).split(/\r?\n/).map((s) => s.trim());
-    for (let i = 0; i < markers.length; i++) {
-      const p = resolved[i];
-      if (p && existsSync15(isAbsolute4(p) ? p : join28(repoRoot, p)))
-        return markers[i];
+    const ctx = makeContext(repoRoot);
+    const config = loadVortexConfig(ctx);
+    if (!config.autoRecord.archive || !config.autoRecord.archiveAtEnd)
+      return;
+    const r = await runArchiveSync(ctx, config, "end");
+    if (r.lockSkipped) {
+      out("archive sync skipped (another session is syncing)\n");
+      return;
     }
+    const parts = [];
+    if (r.catchUp)
+      parts.push(`${r.catchUp.ingestedLocal} archived`);
+    if (r.rawPruned > 0)
+      parts.push(`${r.rawPruned} raw pruned`);
+    if (r.committed)
+      parts.push("committed");
+    if (r.pushed)
+      parts.push("pushed");
+    out(`session-end archive sync: ${parts.length ? parts.join(", ") : "nothing to do"}
+`);
   } catch {
   }
-  return null;
+}
+async function runCatchUpCli(repoRoot, out) {
+  const ctx = makeContext(repoRoot);
+  const config = loadVortexConfig(ctx);
+  const r = await runArchiveSync(ctx, config, "manual");
+  out(JSON.stringify({
+    ran: r.ran,
+    lockSkipped: r.lockSkipped,
+    ingested: r.catchUp?.ingestedLocal ?? 0,
+    indexedPulled: r.catchUp?.indexedPulled ?? 0,
+    ingestErrors: r.catchUp?.errors ?? 0,
+    rawPruned: r.rawPruned,
+    rawRetentionDays: r.retentionDays,
+    committed: r.committed,
+    ...r.commitSkipped ? { commitSkipped: r.commitSkipped } : {},
+    pushed: r.pushed,
+    ...r.pushSkipped ? { pushSkipped: r.pushSkipped } : {}
+  }, null, 2) + "\n");
 }
 function collectCarryover(repoRoot, ignore) {
   const interrupted = detectInterruptedGitOp(repoRoot);
@@ -8945,23 +9273,23 @@ function resolveSessionEnvironment(ctx, config) {
   let environment = resolveEnvironment(config, {
     hostname: hostname(),
     env: process.env,
-    pathExists: existsSync15
+    pathExists: existsSync16
   });
   if (!environment)
     environment = process.env.VORTEX_ENV?.trim() || null;
   if (!environment) {
-    const envFile = join28(ctx.repoRoot, ".agent", "environment");
-    if (existsSync15(envFile)) {
-      environment = readFileSync3(envFile, "utf8").split(/\r?\n/)[0]?.trim() || null;
+    const envFile = join29(ctx.repoRoot, ".agent", "environment");
+    if (existsSync16(envFile)) {
+      environment = readFileSync4(envFile, "utf8").split(/\r?\n/)[0]?.trim() || null;
     }
   }
   return environment;
 }
 
 // ../plugins/session-rituals/dist/ambient-recall.js
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function defaultDbPath2(ctx) {
-  return join29(ctx.dataDir, "_indexes", "memory.sqlite");
+  return join30(ctx.dataDir, "_indexes", "memory.sqlite");
 }
 function createAmbientRecaller(ctx, options) {
   const resolveDb = options.dbPath ?? defaultDbPath2;
@@ -8999,13 +9327,13 @@ function createAmbientRecaller(ctx, options) {
 
 // ../plugins/session-rituals/dist/worklog-write.js
 import { mkdir as mkdir10, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname6, join as join30 } from "path";
+import { dirname as dirname6, join as join31 } from "path";
 async function ensureWorklogEntry(ctx, opts) {
   const now = opts?.now ?? /* @__PURE__ */ new Date();
   const date = isoDate3(now);
   const time = isoTime2(now);
   const keyword = (opts?.keyword ?? "worklog").trim() || "worklog";
-  const store = new WorklogStore(join30(ctx.dataDir, "worklog"));
+  const store = new WorklogStore(join31(ctx.dataDir, "worklog"));
   const existing = await store.get(date);
   if (existing) {
     return { path: existing.path, date: existing.date, keyword: existing.keyword, created: false };