@vortex-os/base 0.7.0 → 0.7.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 vortex-os-project
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 vortex-os-project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -40,7 +40,7 @@ npx vortex init                                          # scaffold the instance
 
 - the per-agent files — `AGENTS.md` (the thin Codex-CLI entry, auto-loaded by Codex and other `AGENTS.md`-aware tools) plus thin routers `CLAUDE.md`, `GEMINI.md`, `.cursorrules`, all pointing at `AI-RULES.md` (the single source of truth for shared rules) — so any agent host finds VortEX's behavior contract (these are generic templates you personalize over time);
 - the `data/` skeleton (`_memory/`, `worklog/`, `decision-log/`, `runbooks/`, `hubs/`, `inbox/`), your user-profile memory, and today's first worklog;
-- `.claude/settings.json` with the session hooks wired as `npx --no-install -p @vortex-os/base vortex session-start` / `… session-end` (the `--no-install` flag and explicit `-p` package make the auto-firing hook fail closed rather than install or shadow), plus the agent-mediated slash-commands in `.claude/commands/`;
+- `.claude/settings.json` with the session hooks wired as `npx --no-install vortex session-start` / `… session-end` (the `--no-install` flag makes the auto-firing hook fail closed rather than install on a cache miss; resolving the bare `vortex` bin — local `node_modules/.bin` first, then PATH — lets the `global-setup` hook fire from any folder, not only where a local install exists), plus the agent-mediated slash-commands in `.claude/commands/`;
 - `.agent/vortex.json` (auto-record config) and a minimal `package.json` with `"type":"module"` if none exists.
 
 `vortex import --from <folder>` brings an existing notes folder in — markdown is auto-classified (worklog / decision-log / …) and **attachments (PDFs, images, …) are copied byte-for-byte** into the same layout; credential files (`*.key`, `.env`, `secrets/` …) and oversized files are skipped and reported. As the framework improves, `vortex update` refreshes the installed templates **without ever overwriting a file you edited** (your edit is parked at `<file>.new`); `vortex doctor` checks instance health.

package/bin/vortex.mjs

@@ -1,17 +1,17 @@
-#!/usr/bin/env node
-// `vortex` — the CLI shipped by @vortex-os/base.
-//
-// `npm i @vortex-os/base` puts this on the instance's path (node_modules/.bin),
-// so `npx vortex init` / `npx vortex session-start` / `npx vortex --list` work
-// without any monorepo checkout. It is a thin wrapper over the canonical
-// dispatch (`runVortexCli`), which is bundled into base from
-// `@vortex-os/session-rituals` — exactly one source of truth for the CLI logic.
-//
-// The dispatch lazily probes the optional `@vortex-os/memory-extended` add-on:
-// when it is installed alongside base, `/recall` lights up; on a lean base-only
-// install the probe is caught and the CLI runs with every other command.
-
-import { sessionRituals } from "../dist/index.js";
-
-const code = await sessionRituals.runVortexCli(process.argv.slice(2));
-process.exitCode = code;
+#!/usr/bin/env node
+// `vortex` — the CLI shipped by @vortex-os/base.
+//
+// `npm i @vortex-os/base` puts this on the instance's path (node_modules/.bin),
+// so `npx vortex init` / `npx vortex session-start` / `npx vortex --list` work
+// without any monorepo checkout. It is a thin wrapper over the canonical
+// dispatch (`runVortexCli`), which is bundled into base from
+// `@vortex-os/session-rituals` — exactly one source of truth for the CLI logic.
+//
+// The dispatch lazily probes the optional `@vortex-os/memory-extended` add-on:
+// when it is installed alongside base, `/recall` lights up; on a lean base-only
+// install the probe is caught and the CLI runs with every other command.
+
+import { sessionRituals } from "../dist/index.js";
+
+const code = await sessionRituals.runVortexCli(process.argv.slice(2));
+process.exitCode = code;

package/dist/{catch-up-GDDKPZHJ.js → catch-up-KIHTAUPX.js}

@@ -1,8 +1,8 @@
 import {
   catchUpSessions
-} from "./chunk-3L5DLEGP.js";
+} from "./chunk-7SNLVGBO.js";
 import "./chunk-PZ5AY32C.js";
 export {
   catchUpSessions
 };
-//# sourceMappingURL=catch-up-GDDKPZHJ.js.map
+//# sourceMappingURL=catch-up-KIHTAUPX.js.map

package/dist/{chunk-3L5DLEGP.js → chunk-7SNLVGBO.js}

