@vortex-os/base 0.7.0 → 0.7.1

package/dist/index.d.ts

@@ -131,6 +131,21 @@ interface AutoRecordConfig {
      * `vectorize` is off, nothing runs regardless.
      */
     readonly vectorizeAutoDownload: boolean;
+    /**
+     * Auto-commit framework bookkeeping. When `vortex update` refreshes
+     * framework-owned files it also rewrites the ownership manifest
+     * (`data/.vortex/ownership.json`); on its own that leaves an uncommitted
+     * "trail" that the next session reports as carried-over work, even though it
+     * is plumbing the user never touched. With this on, `vortex update` commits
+     * exactly the framework files it changed (the manifest + the templates it
+     * refreshed) — and nothing else in the working tree — so an update leaves a
+     * clean tree. Best-effort: a non-git folder, or any git failure, is a silent
+     * no-op (the command still succeeds). On by default; set `false` to keep the
+     * commit manual (e.g. you prefer to review and commit framework changes
+     * yourself). Conflicts (`<file>.new`) are never auto-committed — those still
+     * wait for you to merge.
+     */
+    readonly commitFrameworkChanges: boolean;
 }
 /**
  * One environment label plus the signal that selects it. Rules are evaluated
@@ -2653,7 +2668,7 @@ declare function detectInterruptedGitOp(repoRoot: string): string | null;
  * null when there is nothing to report (clean tree / not a git repo). Exported
  * for tests. (decision-log 2026-06-04-session-recovery-two-tier.)
  */
