@titan-design/active-work 0.6.0 → 0.7.0

package/dist/cli.js

@@ -13,6 +13,7 @@ import {
   NotFoundError,
   NoteFrontmatterSchema,
   NoteKindSchema,
+  SCHEMA_VERSION,
   SessionFrontmatterSchema,
   SessionIdSchema,
   SessionResolveSchema,
@@ -21,11 +22,13 @@ import {
   TaskSeqSchema,
   UsageError,
   ValidationError,
+  WORKSPACE_SPAN_SOURCE_BASE,
   WorktreeEntrySchema,
   assembleBootstrap,
   atomicWrite,
   coerceDates,
   color,
+  defaultGraphPath,
   defineCommand,
   deriveOpenLoops,
   deriveOpenLoopsFrom,
@@ -48,6 +51,8 @@ import {
   loadNotesFromDir,
   loadSessionsFromDir,
   nowIso,
+  openGraph,
+  openGraphReadOnly,
   open_default,
   probeHealth,
   readArtifactHashes,
@@ -76,7 +81,7 @@ import {
   writeFrontmatter,
   writeNoteFile,
   writeYaml
-} from "./chunk-RLSQSE7I.js";
+} from "./chunk-KAR6NOS2.js";
 
 // src/cli.ts
 import { Command, CommanderError } from "commander";
@@ -1517,8 +1522,8 @@ var NO_UPSTREAM = { ahead: null, behind: null };
 function shortBranch(ref) {
   return ref.replace(/^refs\/heads\//, "");
 }
-function emptyWorktree(path68) {
-  return { path: path68, head: null, branch: null, detached: false, bare: false };
+function emptyWorktree(path67) {
+  return { path: path67, head: null, branch: null, detached: false, bare: false };
 }
 function parseWorktreePorcelain(stdout) {
   const out = [];
@@ -3855,144 +3860,6 @@ import { z as z33 } from "zod";
 // src/search/index.ts
 import { createRetrievalEngine, ftsRetriever } from "@titan-design/retrieval";
 
-// src/session-index/graph.ts
-import Database from "better-sqlite3";
-import { openSessionGraph } from "@titan-design/session-graph";
-import { runMigrations, WatermarkTable } from "@titan-design/store-sqlite";
-import path34 from "path";
-
-// src/workspace-index/schema.ts
-import { kitDdl } from "@titan-design/store-sqlite";
-import { MIGRATIONS as SESSION_GRAPH_MIGRATIONS } from "@titan-design/session-graph";
-var WORKSPACE_KIT = {
-  watermark: "workspace_file",
-  edge: "edge",
-  spanFts: "search"
-};
-var WORKSPACE_SPAN_SOURCE_BASE = 1e9;
-var DOMAIN_DDL = `
-  CREATE TABLE IF NOT EXISTS initiative (
-    path            TEXT PRIMARY KEY,
-    initiative_ref  TEXT NOT NULL UNIQUE,
-    slug            TEXT NOT NULL,
-    title           TEXT,
-    state           TEXT,
-    rank            INTEGER,
-    ship_target     TEXT,
-    owner           TEXT,
-    task_prefix     TEXT,
-    updated         TEXT
-  );
-
-  CREATE TABLE IF NOT EXISTS note (
-    path        TEXT PRIMARY KEY,
-    note_ref    TEXT NOT NULL UNIQUE,
-    initiative  TEXT NOT NULL,
-    filename    TEXT NOT NULL,
-    kind        TEXT NOT NULL,
-    title       TEXT NOT NULL,
-    created     TEXT,
-    tags        TEXT,
-    hits        INTEGER NOT NULL DEFAULT 0,
-    promoted_at TEXT
-  );
-  CREATE INDEX IF NOT EXISTS idx_note_initiative ON note(initiative);
-
-  CREATE TABLE IF NOT EXISTS workspace_task (
-    path        TEXT PRIMARY KEY,
-    task_ref    TEXT NOT NULL,
-    initiative  TEXT NOT NULL,
-    task_id     TEXT NOT NULL,
-    title       TEXT NOT NULL,
-    status      TEXT NOT NULL,
-    priority    INTEGER,
-    severity    TEXT,
-    estimate    REAL,
-    tags        TEXT,
-    created     TEXT,
-    updated     TEXT,
-    done_at     TEXT
-  );
-  CREATE INDEX IF NOT EXISTS idx_workspace_task_ref ON workspace_task(task_ref);
-
-  CREATE TABLE IF NOT EXISTS session_record (
-    path              TEXT PRIMARY KEY,
-    session_ref       TEXT NOT NULL,
-    initiative        TEXT NOT NULL,
-    session_id        TEXT NOT NULL,
-    started           TEXT,
-    ended             TEXT,
-    track             TEXT,
-    parent_session_id TEXT
-  );
-  CREATE INDEX IF NOT EXISTS idx_session_record_ref ON session_record(session_ref);
-
-  CREATE TABLE IF NOT EXISTS source (
-    path        TEXT PRIMARY KEY,
-    source_ref  TEXT NOT NULL UNIQUE,
-    initiative  TEXT NOT NULL,
-    title       TEXT,
-    kind        TEXT,
-    added       TEXT
-  );
-`;
-function nextVersion(chain) {
-  return (chain[chain.length - 1]?.version ?? 0) + 1;
-}
-var SPAN_SOURCE_INDEX = `
-  CREATE INDEX IF NOT EXISTS idx_search_span_source ON search_span(source_id);
-`;
-var WORKSPACE_MIGRATIONS = [
-  {
-    version: nextVersion(SESSION_GRAPH_MIGRATIONS),
-    name: "workspace index tables",
-    up: (db) => {
-      db.exec(kitDdl({ watermark: WORKSPACE_KIT.watermark }));
-      db.exec(DOMAIN_DDL);
-      db.exec(SPAN_SOURCE_INDEX);
-    }
-  }
-];
-var PRESERVE_DDL = `
-  CREATE TABLE IF NOT EXISTS preserved_row (
-    table_name   TEXT NOT NULL,
-    identity     TEXT NOT NULL,
-    row_key      TEXT NOT NULL,
-    payload      TEXT NOT NULL,
-    origin       TEXT NOT NULL,
-    mode         TEXT NOT NULL DEFAULT 'insert',
-    preserved_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
-    PRIMARY KEY (table_name, row_key)
-  );
-`;
-var PRESERVE_MIGRATION = {
-  version: nextVersion([...SESSION_GRAPH_MIGRATIONS, ...WORKSPACE_MIGRATIONS]),
-  name: "preserved rows",
-  up: (db) => db.exec(PRESERVE_DDL)
-};
-var MIGRATIONS = [
-  ...SESSION_GRAPH_MIGRATIONS,
-  ...WORKSPACE_MIGRATIONS,
-  PRESERVE_MIGRATION
-];
-
-// src/session-index/graph.ts
-var SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
-function defaultGraphPath() {
-  return path34.join(getMinerRoot(), "graph.sqlite3");
-}
-function openGraph(dbPath = defaultGraphPath()) {
-  const graph = openSessionGraph(dbPath);
-  runMigrations(graph.db, MIGRATIONS);
-  return {
-    ...graph,
-    workspaceFiles: new WatermarkTable(graph.db, { name: WORKSPACE_KIT.watermark })
-  };
-}
-function openGraphReadOnly(dbPath = defaultGraphPath()) {
-  return new Database(dbPath, { readonly: true });
-}
-
 // src/search/classes.ts
 var TRANSCRIPT_FIELDS = ["prompt", "assistant_response", "tool_input", "tool_result"];
 var SEARCH_CLASSES = [
@@ -4028,11 +3895,11 @@ function classOf(ref, field) {
 }
 
 // src/search/resolve.ts
-import path36 from "path";
+import path35 from "path";
 import { readLocatorText } from "@titan-design/locator";
 
 // src/workspace-index/refs.ts
-import path35 from "path";
+import path34 from "path";
 import { refKind } from "@titan-design/store-sqlite";
 var initiativeRef = refKind("initiative");
 var noteRef = refKind("note");
@@ -4040,10 +3907,10 @@ var taskRef = refKind("task");
 var sessionRef = refKind("session");
 var sourceRef = refKind("source");
 function toRelative(activeRoot, absolutePath) {
-  return path35.relative(activeRoot, absolutePath).split(path35.sep).join("/");
+  return path34.relative(activeRoot, absolutePath).split(path34.sep).join("/");
 }
 function toAbsolute(activeRoot, relativePath) {
-  return path35.join(activeRoot, ...relativePath.split("/"));
+  return path34.join(activeRoot, ...relativePath.split("/"));
 }
 
 // src/search/resolve.ts
@@ -4071,7 +3938,7 @@ function fileForSource(graph, sourceId, activeRoot) {
   }
   const row = graph.db.prepare("SELECT source_key FROM transcript WHERE source_id = ?").get(sourceId);
   if (!row) return null;
-  return row.source_key.startsWith("~") ? path36.join(process.env.HOME ?? "", row.source_key.slice(1)) : row.source_key;
+  return row.source_key.startsWith("~") ? path35.join(process.env.HOME ?? "", row.source_key.slice(1)) : row.source_key;
 }
 function oneLine(text, width) {
   const flat = text.replace(/\s+/g, " ").trim();
@@ -4304,7 +4171,7 @@ var list_default = defineCommand({
 });
 
 // src/commands/worktree-set.ts
-import path37 from "path";
+import path36 from "path";
 import { z as z35 } from "zod";
 var argsSchema3 = z35.object({
   slug: z35.string().min(1),
@@ -4321,7 +4188,7 @@ var resultSchema3 = z35.object({
   promoted: z35.boolean()
 });
 var DEFAULT_LABEL = "main";
-var samePath = (a, b) => path37.resolve(expandTilde(a)) === path37.resolve(expandTilde(b));
+var samePath = (a, b) => path36.resolve(expandTilde(a)) === path36.resolve(expandTilde(b));
 var worktree_set_default = defineCommand({
   name: "worktree.set",
   description: "Add or update a registered worktree on an existing initiative. A lone worktree is made default automatically; use --default to promote an added one. Registered worktrees live in artifacts.yml alongside the ones wrap sweeps, and are what `aw` resolves a cwd against.",
@@ -4343,8 +4210,8 @@ var worktree_set_default = defineCommand({
   },
   async run(args) {
     const label = args.label ?? DEFAULT_LABEL;
-    const initiativeDir = path37.join(getActiveRoot(), args.slug);
-    const briefPath = path37.join(initiativeDir, "brief.md");
+    const initiativeDir = path36.join(getActiveRoot(), args.slug);
+    const briefPath = path36.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(args.slug), async () => {
       let frontmatter2;
       let body;
@@ -4398,7 +4265,7 @@ var worktree_set_default = defineCommand({
 });
 
 // src/commands/worktree-set-default.ts
-import path38 from "path";
+import path37 from "path";
 import { z as z36 } from "zod";
 var argsSchema4 = z36.object({
   slug: z36.string().min(1),
@@ -4417,8 +4284,8 @@ var worktree_set_default_default = defineCommand({
     positional: ["slug", "label"]
   },
   async run({ slug, label }) {
-    const initiativeDir = path38.join(getActiveRoot(), slug);
-    const briefPath = path38.join(initiativeDir, "brief.md");
+    const initiativeDir = path37.join(getActiveRoot(), slug);
+    const briefPath = path37.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(slug), async () => {
       let frontmatter2;
       let body;
@@ -4453,7 +4320,7 @@ import { z as z37 } from "zod";
 
 // src/discover/index.ts
 import { promises as fs29 } from "fs";
-import path42 from "path";
+import path41 from "path";
 
 // src/discover/run-command.ts
 import { spawn } from "child_process";
@@ -4550,13 +4417,13 @@ async function discoverGitHub(repos, run = runCommand) {
 }
 
 // src/discover/git.ts
-import path39 from "path";
+import path38 from "path";
 var BRANCH_LIMIT = 20;
 async function discoverGit(repoPaths, run = runCommand) {
   const hits = [];
   const errors = [];
   for (const repoPath of repoPaths) {
-    const repoName = path39.basename(repoPath);
+    const repoName = path38.basename(repoPath);
     await collectBranches(repoPath, repoName, hits, errors, run);
     await collectWorktrees(repoPath, repoName, hits, errors, run);
     await collectStashes(repoPath, repoName, hits, errors, run);
@@ -4671,14 +4538,14 @@ function errStr(err) {
 
 // src/discover/projects.ts
 import { promises as fs27 } from "fs";
-import path40 from "path";
+import path39 from "path";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var RECENT_THRESHOLD_DAYS = 30;
 async function discoverProjects(projectsRoot) {
   const hits = [];
   const errors = [];
   if (!projectsRoot) return { hits, errors };
-  const resolved = path40.resolve(expandTilde(projectsRoot));
+  const resolved = path39.resolve(expandTilde(projectsRoot));
   let entries;
   try {
     entries = await fs27.readdir(resolved, { withFileTypes: true });
@@ -4694,7 +4561,7 @@ async function discoverProjects(projectsRoot) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     if (entry.name === "active") continue;
-    const fullPath = path40.join(resolved, entry.name);
+    const fullPath = path39.join(resolved, entry.name);
     let mtimeMs = 0;
     try {
       const stat = await fs27.stat(fullPath);
@@ -4727,11 +4594,11 @@ async function discoverProjects(projectsRoot) {
 // src/discover/claude.ts
 import { promises as fs28 } from "fs";
 import os2 from "os";
-import path41 from "path";
+import path40 from "path";
 var MAX_SCAN_LINES = 200;
 var COMPACTION_SUBJECT_PREFIX = "[compaction] ";
 async function discoverClaudeSessions() {
-  const root = process.env.CLAUDE_PROJECTS_ROOT ?? path41.join(os2.homedir(), ".claude", "projects");
+  const root = process.env.CLAUDE_PROJECTS_ROOT ?? path40.join(os2.homedir(), ".claude", "projects");
   const hits = [];
   const errors = [];
   let projectDirs;
@@ -4746,7 +4613,7 @@ async function discoverClaudeSessions() {
   const byCwd = /* @__PURE__ */ new Map();
   for (const dir of projectDirs) {
     if (!dir.isDirectory()) continue;
-    const dirPath = path41.join(root, dir.name);
+    const dirPath = path40.join(root, dir.name);
     let files;
     try {
       files = await fs28.readdir(dirPath, { withFileTypes: true });
@@ -4759,7 +4626,7 @@ async function discoverClaudeSessions() {
     }
     for (const file of files) {
       if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
-      const filePath = path41.join(dirPath, file.name);
+      const filePath = path40.join(dirPath, file.name);
       try {
         await aggregateSession(filePath, byCwd);
       } catch (err) {
@@ -4815,7 +4682,7 @@ async function aggregateSession(filePath, byCwd) {
   }
   if (!cwd) return;
   const subject = lastCompactionSummary ? `${COMPACTION_SUBJECT_PREFIX}${truncate2(lastCompactionSummary, 120)}` : firstUserMessage ? truncate2(firstUserMessage, 120) : "";
-  const sessionId = path41.basename(filePath, ".jsonl");
+  const sessionId = path40.basename(filePath, ".jsonl");
   const existing = byCwd.get(cwd);
   if (!existing) {
     byCwd.set(cwd, {
@@ -4915,7 +4782,7 @@ async function loadSlugs(activeRoot) {
   }
 }
 async function loadTriagedRefs(activeRoot) {
-  const logPath = path42.join(activeRoot, ".triaged.log");
+  const logPath = path41.join(activeRoot, ".triaged.log");
   const refs = /* @__PURE__ */ new Set();
   try {
     const raw = await fs29.readFile(logPath, "utf8");
@@ -4993,11 +4860,11 @@ import { z as z38 } from "zod";
 
 // src/discover/triaged-log.ts
 import { promises as fs30 } from "fs";
-import path43 from "path";
+import path42 from "path";
 async function appendTriagedLog(action, ref, extra) {
   const root = getActiveRoot();
   await fs30.mkdir(root, { recursive: true });
-  const logPath = path43.join(root, ".triaged.log");
+  const logPath = path42.join(root, ".triaged.log");
   let existing = "";
   try {
     existing = await fs30.readFile(logPath, "utf8");
@@ -5039,7 +4906,7 @@ var drop_default = defineCommand({
 
 // src/commands/fold.ts
 import { promises as fs31 } from "fs";
-import path44 from "path";
+import path43 from "path";
 import { z as z39 } from "zod";
 var ArgsSchema35 = z39.object({
   ref: z39.string().min(1),
@@ -5081,7 +4948,7 @@ var fold_default = defineCommand({
       if (err instanceof NotFoundError) throw err;
       throw new NotFoundError(`Initiative not found: ${args.into}`);
     }
-    const sessionsDir = path44.join(initiativeDir, "sessions");
+    const sessionsDir = path43.join(initiativeDir, "sessions");
     await fs31.mkdir(sessionsDir, { recursive: true });
     const startedIso = nowIso();
     const stem = buildSessionStem(startedIso, `folded-${sanitizeRef(args.ref)}`);
@@ -5114,7 +4981,7 @@ function sanitizeRef(ref) {
 
 // src/commands/track.ts
 import { promises as fs32 } from "fs";
-import path45 from "path";
+import path44 from "path";
 import { z as z40 } from "zod";
 import { stringify as yamlStringify } from "yaml";
 var ArgsSchema36 = z40.object({
@@ -5161,13 +5028,13 @@ var track_default = defineCommand({
     if (await dirExists5(dir)) {
       throw new UsageError(`Initiative already exists: ${args.slug}`);
     }
-    await fs32.mkdir(path45.join(dir, "tasks"), { recursive: true });
-    await fs32.mkdir(path45.join(dir, "sessions"), { recursive: true });
-    await fs32.mkdir(path45.join(dir, "sources"), { recursive: true });
+    await fs32.mkdir(path44.join(dir, "tasks"), { recursive: true });
+    await fs32.mkdir(path44.join(dir, "sessions"), { recursive: true });
+    await fs32.mkdir(path44.join(dir, "sources"), { recursive: true });
     const title = args.title ?? deriveTitle(args.slug);
     const briefBody = buildBriefBody(title, args.ref);
     await writeFrontmatter(
-      path45.join(dir, "brief.md"),
+      path44.join(dir, "brief.md"),
       {
         schema_version: 1,
         title,
@@ -5183,8 +5050,8 @@ var track_default = defineCommand({
     const artifacts = ArtifactsSchema.parse({
       worktrees: args.worktree ? [{ path: args.worktree, repo: args.worktree, name: "main", default: true }] : []
     });
-    await atomicWrite(path45.join(dir, "artifacts.yml"), yamlStringify(artifacts));
-    await atomicWrite(path45.join(dir, "sources", ".gitkeep"), "");
+    await atomicWrite(path44.join(dir, "artifacts.yml"), yamlStringify(artifacts));
+    await atomicWrite(path44.join(dir, "sources", ".gitkeep"), "");
     await appendTriagedLog("track", args.ref, `slug:${args.slug}`);
     return { slug: args.slug, dir, ref: args.ref };
   }
@@ -5224,6 +5091,8 @@ var ArgsSchema37 = z41.object({
   // Frame the prompt as ad-hoc work on the workstream rather than a
   // continuation of its handoff / top task.
   adhoc: z41.boolean().optional(),
+  // Rank the notes against this instead of the top task and brief titles.
+  about: z41.string().min(1).optional(),
   // Skip the check for another session already live on this initiative.
   no_sibling_check: z41.boolean().optional()
 });
@@ -5247,12 +5116,16 @@ var promptCommand = defineCommand({
         long: "--adhoc",
         description: "Frame the prompt as ad-hoc work on the workstream, awaiting the user\u2019s task, not a continuation of the handoff / top task."
       },
+      about: {
+        long: "--about",
+        description: "What this session is about, ranking the notes against it instead of the top task and brief titles."
+      },
       no_sibling_check: {
         long: "--no-sibling-check",
         description: "Skip the check for another session already live on this initiative."
       }
     },
-    usage: "active-work prompt [slug] [--offline] [--cwd <dir>] [--adhoc] [--no-sibling-check]"
+    usage: "active-work prompt [slug] [--offline] [--cwd <dir>] [--adhoc] [--about <text>] [--no-sibling-check]"
   },
   async run(args, ctx) {
     const activeRoot = ctx.activeRoot ?? getActiveRoot();
@@ -5274,6 +5147,7 @@ var promptCommand = defineCommand({
       slug,
       includeLiveStatus: !args.offline,
       adhoc: args.adhoc,
+      ...args.about !== void 0 ? { about: args.about } : {},
       detectSiblings: !args.no_sibling_check && !args.offline,
       ...process.env.AW_LEASE_ID ? { ownLeaseId: process.env.AW_LEASE_ID } : {}
     });
@@ -5284,7 +5158,7 @@ var prompt_default = promptCommand;
 
 // src/commands/edit.ts
 import { promises as fs33 } from "fs";
-import path46 from "path";
+import path45 from "path";
 import { spawn as spawn2 } from "child_process";
 import { z as z42 } from "zod";
 var ArgsSchema38 = z42.object({
@@ -5335,7 +5209,7 @@ var defaultDeps = {
   spawner: defaultSpawner
 };
 function targetFile(slug) {
-  return path46.join(getInitiativeDir(slug), "brief.md");
+  return path45.join(getInitiativeDir(slug), "brief.md");
 }
 async function fileExists2(p) {
   try {
@@ -5414,7 +5288,7 @@ import {
 } from "@titan-design/registry";
 
 // src/version.ts
-var BUILD_VERSION = "0.6.0";
+var BUILD_VERSION = "0.7.0";
 
 // src/server/mcp.ts
 var TOOL_NAME_PREFIX = "active__";
@@ -5437,7 +5311,7 @@ import { DaemonAlreadyRunningError, startDaemon } from "@titan-design/daemon";
 
 // src/server/dashboard-routes.ts
 import { promises as fs34 } from "fs";
-import path47 from "path";
+import path46 from "path";
 import { fileURLToPath } from "url";
 var PLACEHOLDER_HTML = `<!doctype html>
 <html lang="en">
@@ -5469,17 +5343,17 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filename) {
-  const ext = path47.extname(filename).toLowerCase();
+  const ext = path46.extname(filename).toLowerCase();
   return CONTENT_TYPES[ext] ?? "application/octet-stream";
 }
 function dashboardDirCandidates() {
-  const here = path47.dirname(fileURLToPath(import.meta.url));
+  const here = path46.dirname(fileURLToPath(import.meta.url));
   return [
-    path47.resolve(here, "dashboard"),
+    path46.resolve(here, "dashboard"),
     // bundled: dist/cli.js -> dist/dashboard
-    path47.resolve(here, "..", "dashboard"),
+    path46.resolve(here, "..", "dashboard"),
     // legacy: dist/server -> dist/dashboard
-    path47.resolve(here, "..", "..", "dist", "dashboard")
+    path46.resolve(here, "..", "..", "dist", "dashboard")
     // dev: src/server -> dist/dashboard
   ];
 }
@@ -5505,13 +5379,13 @@ async function handleDashboard(c) {
   const url = new URL(c.req.url);
   const subpath = url.pathname.replace(/^\/ui\/?/, "");
   const relative = subpath === "" ? "index.html" : subpath;
-  const target = path47.resolve(root, relative);
-  if (!target.startsWith(root + path47.sep) && target !== root) {
+  const target = path46.resolve(root, relative);
+  if (!target.startsWith(root + path46.sep) && target !== root) {
     return c.text("forbidden", 403);
   }
   const stat = await safeStat(target);
   if (!stat.exists || !stat.isFile) {
-    const indexPath = path47.join(root, "index.html");
+    const indexPath = path46.join(root, "index.html");
     const indexStat = await safeStat(indexPath);
     if (!indexStat.exists) {
       return c.html(PLACEHOLDER_HTML, 200);
@@ -5529,13 +5403,13 @@ async function handleDashboard(c) {
 
 // src/server/logger.ts
 import { mkdirSync, createWriteStream } from "fs";
-import path48 from "path";
+import path47 from "path";
 import pino, { multistream } from "pino";
 var cachedLogger;
 function buildLogger() {
   const stateRoot = getStateRoot();
   mkdirSync(stateRoot, { recursive: true });
-  const logPath = path48.join(stateRoot, "daemon.log");
+  const logPath = path47.join(stateRoot, "daemon.log");
   const fileStream = createWriteStream(logPath, { flags: "a" });
   const stderrIsTTY = process.stderr.isTTY === true;
   const stderrStream = stderrIsTTY ? pino.transport({
@@ -5556,7 +5430,7 @@ import { transcriptsRoot as transcriptsRoot2 } from "@titan-design/session-read"
 import { watchTree } from "@titan-design/daemon";
 
 // src/session-index/refresh.ts
-import path57 from "path";
+import path56 from "path";
 import { promises as fs44 } from "fs";
 import lockfile from "proper-lockfile";
 import { discoverTranscripts, transcriptsRoot } from "@titan-design/session-read";
@@ -5564,7 +5438,7 @@ import { refreshCorpus, resetIndex } from "@titan-design/session-graph";
 
 // src/session-index/tasks.ts
 import { promises as fs35 } from "fs";
-import path49 from "path";
+import path48 from "path";
 var AMBIGUOUS = null;
 async function initiativeSlugs(root) {
   try {
@@ -5576,7 +5450,7 @@ async function initiativeSlugs(root) {
   }
 }
 async function readInitiative(root, slug) {
-  const dir = path49.join(root, slug, "tasks");
+  const dir = path48.join(root, slug, "tasks");
   let files;
   try {
     files = await fs35.readdir(dir);
@@ -5588,7 +5462,7 @@ async function readInitiative(root, slug) {
   for (const file of files) {
     if (!file.endsWith(".yml")) continue;
     try {
-      const task = await readYaml(path49.join(dir, file), TaskSchema);
+      const task = await readYaml(path48.join(dir, file), TaskSchema);
       found.push([task.id, { initiative: slug, title: task.title, status: task.status }]);
     } catch {
       continue;
@@ -5642,8 +5516,8 @@ function extractMentions(body, initiative, index) {
   for (const id of matches(body, NOTE_REF)) {
     if (index.noteRefs.has(noteRef(id))) found.add(noteRef(id));
   }
-  for (const path68 of matches(body, SOURCE_PATH)) {
-    const scoped = `${initiative}/${path68}`;
+  for (const path67 of matches(body, SOURCE_PATH)) {
+    const scoped = `${initiative}/${path67}`;
     if (index.sourcePaths.has(scoped)) found.add(sourceRef(scoped));
   }
   return [...found].sort();
@@ -5980,26 +5854,26 @@ function compact(spans) {
 
 // src/workspace-index/scan.ts
 import { promises as fs42 } from "fs";
-import path56 from "path";
+import path55 from "path";
 
 // src/lint/index.ts
 import { promises as fs41 } from "fs";
-import path55 from "path";
+import path54 from "path";
 
 // src/lint/brief.ts
 import { promises as fs37 } from "fs";
-import path50 from "path";
+import path49 from "path";
 
 // src/lint/hashes.ts
 import { promises as fs38 } from "fs";
-import path51 from "path";
+import path50 from "path";
 async function lintHashes(slug, initiativeDir) {
   const manifest = await readArtifactHashes(initiativeDir);
   const findings = [];
   for (const [relPath, storedHash] of Object.entries(manifest)) {
     let content;
     try {
-      content = await fs38.readFile(path51.join(initiativeDir, relPath), "utf8");
+      content = await fs38.readFile(path50.join(initiativeDir, relPath), "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") continue;
@@ -6017,16 +5891,16 @@ async function lintHashes(slug, initiativeDir) {
 }
 
 // src/lint/open-loops.ts
-import path52 from "path";
+import path51 from "path";
 
 // src/lint/task.ts
 import { promises as fs39 } from "fs";
-import path53 from "path";
+import path52 from "path";
 import YAML2 from "yaml";
 
 // src/lint/zero-loops.ts
 import { promises as fs40 } from "fs";
-import path54 from "path";
+import path53 from "path";
 import YAML3 from "yaml";
 
 // src/lint/index.ts
@@ -6055,21 +5929,21 @@ function isVisible(entry, extensions) {
 }
 async function filesIn(dir, extensions) {
   const entries = await readDirents(dir);
-  return entries.filter((entry) => isVisible(entry, extensions)).map((entry) => path56.join(dir, entry.name)).sort();
+  return entries.filter((entry) => isVisible(entry, extensions)).map((entry) => path55.join(dir, entry.name)).sort();
 }
 async function taskFiles(tasksDir) {
   const own = await filesIn(tasksDir, [".yml", ".yaml"]);
-  const archive = await filesIn(path56.join(tasksDir, "archive"), [".yml", ".yaml"]);
+  const archive = await filesIn(path55.join(tasksDir, "archive"), [".yml", ".yaml"]);
   return [...own, ...archive];
 }
 async function collectSlug(activeRoot, slug) {
-  const dir = path56.join(activeRoot, slug);
-  const brief = path56.join(dir, "brief.md");
+  const dir = path55.join(activeRoot, slug);
+  const brief = path55.join(dir, "brief.md");
   const [notes, tasks, sessions2, sources] = await Promise.all([
-    filesIn(path56.join(dir, "sources", "notes"), [".md"]),
-    taskFiles(path56.join(dir, "tasks")),
-    filesIn(path56.join(dir, "sessions"), [".md"]),
-    filesIn(path56.join(dir, "sources"), [".md"])
+    filesIn(path55.join(dir, "sources", "notes"), [".md"]),
+    taskFiles(path55.join(dir, "tasks")),
+    filesIn(path55.join(dir, "sessions"), [".md"]),
+    filesIn(path55.join(dir, "sources"), [".md"])
   ]);
   return [
     ...notes.map((p) => ["note", p]),
@@ -6479,7 +6353,7 @@ function refreshLockPath() {
 }
 async function withRefreshLock(fn) {
   const target = refreshLockPath();
-  await fs44.mkdir(path57.dirname(target), { recursive: true });
+  await fs44.mkdir(path56.dirname(target), { recursive: true });
   await fs44.writeFile(target, "", { flag: "a" });
   const release = await lockfile.lock(target, {
     realpath: false,
@@ -7011,7 +6885,7 @@ var mcp_status_default = defineCommand({
 
 // src/commands/mcp-logs.ts
 import { promises as fs45 } from "fs";
-import path58 from "path";
+import path57 from "path";
 import { z as z48 } from "zod";
 var ArgsSchema43 = z48.object({
   lines: z48.number().int().positive().optional()
@@ -7035,7 +6909,7 @@ var mcp_logs_default = defineCommand({
   },
   async run(args) {
     const n = args.lines ?? DEFAULT_LINES;
-    const logPath = path58.join(getStateRoot(), "daemon.log");
+    const logPath = path57.join(getStateRoot(), "daemon.log");
     let content;
     try {
       content = await fs45.readFile(logPath, "utf8");
@@ -7065,7 +6939,7 @@ import { Clusterer } from "@titan-design/cluster";
 
 // src/drain/store.ts
 import { promises as fs46 } from "fs";
-import path59 from "path";
+import path58 from "path";
 
 // src/schemas/template.ts
 import { z as z49 } from "zod";
@@ -7095,10 +6969,10 @@ var TemplatesFileSchema = z49.object({
 
 // src/drain/store.ts
 function templatesPath(root) {
-  return path59.join(root, "templates.yml");
+  return path58.join(root, "templates.yml");
 }
 function occurrencesPath(root) {
-  return path59.join(root, "occurrences.jsonl");
+  return path58.join(root, "occurrences.jsonl");
 }
 async function loadTemplates(root = getMinerRoot()) {
   try {
@@ -7136,7 +7010,7 @@ async function appendOccurrences(occurrences, root = getMinerRoot()) {
 
 // src/drain/tree-store.ts
 import { promises as fs47 } from "fs";
-import path60 from "path";
+import path59 from "path";
 import { z as z50 } from "zod";
 var PartitionSchema = z50.object({
   partition: z50.string().min(1),
@@ -7160,7 +7034,7 @@ var LegacySnapshotFileSchema = z50.object({
   trees: z50.array(PartitionSchema.omit({ partition: true }).extend({ toolType: z50.string().min(1) }))
 });
 function snapshotPath(root) {
-  return path60.join(root, "drain-trees.json");
+  return path59.join(root, "drain-trees.json");
 }
 function empty() {
   return { version: 1, partitions: [] };
@@ -7339,7 +7213,7 @@ function extractBlobs(line, toolNames) {
 
 // src/drain/reader-state.ts
 import { promises as fs48 } from "fs";
-import path61 from "path";
+import path60 from "path";
 import { z as z51 } from "zod";
 var TranscriptStateSchema = z51.object({
   /** `~`-relative path, matching `session-index/discover.ts`'s display form. */
@@ -7360,7 +7234,7 @@ var ReaderStateSchema = z51.object({
 });
 var MAX_PENDING_TOOL_NAMES = 256;
 function readerStatePath(root = getMinerRoot()) {
-  return path61.join(root, "reader-state.json");
+  return path60.join(root, "reader-state.json");
 }
 async function loadReaderState(root = getMinerRoot()) {
   try {
@@ -8011,7 +7885,7 @@ async function readStdinJson(stream = process.stdin) {
 
 // src/utils/agent-chat-hook-state.ts
 import { promises as fs49 } from "fs";
-import path62 from "path";
+import path61 from "path";
 import { z as z56 } from "zod";
 var SpawnContextSchema = z56.object({
   slug: z56.string().min(1),
@@ -8031,10 +7905,10 @@ var SpawnContextSchema = z56.object({
   briefing: z56.string().nullable().default(null)
 });
 function stateDir() {
-  return path62.join(getStateRoot(), "agent-chat-hooks");
+  return path61.join(getStateRoot(), "agent-chat-hooks");
 }
 function stateFile(agentId) {
-  return path62.join(stateDir(), `${agentId}.json`);
+  return path61.join(stateDir(), `${agentId}.json`);
 }
 async function stashSpawnContext(agentId, context) {
   await fs49.mkdir(stateDir(), { recursive: true });
@@ -8204,7 +8078,7 @@ import { join } from "path";
 
 // src/migrations/v1-to-v2-artifacts.ts
 import { promises as fs50 } from "fs";
-import path63 from "path";
+import path62 from "path";
 import YAML4 from "yaml";
 function asArray(value) {
   return Array.isArray(value) ? value : [];
@@ -8264,7 +8138,7 @@ async function walkArtifactsFiles(activeRoot) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      const candidate = path63.join(activeRoot, entry.name, "artifacts.yml");
+      const candidate = path62.join(activeRoot, entry.name, "artifacts.yml");
       try {
         await fs50.access(candidate);
         out.push(candidate);
@@ -8273,14 +8147,14 @@ async function walkArtifactsFiles(activeRoot) {
     }
   } catch {
   }
-  const archiveRoot = path63.resolve(activeRoot, "..");
+  const archiveRoot = path62.resolve(activeRoot, "..");
   try {
     const domains = await fs50.readdir(archiveRoot, { withFileTypes: true });
     for (const domain of domains) {
       if (!domain.isDirectory()) continue;
       if (domain.name.startsWith(".")) continue;
-      if (path63.join(archiveRoot, domain.name) === path63.resolve(activeRoot)) continue;
-      const archiveDir = path63.join(archiveRoot, domain.name, "archive");
+      if (path62.join(archiveRoot, domain.name) === path62.resolve(activeRoot)) continue;
+      const archiveDir = path62.join(archiveRoot, domain.name, "archive");
       let archived;
       try {
         archived = await fs50.readdir(archiveDir, { withFileTypes: true });
@@ -8289,7 +8163,7 @@ async function walkArtifactsFiles(activeRoot) {
       }
       for (const entry of archived) {
         if (!entry.isDirectory()) continue;
-        const candidate = path63.join(archiveDir, entry.name, "artifacts.yml");
+        const candidate = path62.join(archiveDir, entry.name, "artifacts.yml");
         try {
           await fs50.access(candidate);
           out.push(candidate);
@@ -8303,7 +8177,7 @@ async function walkArtifactsFiles(activeRoot) {
 }
 async function appendMigrationLog(activeRoot, lines) {
   if (lines.length === 0) return;
-  const logPath = path63.join(activeRoot, ".migrations.log");
+  const logPath = path62.join(activeRoot, ".migrations.log");
   const stamp = (/* @__PURE__ */ new Date()).toISOString();
   const body = lines.map((l) => `${stamp}	v1->v2	${l}
 `).join("");
@@ -8335,7 +8209,7 @@ var v1ToV2Artifacts = {
 
 // src/migrations/v2-to-v3-open-loops.ts
 import { promises as fs53 } from "fs";
-import path65 from "path";
+import path64 from "path";
 
 // src/migrations/v3-proposal.ts
 import { promises as fs51 } from "fs";
@@ -9235,17 +9109,17 @@ async function loadProposal() {
 
 // src/migrations/v3-repairs.ts
 import { promises as fs52 } from "fs";
-import path64 from "path";
+import path63 from "path";
 var KNOWN_REPAIRS = [
   {
-    file: path64.join("audiobook", "sessions", "2026-07-23-0549-2026-07-26-book1-m4b-packaging.md"),
+    file: path63.join("audiobook", "sessions", "2026-07-23-0549-2026-07-26-book1-m4b-packaging.md"),
     kind: "retrack",
     why: "track is a branch name ('feat/tts-quality'), not one of canonical|sidecar|adhoc"
   },
   {
-    file: path64.join("voltras-workspace", "sessions", "ARCHIVED-handoff-through-2026-07-15.md"),
+    file: path63.join("voltras-workspace", "sessions", "ARCHIVED-handoff-through-2026-07-15.md"),
     kind: "relocate",
-    target: path64.join("voltras-workspace", "sources", "ARCHIVED-handoff-through-2026-07-15.md"),
+    target: path63.join("voltras-workspace", "sources", "ARCHIVED-handoff-through-2026-07-15.md"),
     why: "not a session file \u2014 a hand-archived handoff parked in sessions/"
   }
 ];
@@ -9304,7 +9178,7 @@ async function exists3(p) {
 async function planRepairs(activeRoot) {
   const plans = [];
   for (const repair of KNOWN_REPAIRS) {
-    const fullPath = path64.join(activeRoot, repair.file);
+    const fullPath = path63.join(activeRoot, repair.file);
     if (!await exists3(fullPath)) {
       plans.push({ action: "skip", file: repair.file, detail: "already absent" });
       continue;
@@ -9314,7 +9188,7 @@ async function planRepairs(activeRoot) {
       continue;
     }
     const target = repair.target;
-    if (await exists3(path64.join(activeRoot, target))) {
+    if (await exists3(path63.join(activeRoot, target))) {
       plans.push({
         action: "skip",
         file: repair.file,
@@ -9328,7 +9202,7 @@ async function planRepairs(activeRoot) {
   return plans;
 }
 async function applyRepair(activeRoot, plan) {
-  const fullPath = path64.join(activeRoot, plan.file);
+  const fullPath = path63.join(activeRoot, plan.file);
   if (plan.action === "retrack" && plan.repaired !== void 0) {
     await writeFrontmatter(
       fullPath,
@@ -9339,15 +9213,15 @@ async function applyRepair(activeRoot, plan) {
     return;
   }
   if (plan.action === "relocate") {
-    const target = path64.join(activeRoot, plan.target);
-    await fs52.mkdir(path64.dirname(target), { recursive: true });
+    const target = path63.join(activeRoot, plan.target);
+    await fs52.mkdir(path63.dirname(target), { recursive: true });
     await fs52.rename(fullPath, target);
   }
 }
 
 // src/migrations/v2-to-v3-open-loops.ts
 var HANDOFF_FILE = "handoff.md";
-var HANDOFF_ARCHIVE = path65.join("sources", "handoff-archive.md");
+var HANDOFF_ARCHIVE = path64.join("sources", "handoff-archive.md");
 async function pathExists(p) {
   try {
     await fs53.access(p);
@@ -9366,7 +9240,7 @@ async function listInitiativeSlugs3(activeRoot) {
   const slugs = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    if (await pathExists(path65.join(activeRoot, entry.name, "brief.md"))) {
+    if (await pathExists(path64.join(activeRoot, entry.name, "brief.md"))) {
       slugs.push(entry.name);
     }
   }
@@ -9374,9 +9248,9 @@ async function listInitiativeSlugs3(activeRoot) {
 }
 async function maxOnDiskTaskNumber2(initiativeDir, prefix) {
   const re = new RegExp(`^${prefix}-(\\d+)\\.yml$`);
-  const tasksDir = path65.join(initiativeDir, "tasks");
+  const tasksDir = path64.join(initiativeDir, "tasks");
   let max = 0;
-  for (const dir of [tasksDir, path65.join(tasksDir, "archive")]) {
+  for (const dir of [tasksDir, path64.join(tasksDir, "archive")]) {
     let names;
     try {
       names = await fs53.readdir(dir);
@@ -9398,7 +9272,7 @@ async function nextTaskSeq(initiativeDir, frontmatter2) {
   return max > 0 ? max : null;
 }
 async function planBrief(initiativeDir, slug) {
-  const raw = await readRawFrontmatter(path65.join(initiativeDir, "brief.md"));
+  const raw = await readRawFrontmatter(path64.join(initiativeDir, "brief.md"));
   const repaired = repairBriefFrontmatter(slug, raw.frontmatter);
   const taskSeq = await nextTaskSeq(initiativeDir, repaired.frontmatter);
   if (taskSeq === null && repaired.applied.length === 0) return { write: null };
@@ -9415,8 +9289,8 @@ async function planBrief(initiativeDir, slug) {
   };
 }
 async function planHandoff(initiativeDir) {
-  if (!await pathExists(path65.join(initiativeDir, HANDOFF_FILE))) return "absent";
-  if (await pathExists(path65.join(initiativeDir, HANDOFF_ARCHIVE))) return "archive-exists";
+  if (!await pathExists(path64.join(initiativeDir, HANDOFF_FILE))) return "absent";
+  if (await pathExists(path64.join(initiativeDir, HANDOFF_ARCHIVE))) return "archive-exists";
   return "archive-and-remove";
 }
 function buildOpenSession(entry) {
@@ -9506,7 +9380,7 @@ function draftSessions(entry, abandonedAt) {
   return [open, buildAbandonSession(entry, open.stem, abandonedAt)];
 }
 async function planInitiative(activeRoot, slug, entry, abandonedAt) {
-  const initiativeDir = path65.join(activeRoot, slug);
+  const initiativeDir = path64.join(activeRoot, slug);
   const brief = await planBrief(initiativeDir, slug);
   const base = {
     slug,
@@ -9545,9 +9419,9 @@ async function planV2ToV3(activeRoot) {
   return { proposalOrigin: origin, initiatives, repairs: await planRepairs(activeRoot) };
 }
 async function archiveHandoff(initiativeDir) {
-  const source = path65.join(initiativeDir, HANDOFF_FILE);
-  const target = path65.join(initiativeDir, HANDOFF_ARCHIVE);
-  await fs53.mkdir(path65.dirname(target), { recursive: true });
+  const source = path64.join(initiativeDir, HANDOFF_FILE);
+  const target = path64.join(initiativeDir, HANDOFF_ARCHIVE);
+  await fs53.mkdir(path64.dirname(target), { recursive: true });
   await fs53.copyFile(source, target);
   await fs53.rm(source);
 }
@@ -9566,15 +9440,15 @@ async function writePlannedSession(activeRoot, slug, session) {
   });
 }
 async function applyInitiative(activeRoot, plan) {
-  const initiativeDir = path65.join(activeRoot, plan.slug);
-  await withFileLock(path65.join(initiativeDir, ".lock"), async () => {
+  const initiativeDir = path64.join(activeRoot, plan.slug);
+  await withFileLock(path64.join(initiativeDir, ".lock"), async () => {
     for (const session of plan.sessions) {
       if (session.exists) continue;
       await writePlannedSession(activeRoot, plan.slug, session);
     }
     if (plan.brief !== null) {
       await writeFrontmatter(
-        path65.join(initiativeDir, "brief.md"),
+        path64.join(initiativeDir, "brief.md"),
         plan.brief.frontmatter,
         plan.brief.body,
         BriefFrontmatterSchema
@@ -9605,12 +9479,12 @@ var v2ToV3OpenLoops = {
 
 // src/migrations/v3-to-v4-worktrees.ts
 import { promises as fs54 } from "fs";
-import path66 from "path";
+import path65 from "path";
 import matter5 from "gray-matter";
 import YAML5 from "yaml";
 function normalize(value) {
-  const expanded = value.startsWith("~") ? path66.join(process.env.HOME ?? "", value.slice(1)) : value;
-  return path66.resolve(expanded);
+  const expanded = value.startsWith("~") ? path65.join(process.env.HOME ?? "", value.slice(1)) : value;
+  return path65.resolve(expanded);
 }
 function toEntries(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return [];
@@ -9657,7 +9531,7 @@ async function readArtifacts2(file) {
   }
 }
 async function migrateOne2(initiativeDir) {
-  const briefPath = path66.join(initiativeDir, "brief.md");
+  const briefPath = path65.join(initiativeDir, "brief.md");
   let raw;
   try {
     raw = await fs54.readFile(briefPath, "utf8");
@@ -9670,7 +9544,7 @@ async function migrateOne2(initiativeDir) {
   const incoming = toEntries(data.worktrees);
   delete data.worktrees;
   if (incoming.length > 0) {
-    const artifactsPath2 = path66.join(initiativeDir, "artifacts.yml");
+    const artifactsPath2 = path65.join(initiativeDir, "artifacts.yml");
     const current = await readArtifacts2(artifactsPath2);
     await writeYaml(
       artifactsPath2,
@@ -9695,9 +9569,9 @@ async function initiativeDirs(activeRoot) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    const dir = path66.join(activeRoot, entry.name);
+    const dir = path65.join(activeRoot, entry.name);
     try {
-      await fs54.access(path66.join(dir, "brief.md"));
+      await fs54.access(path65.join(dir, "brief.md"));
       out.push(dir);
     } catch {
     }
@@ -9712,12 +9586,12 @@ var v3ToV4Worktrees = {
     const moved = [];
     for (const dir of await initiativeDirs(activeRoot)) {
       const count = await migrateOne2(dir);
-      if (count > 0) moved.push(`${path66.basename(dir)}	${count} worktree(s)`);
+      if (count > 0) moved.push(`${path65.basename(dir)}	${count} worktree(s)`);
     }
     if (moved.length === 0) return;
     const stamp = (/* @__PURE__ */ new Date()).toISOString();
     await fs54.appendFile(
-      path66.join(activeRoot, ".migrations.log"),
+      path65.join(activeRoot, ".migrations.log"),
       moved.map((line) => `${stamp}	v3->v4	${line}
 `).join(""),
       "utf8"
@@ -9727,12 +9601,12 @@ var v3ToV4Worktrees = {
 
 // src/migrations/index.ts
 var BASE_VERSION = 1;
-var MIGRATIONS2 = [v1ToV2Artifacts, v2ToV3OpenLoops, v3ToV4Worktrees];
-var CURRENT_VERSION = targetVersion(MIGRATIONS2);
+var MIGRATIONS = [v1ToV2Artifacts, v2ToV3OpenLoops, v3ToV4Worktrees];
+var CURRENT_VERSION = targetVersion(MIGRATIONS);
 function targetVersion(migrations) {
   return migrations.reduce((highest, m) => Math.max(highest, m.to), BASE_VERSION);
 }
-async function runMigrations2(activeRoot, fromVersion, migrations = MIGRATIONS2) {
+async function runMigrations(activeRoot, fromVersion, migrations = MIGRATIONS) {
   if (fromVersion === CURRENT_VERSION) {
     return { ran: [] };
   }
@@ -9770,10 +9644,10 @@ var SCHEMA_VERSION_FILENAME = ".schema-version";
 var schemaVersionPath = (activeRoot) => join(activeRoot, SCHEMA_VERSION_FILENAME);
 var isNodeErrnoException = (err) => typeof err === "object" && err !== null && "code" in err;
 async function readSchemaVersion(activeRoot) {
-  const path68 = schemaVersionPath(activeRoot);
+  const path67 = schemaVersionPath(activeRoot);
   let raw;
   try {
-    raw = await readFile(path68, "utf8");
+    raw = await readFile(path67, "utf8");
   } catch (err) {
     if (isNodeErrnoException(err) && err.code === "ENOENT") {
       return 0;
@@ -9783,13 +9657,13 @@ async function readSchemaVersion(activeRoot) {
   const trimmed = raw.trim();
   if (trimmed === "" || !/^\d+$/.test(trimmed)) {
     throw new Error(
-      `Invalid schema version in ${path68}: expected a positive integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path67}: expected a positive integer, got ${JSON.stringify(raw)}`
     );
   }
   const parsed = Number(trimmed);
   if (!Number.isInteger(parsed) || parsed <= 0) {
     throw new Error(
-      `Invalid schema version in ${path68}: expected a positive integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path67}: expected a positive integer, got ${JSON.stringify(raw)}`
     );
   }
   return parsed;
@@ -9802,10 +9676,10 @@ async function writeSchemaVersion(activeRoot, version) {
 `, "utf8");
 }
 async function readRawSchemaVersion(activeRoot) {
-  const path68 = schemaVersionPath(activeRoot);
+  const path67 = schemaVersionPath(activeRoot);
   let raw;
   try {
-    raw = await readFile(path68, "utf8");
+    raw = await readFile(path67, "utf8");
   } catch (err) {
     if (isNodeErrnoException(err) && err.code === "ENOENT") {
       return { present: false };
@@ -9815,13 +9689,13 @@ async function readRawSchemaVersion(activeRoot) {
   const trimmed = raw.trim();
   if (trimmed === "" || !/^\d+$/.test(trimmed)) {
     throw new Error(
-      `Invalid schema version in ${path68}: expected a non-negative integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path67}: expected a non-negative integer, got ${JSON.stringify(raw)}`
     );
   }
   const parsed = Number(trimmed);
   if (!Number.isInteger(parsed) || parsed < 0) {
     throw new Error(
-      `Invalid schema version in ${path68}: expected a non-negative integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path67}: expected a non-negative integer, got ${JSON.stringify(raw)}`
     );
   }
   return { present: true, version: parsed };
@@ -9841,7 +9715,7 @@ async function ensureSchemaVersion(activeRoot) {
   if (before === CURRENT_VERSION) {
     return { before, after: before, migrated: false, ran: [] };
   }
-  const { ran } = await runMigrations2(activeRoot, before);
+  const { ran } = await runMigrations(activeRoot, before);
   await writeSchemaVersion(activeRoot, CURRENT_VERSION);
   return {
     before,
@@ -12040,14 +11914,14 @@ import { readCommanderOption } from "@titan-design/registry";
 
 // src/utils/usage-log.ts
 import { promises as fs56 } from "fs";
-import path67 from "path";
+import path66 from "path";
 function usageLogPath() {
-  return path67.join(getStateRoot(), "usage.jsonl");
+  return path66.join(getStateRoot(), "usage.jsonl");
 }
 async function appendUsage(rec) {
   try {
     const file = usageLogPath();
-    await fs56.mkdir(path67.dirname(file), { recursive: true });
+    await fs56.mkdir(path66.dirname(file), { recursive: true });
     await fs56.appendFile(file, JSON.stringify(rec) + "\n", "utf8");
   } catch {
   }