@@ -26,4 +26,4 @@ async function catchUpSessions(ctx, opts) {
 export {
   catchUpSessions
 };
-//# sourceMappingURL=chunk-3L5DLEGP.js.map
+//# sourceMappingURL=chunk-7SNLVGBO.js.map

package/dist/chunk-7SNLVGBO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../plugins/session-rituals/src/catch-up.ts"],"sourcesContent":["import type { ModuleContext } from \"@vortex-os/core\";\r\n// Type-only — erased at compile time, so importing it does NOT pull the\r\n// `@vortex-os/memory-extended` add-on (or its native sqlite/level deps) into\r\n// the module graph of consumers that only need the types. The runtime engine\r\n// is loaded lazily inside the function body via `await import(...)`.\r\nimport type { sessionArchive } from \"@vortex-os/memory-extended\";\r\n\r\n/**\r\n * Start-of-session \"catch-up\": fold conversation transcripts into the local\r\n * search archive without the user ever having to wrap up a session.\r\n *\r\n * Two sources, one pass:\r\n *  - **local (a)** — this machine's own transcripts that are not archived yet,\r\n *    read from every detected agent host's transcript store (Claude Code,\r\n *    Codex, Gemini) and scoped to the current project. Because all hosts are\r\n *    swept on every start, a single Claude Code session-start also folds in the\r\n *    Codex/Gemini sessions you ran in the same project, into one archive.\r\n *  - **pulled (b)** — transcripts created on another machine that arrived as\r\n *    normalized text via git sync. Their text is present but this machine's\r\n *    DB (local, derived, gitignored) has never indexed them.\r\n *\r\n * Text only — vectorization is deferred to recall/rebuild so session start\r\n * stays fast. The whole step is gated by `autoRecord.archive` at the call site\r\n * and is best-effort: callers should treat a thrown archive backend (e.g. the\r\n * native sqlite module not built) as \"skip\", never as a fatal start error.\r\n */\r\nexport interface CatchUpResult {\r\n  /** Local transcripts newly archived this run (source a). */\r\n  readonly ingestedLocal: number;\r\n  /** Normalized transcripts from another machine newly indexed (source b). */\r\n  readonly indexedPulled: number;\r\n  /** Per-session ingest errors (source a). */\r\n  readonly errors: number;\r\n}\r\n\r\nexport interface CatchUpOptions {\r\n  /** Restrict local ingest to one project's transcripts. Default: `ctx.repoRoot`. */\r\n  readonly cwd?: string;\r\n  /**\r\n   * Transcript adapters for local ingest. Default: all CLI hosts — Claude Code,\r\n   * Codex, and Gemini. Each adapter's `detect()` returns false when its host is\r\n   * absent, so registering all three is ~free on a machine that only uses one.\r\n   * (Claude Desktop is opt-in — it needs the `classic-level` dependency — so it\r\n   * is not in the default set; a caller can add it.) Tests inject fakes (or a\r\n   * sandbox `env.home`) so the scan never touches the real home directory.\r\n   */\r\n  readonly adapters?: sessionArchive.IngestParams[\"adapters\"];\r\n  /** Adapter environment override (e.g. a sandbox HOME). Tests use this. */\r\n  readonly env?: sessionArchive.IngestParams[\"env\"];\r\n}\r\n\r\nexport async function catchUpSessions(\r\n  ctx: ModuleContext,\r\n  opts?: CatchUpOptions,\r\n): Promise<CatchUpResult> {\r\n  // Lazy-load the optional add-on. Base ships without `memory-extended`; this\r\n  // import resolves only when the add-on is installed alongside it. The call\r\n  // site already gates this step on `autoRecord.archive` and treats a thrown\r\n  // backend as \"skip\", so a missing add-on surfaces as a normal load error\r\n  // the caller can catch.\r\n  const { sessionArchive } = await import(\"@vortex-os/memory-extended\");\r\n\r\n  const dataDir = ctx.dataDir;\r\n  const cwd = opts?.cwd ?? ctx.repoRoot;\r\n  const adapters = opts?.adapters ?? [\r\n    sessionArchive.claudeCodeAdapter,\r\n    sessionArchive.codexAdapter,\r\n    sessionArchive.geminiAdapter,\r\n  ];\r\n\r\n  // (a) Ingest this machine's not-yet-archived transcripts for the current\r\n  // project. Writes the normalized copy into the archive (which git syncs) and\r\n  // a local DB row. Text only — no vectorization here.\r\n  const ingestResult = await sessionArchive.ingest({ adapters, dataDir, cwd, env: opts?.env });\r\n\r\n  // (b) Index normalized transcripts that arrived from another machine via git\r\n  // pull — their text is on disk but this machine's DB has no row yet.\r\n  const store = new sessionArchive.SessionArchiveStore(dataDir);\r\n  let indexedPulled = 0;\r\n  try {\r\n    indexedPulled = store.reindexFromNormalized().indexed;\r\n  } finally {\r\n    store.close();\r\n  }\r\n\r\n  return {\r\n    ingestedLocal: ingestResult.sessionsIngested,\r\n    indexedPulled,\r\n    errors: ingestResult.errors.length,\r\n  };\r\n}\r\n"],"mappings":";AAmDA,eAAsB,gBACpB,KACA,MAAqB;AAOrB,QAAM,EAAE,eAAc,IAAK,MAAM,OAAO,4BAA4B;AAEpE,QAAM,UAAU,IAAI;AACpB,QAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAM,WAAW,MAAM,YAAY;IACjC,eAAe;IACf,eAAe;IACf,eAAe;;AAMjB,QAAM,eAAe,MAAM,eAAe,OAAO,EAAE,UAAU,SAAS,KAAK,KAAK,MAAM,IAAG,CAAE;AAI3F,QAAM,QAAQ,IAAI,eAAe,oBAAoB,OAAO;AAC5D,MAAI,gBAAgB;AACpB,MAAI;AACF,oBAAgB,MAAM,sBAAqB,EAAG;EAChD;AACE,UAAM,MAAK;EACb;AAEA,SAAO;IACL,eAAe,aAAa;IAC5B;IACA,QAAQ,aAAa,OAAO;;AAEhC;","names":[]}

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;
@@ -2669,8 +2684,8 @@ declare function collectCarryover(repoRoot: string): {
  * file read/write around them. Keeping them pure makes the merge unit-testable
  * and the "writes only what's missing" guarantee verifiable.
  */
-declare const SESSION_START_COMMAND = "npx --no-install -p @vortex-os/base vortex session-start || exit 0";
-declare const SESSION_END_COMMAND = "npx --no-install -p @vortex-os/base vortex session-end || exit 0";
+declare const SESSION_START_COMMAND = "npx --no-install vortex session-start || exit 0";
+declare const SESSION_END_COMMAND = "npx --no-install vortex session-end || exit 0";
 interface HookCommand {
     readonly type: "command";
     readonly command: string;
@@ -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

@@ -1,6 +1,6 @@
 import {
   catchUpSessions
-} from "./chunk-3L5DLEGP.js";
+} from "./chunk-7SNLVGBO.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.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
@@ -4778,11 +4780,17 @@ import { basename as basename7, dirname as dirname5, extname as extname11, join
 import { fileURLToPath } from "url";
 
 // ../plugins/session-rituals/dist/ensure-hooks.js
-var SESSION_START_COMMAND = "npx --no-install -p @vortex-os/base vortex session-start || exit 0";
-var SESSION_END_COMMAND = "npx --no-install -p @vortex-os/base vortex session-end || exit 0";
+var SESSION_START_COMMAND = "npx --no-install vortex session-start || exit 0";
+var SESSION_END_COMMAND = "npx --no-install vortex session-end || exit 0";
 var LEGACY_COMMANDS = {
-  SessionStart: "npx --no-install -p @vortex-os/base vortex session-start",
-  SessionEnd: "npx --no-install -p @vortex-os/base vortex session-end"
+  SessionStart: [
+    "npx --no-install -p @vortex-os/base vortex session-start || exit 0",
+    "npx --no-install -p @vortex-os/base vortex session-start"
+  ],
+  SessionEnd: [
+    "npx --no-install -p @vortex-os/base vortex session-end || exit 0",
+    "npx --no-install -p @vortex-os/base vortex session-end"
+  ]
 };
 function parseSettings(text) {
   const trimmed = (text ?? "").trim();
@@ -4812,7 +4820,7 @@ function ensureVortexHooks(existing) {
     for (const g of src) {
       const hookList = [];
       for (const h of g.hooks ?? []) {
-        const migrated = h.command === legacy;
+        const migrated = legacy.includes(h.command);
         const cmd = migrated ? command : h.command;
         if (cmd === command) {
           if (kept) {
@@ -5005,6 +5013,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 +5053,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 +5633,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 +6093,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 +7580,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 +7842,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 +7874,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(", ")})` : "";
@@ -8558,7 +8653,7 @@ async function runVectorizeSetup(repoRoot, out, err) {
       return;
     }
     cleanTmp();
-    const { vectorizeIndex } = await import("./vectorize-PN4Y7XMO.js");
+    const { vectorizeIndex } = await import("./vectorize-RBDBTSTW.js");
     const result = await vectorizeIndex(ctx, { dbPath: tmpDb, allowDownload: true });
     const sqliteSpecifier = "better-sqlite3";
     const mod = await import(sqliteSpecifier);
@@ -8599,16 +8694,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 +8712,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 {
@@ -8629,7 +8725,7 @@ async function runSessionStart(repoRoot, out) {
   let catchUp = null;
   if (config.autoRecord.archive) {
     try {
-      const { catchUpSessions: catchUpSessions2 } = await import("./catch-up-GDDKPZHJ.js");
+      const { catchUpSessions: catchUpSessions2 } = await import("./catch-up-KIHTAUPX.js");
       catchUp = await catchUpSessions2(ctx);
     } catch {
     }
@@ -8648,7 +8744,7 @@ async function runSessionStart(repoRoot, out) {
     });
     if (action === "inline") {
       try {
-        const { vectorizeIndex } = await import("./vectorize-PN4Y7XMO.js");
+        const { vectorizeIndex } = await import("./vectorize-RBDBTSTW.js");
         vectorized = await vectorizeIndex(ctx);
       } catch {
       }
@@ -8688,7 +8784,7 @@ async function runSessionStart(repoRoot, out) {
   } catch {
   }
   out(renderSessionStartReport(report, {
-    git,
+    git: git2,
     missingWorklogDays,
     catchUp: catchUp ?? void 0,
     vectorized: vectorized ?? void 0,
@@ -8712,7 +8808,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 +8836,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;