-declare function collectCarryover(repoRoot: string): {
+declare function collectCarryover(repoRoot: string, ignore?: (repoRelPosixPath: string) => boolean): {
     uncommitted: number;
     interrupted: string | null;
 } | null;
@@ -3084,8 +3099,14 @@ declare function detectWorklogGaps(commitDays: readonly string[], presentDates:
  * non-empty line. Pure: the hook runs git; this turns its stdout into the
  * Tier-1 carryover count. (`--porcelain` emits exactly one line per changed
  * path, including untracked, so a line count is the change count.)
+ *
+ * `ignore`, when given, drops paths it returns true for from the count — used to
+ * exclude framework-generated bookkeeping (the ownership manifest under
+ * `data/.vortex/`), which is auto-maintained plumbing the user never edits, so
+ * it must not be reported as carried-over WIP. A line whose path can't be parsed
+ * is counted (fail toward surfacing, not hiding).
  */
-declare function countUncommitted(porcelain: string): number;
+declare function countUncommitted(porcelain: string, ignore?: (repoRelPosixPath: string) => boolean): number;
 /**
  * Render a session-start report as a compact markdown block for a host hook
  * to inject as session context. A pull conflict and any worklog gaps are

package/dist/index.js

@@ -105,7 +105,7 @@ function moduleDir(ctx, moduleName) {
 import { existsSync, readFileSync } from "fs";
 import { join as join2 } from "path";
 var DEFAULT_CONFIG = {
-  autoRecord: { sessionStart: true, worklog: true, decision: true, ambientRecall: true, archive: true, vectorize: true, vectorizeAutoDownload: true },
+  autoRecord: { sessionStart: true, worklog: true, decision: true, ambientRecall: true, archive: true, vectorize: true, vectorizeAutoDownload: true, commitFrameworkChanges: true },
   updates: { check: "session" },
   environments: []
 };
@@ -147,11 +147,13 @@ function loadVortexConfig(ctx) {
     const check = rawCheck === void 0 ? "session" : typeof rawCheck === "string" && rawCheck.trim().toLowerCase() === "session" ? "session" : "off";
     const rawAuto = raw.autoRecord && typeof raw.autoRecord === "object" && !Array.isArray(raw.autoRecord) ? raw.autoRecord : {};
     const vectorizeAutoDownload = rawAuto.vectorizeAutoDownload === void 0 ? true : rawAuto.vectorizeAutoDownload === true;
+    const commitFrameworkChanges = rawAuto.commitFrameworkChanges === void 0 ? true : rawAuto.commitFrameworkChanges === true;
     return {
       autoRecord: {
         ...DEFAULT_CONFIG.autoRecord,
         ...raw.autoRecord ?? {},
-        vectorizeAutoDownload
+        vectorizeAutoDownload,
+        commitFrameworkChanges
       },
       updates: { check },
       environments
@@ -5005,6 +5007,21 @@ var MANIFEST_NAME = "manifest.json";
 function ownershipManifestPath(ctx) {
   return join24(ctx.dataDir, ".vortex", "ownership.json");
 }
+function frameworkBookkeepingPrefix(ctx) {
+  return toPosix(relative4(ctx.repoRoot, join24(ctx.dataDir, ".vortex"))) + "/";
+}
+function committableUpdatePaths(ctx, result) {
+  const out = /* @__PURE__ */ new Set();
+  for (const a of result.actions) {
+    if (a.error)
+      continue;
+    if (a.action === "replace" || a.action === "restore" || a.action === "install" || a.action === "adopt") {
+      out.add(a.path);
+    }
+  }
+  out.add(toPosix(relative4(ctx.repoRoot, ownershipManifestPath(ctx))));
+  return [...out];
+}
 function toPosix(p) {
   return p.split(sep4).join("/");
 }
@@ -5030,6 +5047,8 @@ function templateDestRelPath(templateRelPath) {
   const parts = templateRelPath.split("/");
   if (parts.length < 2)
     return null;
+  if (parts.some((p) => p === ".." || p === "."))
+    return null;
   const [top, ...rest] = parts;
   const tail = rest.join("/");
   if (top === "routers")
@@ -5608,6 +5627,41 @@ function buildNextActions(status, summary, actions, dryRun, fromVersion, toVersi
   return out;
 }
 
+// ../plugins/session-rituals/dist/git-commit.js
+import { execFileSync } from "child_process";
+function git(repoRoot, args) {
+  return execFileSync("git", [...args], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    // GIT_LITERAL_PATHSPECS=1 makes every `-- <path>` a LITERAL filename, not a
+    // pathspec: it disables glob magic (`*` `?` `[…]`) and `:(…)` prefixes. So
+    // even a path carrying those bytes (e.g. from a malformed template index)
+    // can only ever match the exact file named — never a wider set.
+    env: { ...process.env, GIT_LITERAL_PATHSPECS: "1" },
+    // Suppress git's own stderr; the caller treats a non-zero exit as "no commit".
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+}
+function commitFrameworkPaths(repoRoot, paths, message) {
+  if (paths.length === 0)
+    return { committed: false, reason: "no-paths" };
+  try {
+    git(repoRoot, ["rev-parse", "--git-dir"]);
+  } catch {
+    return { committed: false, reason: "not-a-git-repo" };
+  }
+  try {
+    const status = git(repoRoot, ["status", "--porcelain", "--", ...paths]).trim();
+    if (!status)
+      return { committed: false, reason: "nothing-to-commit" };
+    git(repoRoot, ["add", "--", ...paths]);
+    git(repoRoot, ["commit", "-m", message, "--", ...paths]);
+    return { committed: true };
+  } catch (e) {
+    return { committed: false, reason: "git-error", error: e?.message ?? String(e) };
+  }
+}
+
 // ../plugins/session-rituals/dist/commands/vortex.js
 var PLANNED_SUBS = [];
 var vortexCommand = {
@@ -6033,10 +6087,25 @@ async function runUpdate(input, tokens) {
   const dryRun = tokens.includes("--dry-run");
   const adopt = parseAdoptArgs(tokens);
   const templatesDir = resolveTemplatesDir();
-  return runTemplatesUpdate(input.context, templatesDir, {
+  const result = await runTemplatesUpdate(input.context, templatesDir, {
     dryRun,
     adopt: adopt.size > 0 ? adopt : void 0
   });
+  if (dryRun || result.status === "no-manifest" || result.status === "no-templates")
+    return result;
+  if (!loadVortexConfig(input.context).autoRecord.commitFrameworkChanges)
+    return result;
+  const paths = committableUpdatePaths(input.context, result);
+  const commit = commitFrameworkPaths(input.context.repoRoot, paths, `chore(vortex): sync framework templates to base ${result.toVersion ?? "?"}`);
+  if (!commit.committed)
+    return result;
+  return {
+    ...result,
+    nextActions: [
+      ...result.nextActions,
+      `Committed the framework changes so nothing is left uncommitted (autoRecord.commitFrameworkChanges; set false to commit these yourself).`
+    ]
+  };
 }
 function parseAdoptArgs(tokens) {
   const adopt = /* @__PURE__ */ new Set();
@@ -7505,7 +7574,7 @@ function createRitualRegistry(options) {
 }
 
 // ../plugins/session-rituals/dist/cli-dispatch.js
-import { execFileSync, spawn as spawn2 } from "child_process";
+import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
 import { existsSync as existsSync15, readFileSync as readFileSync4, mkdirSync, openSync, writeSync, closeSync, linkSync, rmSync, statSync } from "fs";
 import { createRequire } from "module";
 import { hostname } from "os";
@@ -7767,8 +7836,28 @@ function detectWorklogGaps(commitDays, presentDates) {
   const present = new Set(presentDates);
   return [...new Set(commitDays)].filter((d2) => d2 && !present.has(d2)).sort();
 }
-function countUncommitted(porcelain) {
-  return porcelain.split(/\r?\n/).filter((l3) => l3.trim().length > 0).length;
+function porcelainPath(line) {
+  const body = line.slice(3);
+  if (!body)
+    return null;
+  const arrow = body.indexOf(" -> ");
+  const raw = (arrow >= 0 ? body.slice(arrow + 4) : body).trim();
+  if (raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"'))
+    return raw.slice(1, -1);
+  return raw;
+}
+function countUncommitted(porcelain, ignore) {
+  const lines = porcelain.split(/\r?\n/).filter((l3) => l3.trim().length > 0);
+  if (!ignore)
+    return lines.length;
+  let n = 0;
+  for (const l3 of lines) {
+    const p = porcelainPath(l3);
+    if (p && ignore(p))
+      continue;
+    n++;
+  }
+  return n;
 }
 function renderSessionStartReport(report, extras) {
   const lines = [
@@ -7779,9 +7868,9 @@ function renderSessionStartReport(report, extras) {
   ];
   const env = report.environment ? ` \xB7 env: ${envLabel(report.environment)}` : "";
   lines.push(`- time: ${report.localTime ?? report.time}${env}`);
-  const git = extras?.git;
-  if (git?.ran) {
-    lines.push(git.conflict ? `- git: \u26A0\uFE0F ${git.summary} \u2014 resolve manually (not auto-resolved)` : `- git: ${git.summary}`);
+  const git2 = extras?.git;
+  if (git2?.ran) {
+    lines.push(git2.conflict ? `- git: \u26A0\uFE0F ${git2.summary} \u2014 resolve manually (not auto-resolved)` : `- git: ${git2.summary}`);
   }
   const countStr = COUNTED_DIRS2.map((d2) => `${d2} ${report.counts[d2] ?? 0}`).join(" \xB7 ");
   const miss = report.missing.length ? ` (missing: ${report.missing.join(", ")})` : "";
@@ -8599,16 +8688,16 @@ async function runSessionStart(repoRoot, out) {
   if (!config.autoRecord.sessionStart)
     return;
   const environment = resolveSessionEnvironment(ctx, config);
-  let git = null;
+  let git2 = null;
   try {
     const remotes = gitOut(repoRoot, ["remote"]).trim();
     if (remotes) {
       try {
         const pulled = gitOut(repoRoot, ["pull", "--ff-only"]);
         const lastLine = pulled.trim().split(/\r?\n/).pop() || "up to date";
-        git = { ran: true, summary: lastLine, conflict: false };
+        git2 = { ran: true, summary: lastLine, conflict: false };
       } catch {
-        git = {
+        git2 = {
           ran: true,
           summary: "fast-forward pull failed (diverged or dirty tree)",
           conflict: true
@@ -8617,7 +8706,8 @@ async function runSessionStart(repoRoot, out) {
     }
   } catch {
   }
-  const carryover = collectCarryover(repoRoot);
+  const bookkeepingPrefix = frameworkBookkeepingPrefix(ctx);
+  const carryover = collectCarryover(repoRoot, (p) => p.startsWith(bookkeepingPrefix));
   const report = await collectSessionStartReport(ctx, { environment });
   let missingWorklogDays = [];
   try {
@@ -8688,7 +8778,7 @@ async function runSessionStart(repoRoot, out) {
   } catch {
   }
   out(renderSessionStartReport(report, {
-    git,
+    git: git2,
     missingWorklogDays,
     catchUp: catchUp ?? void 0,
     vectorized: vectorized ?? void 0,
@@ -8712,7 +8802,7 @@ async function runSessionEnd(repoRoot, out) {
   }
 }
 function gitOut(cwd, gitArgs) {
-  return execFileSync("git", [...gitArgs], {
+  return execFileSync2("git", [...gitArgs], {
     cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"]
@@ -8740,11 +8830,11 @@ function detectInterruptedGitOp(repoRoot) {
   }
   return null;
 }
-function collectCarryover(repoRoot) {
+function collectCarryover(repoRoot, ignore) {
   const interrupted = detectInterruptedGitOp(repoRoot);
   let uncommitted = 0;
   try {
-    uncommitted = countUncommitted(gitOut(repoRoot, ["status", "--porcelain"]));
+    uncommitted = countUncommitted(gitOut(repoRoot, ["status", "--porcelain"]), ignore);
   } catch {
   }
   return uncommitted > 0 || interrupted ? { uncommitted, interrupted } : null;