@titan-design/active-work 0.3.0 → 0.4.0

package/dist/cli.js

@@ -11,6 +11,7 @@ import {
   NOTE_TITLE_MAX_LENGTH,
   NextStepSchema,
   NotFoundError,
+  NoteFrontmatterSchema,
   NoteKindSchema,
   SessionFrontmatterSchema,
   SessionIdSchema,
@@ -23,6 +24,7 @@ import {
   WorktreeEntrySchema,
   assembleBootstrap,
   atomicWrite,
+  coerceDates,
   color,
   defineCommand,
   deriveOpenLoops,
@@ -74,7 +76,7 @@ import {
   writeFrontmatter,
   writeNoteFile,
   writeYaml
-} from "./chunk-HSGZOWS3.js";
+} from "./chunk-BK25ASXA.js";
 
 // src/cli.ts
 import { Command, CommanderError } from "commander";
@@ -261,7 +263,7 @@ var new_default = defineCommand({
     }
     const rank = await computeNextRank(ctx.activeRoot);
     const task_prefix = derivePrefix(args.slug);
-    const frontmatter = {
+    const frontmatter2 = {
       schema_version: 1,
       title: args.title,
       updated: today(),
@@ -281,7 +283,7 @@ Why: ...
 `;
     await writeFrontmatter(
       path2.join(dir, "brief.md"),
-      frontmatter,
+      frontmatter2,
       briefBody,
       BriefFrontmatterSchema
     );
@@ -452,11 +454,11 @@ var set_default = defineCommand({
       throw new NotFoundError(`Initiative not found: ${args.slug}`);
     }
     await withFileLock(getLockPath(args.slug), async () => {
-      const { frontmatter, body } = await readRawFrontmatter(briefPath);
-      setPath(frontmatter, args.field, args.value);
-      frontmatter.updated = today();
+      const { frontmatter: frontmatter2, body } = await readRawFrontmatter(briefPath);
+      setPath(frontmatter2, args.field, args.value);
+      frontmatter2.updated = today();
       try {
-        await writeFrontmatter(briefPath, frontmatter, body, BriefFrontmatterSchema);
+        await writeFrontmatter(briefPath, frontmatter2, body, BriefFrontmatterSchema);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
         throw new ValidationError(
@@ -497,9 +499,9 @@ var touch_default = defineCommand({
     }
     const updated = today();
     await withFileLock(getLockPath(args.slug), async () => {
-      const { frontmatter, body } = await readRawFrontmatter(briefPath);
-      frontmatter.updated = updated;
-      await writeFrontmatter(briefPath, frontmatter, body, BriefFrontmatterSchema);
+      const { frontmatter: frontmatter2, body } = await readRawFrontmatter(briefPath);
+      frontmatter2.updated = updated;
+      await writeFrontmatter(briefPath, frontmatter2, body, BriefFrontmatterSchema);
     });
     return { slug: args.slug, updated };
   }
@@ -531,8 +533,8 @@ async function loadAllBriefs() {
       continue;
     }
     if (!stat.isFile()) continue;
-    const { frontmatter, body } = await readFrontmatter(briefPath, BriefFrontmatterSchema);
-    briefs.push({ slug: name, briefPath, frontmatter, body });
+    const { frontmatter: frontmatter2, body } = await readFrontmatter(briefPath, BriefFrontmatterSchema);
+    briefs.push({ slug: name, briefPath, frontmatter: frontmatter2, body });
   }
   briefs.sort((a, b) => a.slug.localeCompare(b.slug));
   return briefs;
@@ -1084,11 +1086,11 @@ var task_delete_default = defineCommand({
       if (n !== null && n === onDiskMax) {
         const stored = readTaskSeq(brief, onDiskMax);
         if (stored < n) {
-          const frontmatter = {
+          const frontmatter2 = {
             ...brief.frontmatter,
             task_seq: n
           };
-          await writeFrontmatter(brief.path, frontmatter, brief.body, BriefFrontmatterSchema);
+          await writeFrontmatter(brief.path, frontmatter2, brief.body, BriefFrontmatterSchema);
         }
       }
       await fs10.unlink(file);
@@ -1515,8 +1517,8 @@ var NO_UPSTREAM = { ahead: null, behind: null };
 function shortBranch(ref) {
   return ref.replace(/^refs\/heads\//, "");
 }
-function emptyWorktree(path65) {
-  return { path: path65, 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 = [];
@@ -2000,10 +2002,10 @@ var session_list_default = defineCommand({
     for (const filename of filenames) {
       const fullPath = path19.join(sessionsDir, filename);
       try {
-        const { frontmatter, body } = await readSession(fullPath);
+        const { frontmatter: frontmatter2, body } = await readSession(fullPath);
         entries.push({
           filename,
-          frontmatter,
+          frontmatter: frontmatter2,
           first_line: extractFirstLine(body)
         });
       } catch (err) {
@@ -2427,9 +2429,9 @@ async function verifyTaskIds(initiativeDir, ids) {
 }
 async function stampBriefUpdated(briefPath) {
   const updated = today();
-  const { frontmatter, body } = await readRawFrontmatter(briefPath);
-  frontmatter.updated = updated;
-  await writeFrontmatter(briefPath, frontmatter, body, BriefFrontmatterSchema);
+  const { frontmatter: frontmatter2, body } = await readRawFrontmatter(briefPath);
+  frontmatter2.updated = updated;
+  await writeFrontmatter(briefPath, frontmatter2, body, BriefFrontmatterSchema);
   return updated;
 }
 async function writeWrap(args, briefPath, body, ledger) {
@@ -2714,14 +2716,14 @@ var note_add_default = defineCommand({
       throw new NotFoundError(`Initiative not found: ${args.slug}`);
     }
     const body = args.body ?? await fs20.readFile(args.body_file, "utf8");
-    const frontmatter = {
+    const frontmatter2 = {
       kind: args.kind,
       title: args.title,
       created: today(),
       ...args.tags && args.tags.length > 0 ? { tags: args.tags } : {}
     };
     return withFileLock(getLockPath(args.slug), async () => {
-      const written = await writeNoteFile(initiativeDir, frontmatter, body);
+      const written = await writeNoteFile(initiativeDir, frontmatter2, body);
       return { ...written, kind: args.kind, title: args.title };
     });
   }
@@ -3059,13 +3061,13 @@ async function classifyWorktree(entry) {
   if (await isWorktreePresent(entry.path)) return { keep: true };
   return { keep: false, reason: "worktree path missing" };
 }
-async function partition(entries, classify2, describe2) {
+async function partition(entries, classify2, describe3) {
   const keep = [];
   const pruned = [];
   for (const entry of entries) {
     const verdict = await classify2(entry);
     if (verdict.keep) keep.push(entry);
-    else pruned.push({ ...describe2(entry), reason: verdict.reason });
+    else pruned.push({ ...describe3(entry), reason: verdict.reason });
   }
   return { keep, pruned };
 }
@@ -3411,9 +3413,9 @@ async function listSources(initiativeDir) {
   );
 }
 function extractSourceReferences(body) {
-  const matches = body.matchAll(/sources\/([A-Za-z0-9._/-]+\.md)/g);
+  const matches2 = body.matchAll(/sources\/([A-Za-z0-9._/-]+\.md)/g);
   const seen = /* @__PURE__ */ new Set();
-  for (const match of matches) {
+  for (const match of matches2) {
     seen.add(match[1]);
   }
   return [...seen].sort();
@@ -3557,9 +3559,9 @@ async function scanInitiatives(activeRoot) {
       continue;
     }
     try {
-      const { frontmatter } = await readFrontmatter(briefPath, BriefFrontmatterSchema);
+      const { frontmatter: frontmatter2 } = await readFrontmatter(briefPath, BriefFrontmatterSchema);
       const worktrees = await readRegisteredWorktrees(path32.join(activeRoot, slug));
-      entries.push({ slug, frontmatter, worktrees });
+      entries.push({ slug, frontmatter: frontmatter2, worktrees });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       errors.push({ slug, error: message });
@@ -3607,13 +3609,13 @@ var audit_default = defineCommand({
   async run() {
     const activeRoot = getActiveRoot();
     const { entries, errors } = await scanInitiatives(activeRoot);
-    const initiatives = [...entries].sort(compareInitiatives).map(({ slug, frontmatter }) => ({
+    const initiatives = [...entries].sort(compareInitiatives).map(({ slug, frontmatter: frontmatter2 }) => ({
       slug,
-      title: frontmatter.title,
-      state: frontmatter.state,
-      ...frontmatter.rank !== void 0 ? { rank: frontmatter.rank } : {},
-      updated: frontmatter.updated,
-      ...frontmatter.ship_target !== void 0 ? { ship_target: frontmatter.ship_target } : {}
+      title: frontmatter2.title,
+      state: frontmatter2.state,
+      ...frontmatter2.rank !== void 0 ? { rank: frontmatter2.rank } : {},
+      updated: frontmatter2.updated,
+      ...frontmatter2.ship_target !== void 0 ? { ship_target: frontmatter2.ship_target } : {}
     }));
     return {
       initiatives,
@@ -3736,12 +3738,12 @@ function matchBody(match, base, body) {
   return out;
 }
 function scanSessionFile(input, scan) {
-  const { slug, stem, rel, id, match, frontmatter, body } = input;
+  const { slug, stem, rel, id, match, frontmatter: frontmatter2, body } = input;
   const base = { slug, source: "session", file: rel };
-  if (id === stem || id === frontmatter.session_id) {
+  if (id === stem || id === frontmatter2.session_id) {
     scan.subject = { kind: "session", slug, file: rel, title: stem };
   }
-  frontmatter.next_steps.forEach((step, i) => {
+  frontmatter2.next_steps.forEach((step, i) => {
     if (`${stem}#${step.id}` === id) {
       scan.subject = { kind: "loop", slug, file: rel, title: step.text };
       return;
@@ -3753,7 +3755,7 @@ function scanSessionFile(input, scan) {
       ])
     );
   });
-  frontmatter.resolves.forEach((entry, i) => {
+  frontmatter2.resolves.forEach((entry, i) => {
     scan.references.push(
       ...matchFields(match, base, [
         [`resolves[${i}].ref`, entry.ref],
@@ -3768,12 +3770,12 @@ async function scanSessions(slug, id, match, scan) {
   for (const file of await listFiles(dir, ".md")) {
     const rel = path33.join("sessions", file);
     try {
-      const { frontmatter, body } = await readFrontmatter(
+      const { frontmatter: frontmatter2, body } = await readFrontmatter(
         path33.join(dir, file),
         SessionFrontmatterSchema
       );
       const stem = file.slice(0, -".md".length);
-      scanSessionFile({ slug, stem, rel, id, match, frontmatter, body }, scan);
+      scanSessionFile({ slug, stem, rel, id, match, frontmatter: frontmatter2, body }, scan);
     } catch (err) {
       scan.errors.push({ file: rel, error: errorText(err) });
     }
@@ -3897,9 +3899,9 @@ var list_default = defineCommand({
     const backburner = [];
     const paused = [];
     const done = [];
-    for (const { slug, frontmatter } of entries) {
-      const item = toItem(slug, frontmatter);
-      switch (frontmatter.state) {
+    for (const { slug, frontmatter: frontmatter2 } of entries) {
+      const item = toItem(slug, frontmatter2);
+      switch (frontmatter2.state) {
         case "focused":
           focused.push(item);
           break;
@@ -3986,10 +3988,10 @@ var worktree_set_default = defineCommand({
     const initiativeDir = path34.join(getActiveRoot(), args.slug);
     const briefPath = path34.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(args.slug), async () => {
-      let frontmatter;
+      let frontmatter2;
       let body;
       try {
-        ({ frontmatter, body } = await readFrontmatter(briefPath, BriefFrontmatterSchema));
+        ({ frontmatter: frontmatter2, body } = await readFrontmatter(briefPath, BriefFrontmatterSchema));
       } catch (err) {
         throw new ValidationError(err instanceof Error ? err.message : String(err));
       }
@@ -4022,7 +4024,7 @@ var worktree_set_default = defineCommand({
       });
       await writeFrontmatter(
         briefPath,
-        { ...frontmatter, updated: today() },
+        { ...frontmatter2, updated: today() },
         body,
         BriefFrontmatterSchema
       );
@@ -4060,10 +4062,10 @@ var worktree_set_default_default = defineCommand({
     const initiativeDir = path35.join(getActiveRoot(), slug);
     const briefPath = path35.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(slug), async () => {
-      let frontmatter;
+      let frontmatter2;
       let body;
       try {
-        ({ frontmatter, body } = await readFrontmatter(briefPath, BriefFrontmatterSchema));
+        ({ frontmatter: frontmatter2, body } = await readFrontmatter(briefPath, BriefFrontmatterSchema));
       } catch (err) {
         throw new ValidationError(err instanceof Error ? err.message : String(err));
       }
@@ -4079,7 +4081,7 @@ var worktree_set_default_default = defineCommand({
       await writeArtifactsFile(initiativeDir, { ...artifacts, worktrees });
       await writeFrontmatter(
         briefPath,
-        { ...frontmatter, updated: today() },
+        { ...frontmatter2, updated: today() },
         body,
         BriefFrontmatterSchema
       );
@@ -5198,22 +5200,145 @@ import { watchTree } from "@titan-design/daemon";
 
 // src/session-index/graph.ts
 import Database from "better-sqlite3";
-import { MIGRATIONS, openSessionGraph } from "@titan-design/session-graph";
+import { openSessionGraph } from "@titan-design/session-graph";
+import { runMigrations, WatermarkTable } from "@titan-design/store-sqlite";
 import path46 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 path46.join(getMinerRoot(), "graph.sqlite3");
 }
 function openGraph(dbPath = defaultGraphPath()) {
-  return openSessionGraph(dbPath);
+  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/session-index/refresh.ts
-import path48 from "path";
-import { promises as fs36 } from "fs";
+import path56 from "path";
+import { promises as fs44 } from "fs";
 import lockfile from "proper-lockfile";
 import { discoverTranscripts, transcriptsRoot } from "@titan-design/session-read";
 import { refreshCorpus, resetIndex } from "@titan-design/session-graph";
@@ -5274,6 +5399,873 @@ function taskResolver(root) {
   };
 }
 
+// src/workspace-index/refresh.ts
+import { promises as fs43 } from "fs";
+import matter4 from "gray-matter";
+
+// src/workspace-index/refs.ts
+import path48 from "path";
+import { refKind } from "@titan-design/store-sqlite";
+var initiativeRef = refKind("initiative");
+var noteRef = refKind("note");
+var taskRef = refKind("task");
+var sessionRef = refKind("session");
+var sourceRef = refKind("source");
+function toRelative(activeRoot, absolutePath) {
+  return path48.relative(activeRoot, absolutePath).split(path48.sep).join("/");
+}
+function toAbsolute(activeRoot, relativePath) {
+  return path48.join(activeRoot, ...relativePath.split("/"));
+}
+
+// src/workspace-index/mentions.ts
+var TASK_ID = /(?<![A-Za-z0-9])([A-Za-z][A-Za-z0-9]*-\d+)(?![A-Za-z0-9])/g;
+var SESSION_ID = /(?<![A-Za-z0-9_-])(session_[A-Za-z0-9]+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?![A-Za-z0-9-])/gi;
+var NOTE_REF = /(?<![A-Za-z0-9])note:([A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\.md)/g;
+var SOURCE_PATH = /sources\/([A-Za-z0-9._/-]+\.md)/g;
+function matches(body, pattern) {
+  return [...body.matchAll(pattern)].map((match) => match[1]);
+}
+function extractMentions(body, initiative, index) {
+  const found = /* @__PURE__ */ new Set();
+  for (const id of matches(body, TASK_ID)) {
+    if (index.taskIds.has(id.toUpperCase())) found.add(taskRef(id.toUpperCase()));
+  }
+  for (const id of matches(body, SESSION_ID)) {
+    if (index.sessionIds.has(id)) found.add(sessionRef(id));
+  }
+  for (const id of matches(body, NOTE_REF)) {
+    if (index.noteRefs.has(noteRef(id))) found.add(noteRef(id));
+  }
+  for (const path67 of matches(body, SOURCE_PATH)) {
+    const scoped = `${initiative}/${path67}`;
+    if (index.sourcePaths.has(scoped)) found.add(sourceRef(scoped));
+  }
+  return [...found].sort();
+}
+
+// src/workspace-index/edges.ts
+var RELATIONS = {
+  HOLDS: "holds",
+  MENTIONS: "mentions",
+  SHARES_TAG: "shares_tag"
+};
+var SHARES_TAG_MAX_NOTES = 10;
+function rebuildEdges(graph, notes) {
+  const relations = Object.values(RELATIONS);
+  const placeholders = relations.map(() => "?").join(", ");
+  return graph.db.transaction(() => {
+    graph.db.prepare(`DELETE FROM edge WHERE relation IN (${placeholders})`).run(...relations);
+    return {
+      holds: assertHolds(graph),
+      mentions: assertMentions(graph, notes),
+      sharesTag: assertSharesTag(graph, notes)
+    };
+  })();
+}
+var OWNED_REFS = `
+  SELECT note_ref    AS ref, initiative FROM note
+  UNION ALL SELECT task_ref    AS ref, initiative FROM workspace_task
+  UNION ALL SELECT session_ref AS ref, initiative FROM session_record
+  UNION ALL SELECT source_ref  AS ref, initiative FROM source
+`;
+function assertHolds(graph) {
+  const rows = graph.db.prepare(OWNED_REFS).all();
+  let written = 0;
+  for (const row of rows) {
+    const inserted = graph.edges.assert({
+      sourceRef: initiativeRef(row.initiative),
+      relation: RELATIONS.HOLDS,
+      targetRef: row.ref
+    });
+    if (inserted) written++;
+  }
+  return written;
+}
+function assertMentions(graph, notes) {
+  const index = buildRefIndex(graph);
+  let written = 0;
+  for (const note of notes) {
+    for (const target of extractMentions(note.body, note.initiative, index)) {
+      if (target === note.ref) continue;
+      const inserted = graph.edges.assert({
+        sourceRef: note.ref,
+        relation: RELATIONS.MENTIONS,
+        targetRef: target
+      });
+      if (inserted) written++;
+    }
+  }
+  return written;
+}
+function buildRefIndex(graph) {
+  const column = (sql) => graph.db.prepare(sql).all().map((row) => row.value);
+  return {
+    taskIds: new Set(column("SELECT DISTINCT task_id AS value FROM workspace_task")),
+    sessionIds: new Set(column("SELECT DISTINCT session_id AS value FROM session_record")),
+    noteRefs: new Set(column("SELECT note_ref AS value FROM note")),
+    // `source:` is 7 characters; what remains is the `<slug>/<path>` the ref was minted from.
+    sourcePaths: new Set(column("SELECT substr(source_ref, 8) AS value FROM source"))
+  };
+}
+function assertSharesTag(graph, notes) {
+  let written = 0;
+  for (const group of qualifyingTagGroups(notes)) {
+    for (const [a, b] of crossInitiativePairs(group)) {
+      for (const edge of [
+        { sourceRef: a.ref, targetRef: b.ref },
+        { sourceRef: b.ref, targetRef: a.ref }
+      ]) {
+        if (graph.edges.assert({ ...edge, relation: RELATIONS.SHARES_TAG })) written++;
+      }
+    }
+  }
+  return written;
+}
+function qualifyingTagGroups(notes) {
+  const byTag = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    for (const tag of new Set(note.tags)) {
+      const group = byTag.get(tag);
+      if (group) group.push(note);
+      else byTag.set(tag, [note]);
+    }
+  }
+  return [...byTag.values()].filter(
+    (group) => group.length <= SHARES_TAG_MAX_NOTES && new Set(group.map((note) => note.initiative)).size > 1
+  );
+}
+function crossInitiativePairs(group) {
+  const sorted = [...group].sort((a, b) => a.ref.localeCompare(b.ref));
+  const pairs = [];
+  for (let i = 0; i < sorted.length; i++) {
+    for (let j = i + 1; j < sorted.length; j++) {
+      if (sorted[i].initiative !== sorted[j].initiative) pairs.push([sorted[i], sorted[j]]);
+    }
+  }
+  return pairs;
+}
+
+// src/workspace-index/read.ts
+import { promises as fs36 } from "fs";
+import matter3 from "gray-matter";
+import YAML from "yaml";
+
+// src/workspace-index/spans.ts
+var FRONTMATTER_FENCE = /^---\r?\n/;
+var FRONTMATTER_END = /^---[ \t]*\r?$/;
+function bodyByteOffset(raw) {
+  if (!FRONTMATTER_FENCE.test(raw)) return 0;
+  const lines = raw.split("\n");
+  let consumed = lines[0].length + 1;
+  for (let i = 1; i < lines.length; i++) {
+    consumed += lines[i].length + 1;
+    if (FRONTMATTER_END.test(lines[i])) return Buffer.byteLength(raw.slice(0, consumed), "utf8");
+  }
+  return 0;
+}
+function wholeFile(raw) {
+  return { byteOffset: 0, byteLength: Buffer.byteLength(raw, "utf8") };
+}
+function locate(raw, field, text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return null;
+  const at = raw.indexOf(trimmed);
+  if (at < 0) return { field, text: trimmed, ...wholeFile(raw) };
+  return {
+    field,
+    text: trimmed,
+    byteOffset: Buffer.byteLength(raw.slice(0, at), "utf8"),
+    byteLength: Buffer.byteLength(trimmed, "utf8")
+  };
+}
+function sectionSpans(body, baseByteOffset, field = "body") {
+  const spans = [];
+  let cursor = baseByteOffset;
+  for (const section of splitOnHeadings(body)) {
+    const byteLength = Buffer.byteLength(section, "utf8");
+    if (section.trim().length > 0) {
+      spans.push({ field, text: section, byteOffset: cursor, byteLength });
+    }
+    cursor += byteLength;
+  }
+  return spans;
+}
+function splitOnHeadings(body) {
+  const lines = body.split("\n");
+  const sections = [];
+  let current = [];
+  for (const line of lines) {
+    if (/^#{1,6}\s/.test(line) && current.length > 0) {
+      sections.push(current.join("\n") + "\n");
+      current = [];
+    }
+    current.push(line);
+  }
+  if (current.length > 0) sections.push(current.join("\n"));
+  return sections;
+}
+
+// src/workspace-index/read.ts
+var READERS = {
+  initiative: readInitiative2,
+  note: readNote,
+  task: readTask,
+  session: readSession2,
+  source: readSource
+};
+async function readRecord(file) {
+  const raw = await fs36.readFile(file.absolutePath, "utf8");
+  return READERS[file.class](file, raw);
+}
+function frontmatter(raw) {
+  const parsed = matter3(raw);
+  return { data: coerceDates(parsed.data), body: parsed.content };
+}
+function jsonTags(tags) {
+  return tags.length === 0 ? null : JSON.stringify(tags);
+}
+function readInitiative2(file, raw) {
+  const { data, body } = frontmatter(raw);
+  const brief = BriefFrontmatterSchema.parse(data);
+  const lead = firstProse(body);
+  return {
+    file,
+    ref: initiativeRef(file.slug),
+    row: {
+      slug: file.slug,
+      title: brief.title,
+      state: brief.state,
+      rank: brief.rank ?? null,
+      ship_target: brief.ship_target ?? null,
+      owner: brief.owner ?? null,
+      task_prefix: brief.task_prefix,
+      updated: brief.updated
+    },
+    spans: compact([
+      locate(raw, "title", brief.title),
+      lead === void 0 ? null : locate(raw, "body", lead)
+    ]),
+    tags: [],
+    body: ""
+  };
+}
+function readNote(file, raw) {
+  const { data, body } = frontmatter(raw);
+  const note = NoteFrontmatterSchema.parse(data);
+  const tags = note.tags ?? [];
+  return {
+    file,
+    ref: noteRef(`${file.slug}/${basename(file.path)}`),
+    row: {
+      initiative: file.slug,
+      filename: basename(file.path),
+      kind: note.kind,
+      title: note.title,
+      created: note.created,
+      tags: jsonTags(tags),
+      // `hits` and `promoted_at` are the promotion machinery of the design's
+      // §4 and the one thing here not derivable from the files, so a rebuild
+      // resets them to zero. Owner accepted that on 2026-09-10.
+      hits: 0,
+      promoted_at: null
+    },
+    spans: [
+      ...compact([locate(raw, "title", note.title)]),
+      ...sectionSpans(body, bodyByteOffset(raw))
+    ],
+    tags,
+    body
+  };
+}
+function readTask(file, raw) {
+  const task = TaskSchema.parse(coerceDates(YAML.parse(raw)));
+  return {
+    file,
+    ref: taskRef(task.id),
+    row: {
+      initiative: file.slug,
+      task_id: task.id,
+      title: task.title,
+      status: task.status,
+      priority: task.priority,
+      severity: task.severity ?? null,
+      estimate: task.estimate ?? null,
+      tags: jsonTags(task.tags ?? []),
+      created: task.created,
+      updated: task.updated,
+      done_at: task.done_at
+    },
+    spans: compact([
+      locate(raw, "title", task.title),
+      task.done_when !== void 0 && locate(raw, "done_when", task.done_when),
+      task.notes !== void 0 && locate(raw, "notes", task.notes)
+    ]),
+    tags: [],
+    body: ""
+  };
+}
+function readSession2(file, raw) {
+  const { data, body } = frontmatter(raw);
+  const session = SessionFrontmatterSchema.parse(data);
+  return {
+    file,
+    ref: sessionRef(session.session_id),
+    row: {
+      initiative: file.slug,
+      session_id: session.session_id,
+      started: session.started,
+      ended: session.ended,
+      track: session.track,
+      parent_session_id: session.parent_session_id ?? null
+    },
+    spans: sectionSpans(body, bodyByteOffset(raw)),
+    tags: [],
+    body: ""
+  };
+}
+function readSource(file, raw) {
+  const title = firstHeading2(raw) ?? basename(file.path).replace(/\.md$/, "");
+  return {
+    file,
+    ref: sourceRef(`${file.slug}/${sourcesRelative(file.path)}`),
+    row: {
+      initiative: file.slug,
+      title,
+      kind: inferSourceKind(basename(file.path)),
+      added: null
+    },
+    spans: [...compact([locate(raw, "title", title)]), ...sectionSpans(raw, 0)],
+    tags: [],
+    body: ""
+  };
+}
+var PR_FILENAME2 = /^pr-\d+-/;
+var DEEPDIVE_FILENAME2 = /^deepdive-/;
+var SESSION_FILENAME2 = /^\d{4}-\d{2}-\d{2}-/;
+function inferSourceKind(filename) {
+  if (PR_FILENAME2.test(filename)) return "pr";
+  if (DEEPDIVE_FILENAME2.test(filename)) return "deepdive";
+  if (SESSION_FILENAME2.test(filename)) return "session";
+  return "pointer";
+}
+function basename(relativePath) {
+  return relativePath.slice(relativePath.lastIndexOf("/") + 1);
+}
+function sourcesRelative(relativePath) {
+  return relativePath.replace(/^[^/]+\/sources\//, "");
+}
+function firstHeading2(text) {
+  for (const line of text.split("\n", 200)) {
+    const match = /^#{1,6}\s+(.+?)\s*$/.exec(line);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+function firstProse(body) {
+  for (const block of body.split(/\n\s*\n/)) {
+    const trimmed = block.trim();
+    if (trimmed.length > 0 && !trimmed.startsWith("#")) return trimmed;
+  }
+  return void 0;
+}
+function compact(spans) {
+  return spans.filter((span) => Boolean(span));
+}
+
+// src/workspace-index/scan.ts
+import { promises as fs42 } from "fs";
+import path55 from "path";
+
+// src/lint/index.ts
+import { promises as fs41 } from "fs";
+import path54 from "path";
+
+// src/lint/brief.ts
+import { promises as fs37 } from "fs";
+import path49 from "path";
+
+// src/lint/hashes.ts
+import { promises as fs38 } from "fs";
+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(path50.join(initiativeDir, relPath), "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") continue;
+      throw err;
+    }
+    if (hashContent(content) === storedHash) continue;
+    findings.push({
+      level: "warn",
+      slug,
+      file: relPath,
+      message: `${relPath} was hand-edited outside active-work (content no longer matches the last CLI write) \u2014 re-apply the change through the CLI/MCP tools instead of editing the file directly`
+    });
+  }
+  return findings;
+}
+
+// src/lint/open-loops.ts
+import path51 from "path";
+
+// src/lint/task.ts
+import { promises as fs39 } from "fs";
+import path52 from "path";
+import YAML2 from "yaml";
+
+// src/lint/zero-loops.ts
+import { promises as fs40 } from "fs";
+import path53 from "path";
+import YAML3 from "yaml";
+
+// src/lint/index.ts
+async function listInitiativeSlugs2(activeRoot) {
+  let entries;
+  try {
+    entries = await fs41.readdir(activeRoot, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return [];
+    throw err;
+  }
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+}
+
+// src/workspace-index/scan.ts
+async function readDirents(dir) {
+  try {
+    return await fs42.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function isVisible(entry, extensions) {
+  return entry.isFile() && !entry.name.startsWith(".") && extensions.some((ext) => entry.name.endsWith(ext));
+}
+async function filesIn(dir, extensions) {
+  const entries = await readDirents(dir);
+  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(path55.join(tasksDir, "archive"), [".yml", ".yaml"]);
+  return [...own, ...archive];
+}
+async function collectSlug(activeRoot, slug) {
+  const dir = path55.join(activeRoot, slug);
+  const brief = path55.join(dir, "brief.md");
+  const [notes, tasks, sessions2, sources] = await Promise.all([
+    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]),
+    ...tasks.map((p) => ["task", p]),
+    ...sessions2.map((p) => ["session", p]),
+    ...sources.map((p) => ["source", p]),
+    ...await exists2(brief) ? [["initiative", brief]] : []
+  ];
+}
+async function exists2(target) {
+  try {
+    await fs42.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function describe(activeRoot, slug, entry) {
+  const [cls, absolutePath] = entry;
+  try {
+    const stat = await fs42.stat(absolutePath);
+    return {
+      class: cls,
+      slug,
+      path: toRelative(activeRoot, absolutePath),
+      absolutePath,
+      size: stat.size,
+      mtime: stat.mtime.toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+async function scanWorkspace(activeRoot) {
+  const slugs = await listInitiativeSlugs2(activeRoot);
+  const perSlug = await Promise.all(
+    slugs.map(async (slug) => {
+      const entries = await collectSlug(activeRoot, slug);
+      const described = await Promise.all(entries.map((e) => describe(activeRoot, slug, e)));
+      return described.filter((file) => file !== null);
+    })
+  );
+  return perSlug.flat().sort((a, b) => a.path.localeCompare(b.path));
+}
+
+// src/workspace-index/write.ts
+var TABLES = {
+  initiative: {
+    table: "initiative",
+    refColumn: "initiative_ref",
+    columns: ["slug", "title", "state", "rank", "ship_target", "owner", "task_prefix", "updated"]
+  },
+  note: {
+    table: "note",
+    refColumn: "note_ref",
+    columns: ["initiative", "filename", "kind", "title", "created", "tags", "hits", "promoted_at"]
+  },
+  task: {
+    table: "workspace_task",
+    refColumn: "task_ref",
+    columns: [
+      "initiative",
+      "task_id",
+      "title",
+      "status",
+      "priority",
+      "severity",
+      "estimate",
+      "tags",
+      "created",
+      "updated",
+      "done_at"
+    ]
+  },
+  session: {
+    table: "session_record",
+    refColumn: "session_ref",
+    columns: ["initiative", "session_id", "started", "ended", "track", "parent_session_id"]
+  },
+  source: {
+    table: "source",
+    refColumn: "source_ref",
+    columns: ["initiative", "title", "kind", "added"]
+  }
+};
+var CLASSES = Object.keys(TABLES);
+function insertSql({ table, refColumn, columns }) {
+  const all = ["path", refColumn, ...columns];
+  const names = all.map((c) => `"${c}"`).join(", ");
+  return `INSERT OR REPLACE INTO "${table}" (${names}) VALUES (${all.map(() => "?").join(", ")})`;
+}
+function spanSourceId(watermarkId) {
+  return WORKSPACE_SPAN_SOURCE_BASE + watermarkId;
+}
+var WorkspaceWriter = class {
+  constructor(graph) {
+    this.graph = graph;
+    this.inserts = Object.fromEntries(
+      CLASSES.map((cls) => [cls, graph.db.prepare(insertSql(TABLES[cls]))])
+    );
+    this.deletes = CLASSES.map(
+      (cls) => graph.db.prepare(`DELETE FROM "${TABLES[cls].table}" WHERE path = ?`)
+    );
+    this.deleteSpans = graph.db.prepare("DELETE FROM search_span WHERE source_id = ?");
+  }
+  graph;
+  inserts;
+  deletes;
+  deleteSpans;
+  /**
+   * Delete every row and span one file produced.
+   *
+   * Spans go by `source_id`, not by owner ref: `session:` owners are shared
+   * with the transcript side of the same table, so purging by owner would take
+   * a mined transcript's spans with it. The offset id names the file alone.
+   *
+   * This is the *opposite* of the transcript policy in the same database. A
+   * transcript that disappears keeps its rows on purpose — Claude Code prunes
+   * transcripts, and the sessions they witnessed still happened. A workspace
+   * file that disappears was deleted or archived by the operator, and its rows
+   * are a claim about a file that no longer says anything.
+   */
+  purge(relativePath, watermarkId) {
+    for (const statement of this.deletes) statement.run(relativePath);
+    this.deleteSpans.run(spanSourceId(watermarkId));
+  }
+  /**
+   * Write one record's row and spans, replacing whatever the file produced
+   * before. Not transactional on its own — the caller batches many of these
+   * into one transaction, because a WAL commit per file is the difference
+   * between a pass that runs in a moment and one that does not.
+   */
+  apply(record, watermarkId) {
+    const spec = TABLES[record.file.class];
+    this.purge(record.file.path, watermarkId);
+    this.inserts[record.file.class].run(
+      record.file.path,
+      record.ref,
+      ...spec.columns.map((column) => record.row[column] ?? null)
+    );
+    for (const span of record.spans) {
+      this.graph.spans.index(
+        {
+          ownerRef: record.ref,
+          field: span.field,
+          sourceId: spanSourceId(watermarkId),
+          byteOffset: span.byteOffset,
+          byteLength: span.byteLength
+        },
+        span.text
+      );
+    }
+  }
+};
+function resetWorkspaceIndex(graph) {
+  graph.db.transaction(() => {
+    for (const cls of CLASSES) graph.db.exec(`DELETE FROM "${TABLES[cls].table}"`);
+    for (const row of graph.workspaceFiles.list()) graph.workspaceFiles.rewind(row.sourceKey);
+  })();
+}
+
+// src/workspace-index/refresh.ts
+function isUnchanged(row, file) {
+  return row.lastOffset > 0 && row.fileSize === file.size && row.fileMtime === file.mtime;
+}
+var BATCH = 200;
+async function readAttempt(file, watermarkId) {
+  try {
+    return { file, watermarkId, record: await readRecord(file), reason: null };
+  } catch (err) {
+    return {
+      file,
+      watermarkId,
+      record: null,
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function applyBatch(graph, writer, batch) {
+  graph.db.transaction(() => {
+    for (const attempt of batch) {
+      if (attempt.record === null) {
+        writer.purge(attempt.file.path, attempt.watermarkId);
+        graph.workspaceFiles.markStatus(attempt.file.path, "quarantined", attempt.reason);
+        continue;
+      }
+      writer.apply(attempt.record, attempt.watermarkId);
+      graph.workspaceFiles.advance(attempt.file.path, {
+        lastOffset: attempt.file.size,
+        fileSize: attempt.file.size,
+        fileMtime: attempt.file.mtime
+      });
+    }
+  })();
+}
+function removeVanished(graph, writer, present) {
+  let removed = 0;
+  for (const row of graph.workspaceFiles.list()) {
+    if (present.has(row.sourceKey)) continue;
+    writer.purge(row.sourceKey, row.sourceId);
+    graph.db.prepare("DELETE FROM workspace_file WHERE source_id = ?").run(row.sourceId);
+    removed++;
+  }
+  return removed;
+}
+async function collectNoteFacts(activeRoot, graph) {
+  const rows = graph.db.prepare("SELECT path, note_ref, initiative, tags FROM note ORDER BY path").all();
+  const facts = await Promise.all(
+    rows.map(async (row) => ({
+      ref: row.note_ref,
+      initiative: row.initiative,
+      tags: JSON.parse(row.tags ?? "[]") ?? [],
+      body: await readBody(toAbsolute(activeRoot, row.path))
+    }))
+  );
+  return facts;
+}
+async function readBody(absolutePath) {
+  try {
+    return matter4(await fs43.readFile(absolutePath, "utf8")).content;
+  } catch {
+    return "";
+  }
+}
+function countRows(graph) {
+  const count = (table) => graph.db.prepare(`SELECT COUNT(*) AS n FROM "${table}"`).get().n;
+  return {
+    initiative: count("initiative"),
+    note: count("note"),
+    task: count("workspace_task"),
+    session: count("session_record"),
+    source: count("source")
+  };
+}
+async function refreshWorkspace(graph, options = {}) {
+  const activeRoot = options.activeRoot ?? getActiveRoot();
+  const writer = new WorkspaceWriter(graph);
+  const files = await scanWorkspace(activeRoot);
+  const malformed = [];
+  let indexed = 0;
+  let unchanged = 0;
+  const changed = [];
+  graph.db.transaction(() => {
+    for (const file of files) {
+      const row = graph.workspaceFiles.ensure(file.path);
+      if (!options.full && isUnchanged(row, file)) unchanged++;
+      else changed.push({ file, watermarkId: row.sourceId });
+    }
+  })();
+  for (let start = 0; start < changed.length; start += BATCH) {
+    const batch = await Promise.all(
+      changed.slice(start, start + BATCH).map((e) => readAttempt(e.file, e.watermarkId))
+    );
+    applyBatch(graph, writer, batch);
+    indexed += batch.filter((a) => a.record !== null).length;
+    for (const failed of batch.filter((a) => a.record === null)) {
+      malformed.push({ path: failed.file.path, reason: failed.reason ?? "unreadable" });
+    }
+  }
+  const removed = removeVanished(graph, writer, new Set(files.map((f) => f.path)));
+  const edges = rebuildEdges(graph, await collectNoteFacts(activeRoot, graph));
+  return {
+    files: files.length,
+    indexed,
+    unchanged,
+    removed,
+    malformed,
+    rows: countRows(graph),
+    edges,
+    orphanRatio: graph.spans.orphanRatio()
+  };
+}
+
+// src/session-index/preserve.ts
+var UPSERT = `
+  INSERT INTO preserved_row (table_name, identity, row_key, payload, origin, mode)
+  VALUES (@table, @identity, @key, @payload, @origin, @mode)
+  ON CONFLICT (table_name, row_key) DO UPDATE SET
+    identity = excluded.identity, payload = excluded.payload,
+    origin = excluded.origin, mode = excluded.mode
+`;
+function preserveRow(graph, row) {
+  if (row.identity.length === 0) throw new Error(`preserveRow: ${row.table} needs an identity`);
+  if (row.mode === "merge" && row.identity.length !== 1) {
+    throw new Error(`preserveRow: a merge over ${row.table} matches exactly one column`);
+  }
+  const missing = row.mode === "insert" ? row.identity.filter((c) => !(c in row.payload)) : [];
+  if (missing.length > 0) {
+    throw new Error(`preserveRow: ${row.table} payload is missing ${missing.join(", ")}`);
+  }
+  graph.db.prepare(UPSERT).run({
+    ...row,
+    identity: JSON.stringify(row.identity),
+    payload: JSON.stringify(row.payload)
+  });
+}
+function listPreserved(graph) {
+  const rows = graph.db.prepare("SELECT * FROM preserved_row ORDER BY table_name, row_key").all();
+  return rows.map((row) => ({
+    table: row.table_name,
+    identity: JSON.parse(row.identity),
+    key: row.row_key,
+    payload: JSON.parse(row.payload),
+    origin: row.origin,
+    mode: row.mode
+  }));
+}
+var UNREACHABLE_SESSIONS = `
+  SELECT s.session_id FROM session s
+   WHERE NOT EXISTS (
+     SELECT 1 FROM fact f JOIN transcript t ON t.source_id = f.transcript_id
+      WHERE f.session_id = s.session_id AND t.status = 'ok'
+   )
+   ORDER BY s.session_id
+`;
+var SESSION_OWNED = [
+  { table: "session", identity: ["session_id"], key: (r) => String(r.session_id) },
+  { table: "turn", identity: ["prompt_id"], key: (r) => String(r.prompt_id) },
+  {
+    table: "session_model_usage",
+    identity: ["session_id", "model"],
+    key: (r) => `${r.session_id}:${r.model}`
+  },
+  {
+    table: "fact",
+    identity: ["transcript_id", "byte_offset"],
+    key: (r) => `${r.transcript_id}:${r.byte_offset}`
+  },
+  {
+    table: "permission_phase",
+    identity: ["session_id", "t_valid", "to_mode"],
+    key: (r) => `${r.session_id}:${r.t_valid}:${r.to_mode}`
+  },
+  {
+    table: "human_edit",
+    identity: ["session_id", "file_path", "ts"],
+    key: (r) => `${r.session_id}:${r.file_path}:${r.ts}`
+  }
+];
+var SYNTHETIC_KEYS = /* @__PURE__ */ new Set(["fact_id", "phase_id", "edit_id", "checkpoint_id"]);
+function payloadOf(row) {
+  return Object.fromEntries(Object.entries(row).filter(([column]) => !SYNTHETIC_KEYS.has(column)));
+}
+function preserveUnreachable(graph, origin) {
+  const ids = graph.db.prepare(UNREACHABLE_SESSIONS).all().map(
+    (row) => row.session_id
+  );
+  if (ids.length === 0) return 0;
+  const placeholders = ids.map(() => "?").join(", ");
+  let preserved = 0;
+  graph.db.transaction(() => {
+    for (const spec of SESSION_OWNED) {
+      const rows = graph.db.prepare(`SELECT * FROM "${spec.table}" WHERE session_id IN (${placeholders})`).all(...ids);
+      for (const row of rows) {
+        const payload = payloadOf(row);
+        preserveRow(graph, {
+          table: spec.table,
+          identity: spec.identity,
+          key: spec.key(row),
+          payload,
+          origin,
+          mode: "insert"
+        });
+        preserved++;
+      }
+    }
+  })();
+  return preserved;
+}
+function restore(graph, row) {
+  const columns = Object.keys(row.payload);
+  const names = columns.map((c) => `"${c}"`).join(", ");
+  const values = columns.map((c) => `@${c}`).join(", ");
+  const match = row.identity.map((c) => `"${c}" IS @${c}`).join(" AND ");
+  const info = graph.db.prepare(
+    `INSERT INTO "${row.table}" (${names}) SELECT ${values}
+        WHERE NOT EXISTS (SELECT 1 FROM "${row.table}" WHERE ${match})`
+  ).run(row.payload);
+  return info.changes > 0;
+}
+function merge(graph, row) {
+  const assignments = Object.keys(row.payload).map((c) => `"${c}" = @${c}`).join(", ");
+  const info = graph.db.prepare(`UPDATE "${row.table}" SET ${assignments} WHERE "${row.identity[0]}" = @__key`).run({ ...row.payload, __key: row.key });
+  return info.changes > 0;
+}
+function replayPreserved(graph) {
+  const summary = { restored: 0, merged: 0, skipped: 0 };
+  graph.db.transaction(() => {
+    for (const row of listPreserved(graph)) {
+      if (row.mode === "merge") {
+        if (merge(graph, row)) summary.merged++;
+        else summary.skipped++;
+        continue;
+      }
+      if (restore(graph, row)) summary.restored++;
+      else summary.skipped++;
+    }
+  })();
+  return summary;
+}
+
 // src/session-index/refresh.ts
 var LOCK_STALE_MS = 6e4;
 function refreshLockPath() {
@@ -5281,8 +6273,8 @@ function refreshLockPath() {
 }
 async function withRefreshLock(fn) {
   const target = refreshLockPath();
-  await fs36.mkdir(path48.dirname(target), { recursive: true });
-  await fs36.writeFile(target, "", { flag: "a" });
+  await fs44.mkdir(path56.dirname(target), { recursive: true });
+  await fs44.writeFile(target, "", { flag: "a" });
   const release = await lockfile.lock(target, {
     realpath: false,
     stale: LOCK_STALE_MS,
@@ -5300,7 +6292,11 @@ async function runRefresh(options = {}) {
   const graph = options.graph ?? openGraph(options.dbPath ?? defaultGraphPath());
   const owned = options.graph === void 0;
   try {
-    if (options.full) resetIndex(graph);
+    if (options.full) {
+      preserveUnreachable(graph, "transcript pruned before this rebuild (TP-41)");
+      resetIndex(graph);
+      resetWorkspaceIndex(graph);
+    }
     const discovered = await discoverTranscripts(options.root ?? transcriptsRoot());
     const visiting = discovered.slice(0, options.limit ?? discovered.length);
     const verify = options.verifyHashes ?? options.full ?? false;
@@ -5310,6 +6306,11 @@ async function runRefresh(options = {}) {
       withContentHash: verify,
       resolveTasks: taskResolver(options.taskRoot)
     });
+    const workspace = options.skipWorkspace ? null : await refreshWorkspace(graph, {
+      activeRoot: options.activeRoot ?? options.taskRoot,
+      full: options.full
+    });
+    const preserved = replayPreserved(graph);
     return {
       startedAt: startedAt2,
       durationMs: Date.now() - started,
@@ -5325,9 +6326,14 @@ async function runRefresh(options = {}) {
       turnsRolledUp: summary.turnsRolledUp,
       tasksRequested: summary.tasks.requested,
       tasksApplied: summary.tasks.applied,
+      workspace,
+      preserved,
       errors: [
         ...summary.tasks.failed ? [`tasks: ${summary.tasks.error ?? "resolver failed"}`] : [],
-        ...quarantineErrors(graph)
+        ...quarantineErrors(graph),
+        ...(workspace?.malformed ?? []).map(
+          (entry) => `workspace: ${entry.path} \u2014 ${entry.reason}`
+        )
       ]
     };
   } finally {
@@ -5798,8 +6804,8 @@ var mcp_status_default = defineCommand({
 });
 
 // src/commands/mcp-logs.ts
-import { promises as fs37 } from "fs";
-import path49 from "path";
+import { promises as fs45 } from "fs";
+import path57 from "path";
 import { z as z46 } from "zod";
 var ArgsSchema42 = z46.object({
   lines: z46.number().int().positive().optional()
@@ -5823,10 +6829,10 @@ var mcp_logs_default = defineCommand({
   },
   async run(args) {
     const n = args.lines ?? DEFAULT_LINES;
-    const logPath = path49.join(getStateRoot(), "daemon.log");
+    const logPath = path57.join(getStateRoot(), "daemon.log");
     let content;
     try {
-      content = await fs37.readFile(logPath, "utf8");
+      content = await fs45.readFile(logPath, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") {
         return { lines: [] };
@@ -5852,8 +6858,8 @@ import { discoverTranscripts as discoverTranscripts2, transcriptsRoot as transcr
 import { Clusterer } from "@titan-design/cluster";
 
 // src/drain/store.ts
-import { promises as fs38 } from "fs";
-import path50 from "path";
+import { promises as fs46 } from "fs";
+import path58 from "path";
 
 // src/schemas/template.ts
 import { z as z47 } from "zod";
@@ -5883,10 +6889,10 @@ var TemplatesFileSchema = z47.object({
 
 // src/drain/store.ts
 function templatesPath(root) {
-  return path50.join(root, "templates.yml");
+  return path58.join(root, "templates.yml");
 }
 function occurrencesPath(root) {
-  return path50.join(root, "occurrences.jsonl");
+  return path58.join(root, "occurrences.jsonl");
 }
 async function loadTemplates(root = getMinerRoot()) {
   try {
@@ -5898,15 +6904,15 @@ async function loadTemplates(root = getMinerRoot()) {
   }
 }
 async function saveTemplates(templates, root = getMinerRoot()) {
-  await fs38.mkdir(root, { recursive: true });
+  await fs46.mkdir(root, { recursive: true });
   await writeYaml(templatesPath(root), { templates }, TemplatesFileSchema);
 }
 async function appendOccurrence(occurrence, root = getMinerRoot()) {
   const parsed = OccurrenceSchema.parse(occurrence);
   const target = occurrencesPath(root);
-  await fs38.mkdir(root, { recursive: true });
+  await fs46.mkdir(root, { recursive: true });
   await withFileLock(`${target}.lock`, async () => {
-    await fs38.appendFile(target, `${JSON.stringify(parsed)}
+    await fs46.appendFile(target, `${JSON.stringify(parsed)}
 `, "utf8");
   });
 }
@@ -5914,17 +6920,17 @@ async function appendOccurrences(occurrences, root = getMinerRoot()) {
   if (occurrences.length === 0) return;
   const parsed = occurrences.map((o) => OccurrenceSchema.parse(o));
   const target = occurrencesPath(root);
-  await fs38.mkdir(root, { recursive: true });
+  await fs46.mkdir(root, { recursive: true });
   const body = `${parsed.map((o) => JSON.stringify(o)).join("\n")}
 `;
   await withFileLock(`${target}.lock`, async () => {
-    await fs38.appendFile(target, body, "utf8");
+    await fs46.appendFile(target, body, "utf8");
   });
 }
 
 // src/drain/tree-store.ts
-import { promises as fs39 } from "fs";
-import path51 from "path";
+import { promises as fs47 } from "fs";
+import path59 from "path";
 import { z as z48 } from "zod";
 var PartitionSchema = z48.object({
   partition: z48.string().min(1),
@@ -5948,7 +6954,7 @@ var LegacySnapshotFileSchema = z48.object({
   trees: z48.array(PartitionSchema.omit({ partition: true }).extend({ toolType: z48.string().min(1) }))
 });
 function snapshotPath(root) {
-  return path51.join(root, "drain-trees.json");
+  return path59.join(root, "drain-trees.json");
 }
 function empty() {
   return { version: 1, partitions: [] };
@@ -5956,7 +6962,7 @@ function empty() {
 async function loadTreeSnapshots(root = getMinerRoot()) {
   let raw;
   try {
-    raw = await fs39.readFile(snapshotPath(root), "utf8");
+    raw = await fs47.readFile(snapshotPath(root), "utf8");
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") return empty();
     throw err;
@@ -5976,7 +6982,7 @@ async function loadTreeSnapshots(root = getMinerRoot()) {
   return parsed.success ? parsed.data : empty();
 }
 async function saveTreeSnapshots(snapshot, root = getMinerRoot()) {
-  await fs39.mkdir(root, { recursive: true });
+  await fs47.mkdir(root, { recursive: true });
   await atomicWrite(
     snapshotPath(root),
     `${JSON.stringify(TreeSnapshotFileSchema.parse(snapshot))}
@@ -6126,8 +7132,8 @@ function extractBlobs(line, toolNames) {
 }
 
 // src/drain/reader-state.ts
-import { promises as fs40 } from "fs";
-import path52 from "path";
+import { promises as fs48 } from "fs";
+import path60 from "path";
 import { z as z49 } from "zod";
 var TranscriptStateSchema = z49.object({
   /** `~`-relative path, matching `session-index/discover.ts`'s display form. */
@@ -6148,11 +7154,11 @@ var ReaderStateSchema = z49.object({
 });
 var MAX_PENDING_TOOL_NAMES = 256;
 function readerStatePath(root = getMinerRoot()) {
-  return path52.join(root, "reader-state.json");
+  return path60.join(root, "reader-state.json");
 }
 async function loadReaderState(root = getMinerRoot()) {
   try {
-    const raw = await fs40.readFile(readerStatePath(root), "utf8");
+    const raw = await fs48.readFile(readerStatePath(root), "utf8");
     return ReaderStateSchema.parse(JSON.parse(raw));
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
@@ -6162,7 +7168,7 @@ async function loadReaderState(root = getMinerRoot()) {
   }
 }
 async function saveReaderState(state, root = getMinerRoot()) {
-  await fs40.mkdir(root, { recursive: true });
+  await fs48.mkdir(root, { recursive: true });
   await atomicWrite(
     readerStatePath(root),
     `${JSON.stringify(ReaderStateSchema.parse(state), null, 2)}
@@ -6374,6 +7380,22 @@ var ArgsSchema44 = z51.object({
   limit: z51.coerce.number().int().positive().optional(),
   verify_hashes: z51.boolean().optional()
 });
+var WorkspaceSchema = z51.object({
+  files: z51.number(),
+  indexed: z51.number(),
+  unchanged: z51.number(),
+  removed: z51.number(),
+  malformed: z51.array(z51.object({ path: z51.string(), reason: z51.string() })),
+  rows: z51.object({
+    initiative: z51.number(),
+    note: z51.number(),
+    task: z51.number(),
+    session: z51.number(),
+    source: z51.number()
+  }),
+  edges: z51.object({ holds: z51.number(), mentions: z51.number(), sharesTag: z51.number() }),
+  orphanRatio: z51.number()
+});
 var ResultSchema40 = z51.object({
   startedAt: z51.string(),
   durationMs: z51.number(),
@@ -6389,6 +7411,8 @@ var ResultSchema40 = z51.object({
   turnsRolledUp: z51.number(),
   tasksRequested: z51.number(),
   tasksApplied: z51.number(),
+  workspace: WorkspaceSchema.nullable(),
+  preserved: z51.object({ restored: z51.number(), merged: z51.number(), skipped: z51.number() }),
   errors: z51.array(z51.string())
 });
 var miner_refresh_default = defineCommand({
@@ -6425,7 +7449,7 @@ import { z as z52 } from "zod";
 
 // src/session-index/liveness.ts
 import { existsSync as existsSync2 } from "fs";
-import { RELATIONS, toAbsolutePath } from "@titan-design/session-read";
+import { RELATIONS as RELATIONS2, toAbsolutePath } from "@titan-design/session-read";
 var SKIP_TABLES = /^(sqlite_|_migration$|search_fts)/;
 var EXPECTED_EMPTY = {
   "edge.t_invalid": "NULL means current; the index is rebuilt from scratch, so no edge is ever superseded in place",
@@ -6433,20 +7457,29 @@ var EXPECTED_EMPTY = {
   "edge.attrs": "kit column; the session graph writes no per-edge attributes"
 };
 var REF_TABLES = {
-  // `session` is the odd one out: it stores the bare id, every other entity
-  // table stores the prefixed ref. Comparing without allowing for that reports
-  // every session endpoint as dangling — a false alarm, which in a diagnostic
-  // is worse than no check at all.
-  session: { table: "session", column: "session_id", bare: true },
-  agent: { table: "subagent", column: "agent_ref" },
-  file: { table: "file", column: "file_ref" },
-  branch: { table: "branch", column: "branch_ref" },
-  task: { table: "task", column: "task_ref" },
-  artifact: { table: "artifact", column: "artifact_ref" },
+  // `session` is the odd one out: `session` stores the bare id, every other
+  // entity table stores the prefixed ref. Comparing without allowing for that
+  // reports every session endpoint as dangling — a false alarm, which in a
+  // diagnostic is worse than no check at all.
+  session: [
+    { table: "session", column: "session_id", bare: true },
+    { table: "session_record", column: "session_ref" }
+  ],
+  agent: [{ table: "subagent", column: "agent_ref" }],
+  file: [{ table: "file", column: "file_ref" }],
+  branch: [{ table: "branch", column: "branch_ref" }],
+  task: [
+    { table: "task", column: "task_ref" },
+    { table: "workspace_task", column: "task_ref" }
+  ],
+  artifact: [{ table: "artifact", column: "artifact_ref" }],
   // `pr` is keyed by `pr_ref` like every other entity table. It was left
   // unmapped on the belief that it was keyed by `(number, repo)` — that is
   // `pr_merge_observation`, a different table (AW-107).
-  pr: { table: "pr", column: "pr_ref" }
+  pr: [{ table: "pr", column: "pr_ref" }],
+  initiative: [{ table: "initiative", column: "initiative_ref" }],
+  note: [{ table: "note", column: "note_ref" }],
+  source: [{ table: "source", column: "source_ref" }]
 };
 function tableNames(db) {
   const rows = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name").all();
@@ -6468,11 +7501,12 @@ function scanTable(db, table) {
     nonNull: row[`c${index}`] ?? 0
   }));
 }
+var WORKSPACE_RELATIONS = ["holds", "mentions", "shares_tag"];
 function relationLiveness(db) {
   const observed = new Map(
     db.prepare("SELECT relation, COUNT(*) AS n FROM edge GROUP BY relation").all().map((row) => [row.relation, row.n])
   );
-  const declared = Object.values(RELATIONS);
+  const declared = [...Object.values(RELATIONS2), ...WORKSPACE_RELATIONS];
   const report2 = declared.map((relation) => ({
     relation,
     count: observed.get(relation) ?? 0,
@@ -6492,19 +7526,22 @@ function refNamespaces(db) {
        ) WHERE namespace <> '' GROUP BY namespace ORDER BY namespace`
   ).all();
   return rows.map(({ namespace, n }) => {
-    const target = REF_TABLES[namespace];
-    if (!target) return { namespace, edges: n, dangling: null };
-    const lhs = target.bare ? `substr(e.ref, ${namespace.length + 2})` : "e.ref";
-    const { c } = db.prepare(
-      `SELECT COUNT(*) AS c FROM (
-           SELECT source_ref AS ref FROM edge UNION ALL SELECT target_ref FROM edge
-         ) e
-         WHERE e.ref LIKE @prefix
-           AND NOT EXISTS (SELECT 1 FROM "${target.table}" t WHERE t."${target.column}" = ${lhs})`
-    ).get({ prefix: `${namespace}:%` });
+    const targets = REF_TABLES[namespace];
+    if (!targets) return { namespace, edges: n, dangling: null };
+    const { c } = db.prepare(danglingSql(namespace, targets)).get({ prefix: `${namespace}:%` });
     return { namespace, edges: n, dangling: c };
   });
 }
+function danglingSql(namespace, targets) {
+  const absent = targets.map((target) => {
+    const lhs = target.bare ? `substr(e.ref, ${namespace.length + 2})` : "e.ref";
+    return `NOT EXISTS (SELECT 1 FROM "${target.table}" t WHERE t."${target.column}" = ${lhs})`;
+  }).join(" AND ");
+  return `SELECT COUNT(*) AS c FROM (
+            SELECT source_ref AS ref FROM edge UNION ALL SELECT target_ref FROM edge
+          ) e
+          WHERE e.ref LIKE @prefix AND ${absent}`;
+}
 function staleTranscripts(db) {
   const rows = db.prepare("SELECT source_key FROM transcript WHERE status = 'ok'").all();
   return rows.filter((row) => !existsSync2(toAbsolutePath(row.source_key))).length;
@@ -6767,8 +7804,8 @@ async function readStdinJson(stream = process.stdin) {
 }
 
 // src/utils/agent-chat-hook-state.ts
-import { promises as fs41 } from "fs";
-import path53 from "path";
+import { promises as fs49 } from "fs";
+import path61 from "path";
 import { z as z54 } from "zod";
 var SpawnContextSchema = z54.object({
   slug: z54.string().min(1),
@@ -6788,19 +7825,19 @@ var SpawnContextSchema = z54.object({
   briefing: z54.string().nullable().default(null)
 });
 function stateDir() {
-  return path53.join(getStateRoot(), "agent-chat-hooks");
+  return path61.join(getStateRoot(), "agent-chat-hooks");
 }
 function stateFile(agentId) {
-  return path53.join(stateDir(), `${agentId}.json`);
+  return path61.join(stateDir(), `${agentId}.json`);
 }
 async function stashSpawnContext(agentId, context) {
-  await fs41.mkdir(stateDir(), { recursive: true });
+  await fs49.mkdir(stateDir(), { recursive: true });
   await atomicWrite(stateFile(agentId), JSON.stringify(context));
 }
 async function readSpawnContext(agentId) {
   let raw;
   try {
-    raw = await fs41.readFile(stateFile(agentId), "utf8");
+    raw = await fs49.readFile(stateFile(agentId), "utf8");
   } catch {
     return null;
   }
@@ -6809,7 +7846,7 @@ async function readSpawnContext(agentId) {
 }
 async function takeSpawnContext(agentId) {
   const context = await readSpawnContext(agentId);
-  await fs41.rm(stateFile(agentId), { force: true });
+  await fs49.rm(stateFile(agentId), { force: true });
   return context;
 }
 async function peekSpawnContext(agentId) {
@@ -6960,9 +7997,9 @@ import { readFile, writeFile } from "fs/promises";
 import { join } from "path";
 
 // src/migrations/v1-to-v2-artifacts.ts
-import { promises as fs42 } from "fs";
-import path54 from "path";
-import YAML from "yaml";
+import { promises as fs50 } from "fs";
+import path62 from "path";
+import YAML4 from "yaml";
 function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
@@ -6987,13 +8024,13 @@ function normaliseStash(s) {
 async function migrateOne(filePath) {
   let raw;
   try {
-    raw = await fs42.readFile(filePath, "utf8");
+    raw = await fs50.readFile(filePath, "utf8");
   } catch {
     return { changed: false, droppedPrs: [] };
   }
   let parsed;
   try {
-    parsed = YAML.parse(raw) ?? {};
+    parsed = YAML4.parse(raw) ?? {};
   } catch {
     return { changed: false, droppedPrs: [] };
   }
@@ -7017,38 +8054,38 @@ async function migrateOne(filePath) {
 async function walkArtifactsFiles(activeRoot) {
   const out = [];
   try {
-    const entries = await fs42.readdir(activeRoot, { withFileTypes: true });
+    const entries = await fs50.readdir(activeRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      const candidate = path54.join(activeRoot, entry.name, "artifacts.yml");
+      const candidate = path62.join(activeRoot, entry.name, "artifacts.yml");
       try {
-        await fs42.access(candidate);
+        await fs50.access(candidate);
         out.push(candidate);
       } catch {
       }
     }
   } catch {
   }
-  const archiveRoot = path54.resolve(activeRoot, "..");
+  const archiveRoot = path62.resolve(activeRoot, "..");
   try {
-    const domains = await fs42.readdir(archiveRoot, { withFileTypes: true });
+    const domains = await fs50.readdir(archiveRoot, { withFileTypes: true });
     for (const domain of domains) {
       if (!domain.isDirectory()) continue;
       if (domain.name.startsWith(".")) continue;
-      if (path54.join(archiveRoot, domain.name) === path54.resolve(activeRoot)) continue;
-      const archiveDir = path54.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 fs42.readdir(archiveDir, { withFileTypes: true });
+        archived = await fs50.readdir(archiveDir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const entry of archived) {
         if (!entry.isDirectory()) continue;
-        const candidate = path54.join(archiveDir, entry.name, "artifacts.yml");
+        const candidate = path62.join(archiveDir, entry.name, "artifacts.yml");
         try {
-          await fs42.access(candidate);
+          await fs50.access(candidate);
           out.push(candidate);
         } catch {
         }
@@ -7060,15 +8097,15 @@ async function walkArtifactsFiles(activeRoot) {
 }
 async function appendMigrationLog(activeRoot, lines) {
   if (lines.length === 0) return;
-  const logPath = path54.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("");
   try {
-    await fs42.mkdir(activeRoot, { recursive: true });
+    await fs50.mkdir(activeRoot, { recursive: true });
   } catch {
   }
-  await fs42.appendFile(logPath, body, "utf8");
+  await fs50.appendFile(logPath, body, "utf8");
 }
 var v1ToV2Artifacts = {
   from: 1,
@@ -7091,11 +8128,11 @@ var v1ToV2Artifacts = {
 };
 
 // src/migrations/v2-to-v3-open-loops.ts
-import { promises as fs45 } from "fs";
-import path56 from "path";
+import { promises as fs53 } from "fs";
+import path64 from "path";
 
 // src/migrations/v3-proposal.ts
-import { promises as fs43 } from "fs";
+import { promises as fs51 } from "fs";
 import { z as z57 } from "zod";
 
 // src/migrations/data/v3-open-loops-proposal.ts
@@ -7970,7 +9007,7 @@ async function loadProposal() {
   if (override !== void 0 && override.length > 0) {
     let raw;
     try {
-      raw = await fs43.readFile(override, "utf8");
+      raw = await fs51.readFile(override, "utf8");
     } catch {
       throw new ValidationError(`${PROPOSAL_PATH_ENV} points at an unreadable file: ${override}`);
     }
@@ -7991,18 +9028,18 @@ async function loadProposal() {
 }
 
 // src/migrations/v3-repairs.ts
-import { promises as fs44 } from "fs";
-import path55 from "path";
+import { promises as fs52 } from "fs";
+import path63 from "path";
 var KNOWN_REPAIRS = [
   {
-    file: path55.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: path55.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: path55.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/"
   }
 ];
@@ -8016,11 +9053,11 @@ var BRIEF_REPAIRS = {
     };
   }
 };
-function repairBriefFrontmatter(slug, frontmatter) {
-  const repair = BRIEF_REPAIRS[slug]?.(frontmatter);
-  if (repair == null) return { frontmatter, applied: [] };
+function repairBriefFrontmatter(slug, frontmatter2) {
+  const repair = BRIEF_REPAIRS[slug]?.(frontmatter2);
+  if (repair == null) return { frontmatter: frontmatter2, applied: [] };
   return {
-    frontmatter: { ...frontmatter, ...repair.patch },
+    frontmatter: { ...frontmatter2, ...repair.patch },
     applied: [repair.detail]
   };
 }
@@ -8050,9 +9087,9 @@ async function planRetrack(fullPath, repair) {
     repaired: { frontmatter: parsed.data, body: raw.body }
   };
 }
-async function exists2(p) {
+async function exists3(p) {
   try {
-    await fs44.access(p);
+    await fs52.access(p);
     return true;
   } catch {
     return false;
@@ -8061,8 +9098,8 @@ async function exists2(p) {
 async function planRepairs(activeRoot) {
   const plans = [];
   for (const repair of KNOWN_REPAIRS) {
-    const fullPath = path55.join(activeRoot, repair.file);
-    if (!await exists2(fullPath)) {
+    const fullPath = path63.join(activeRoot, repair.file);
+    if (!await exists3(fullPath)) {
       plans.push({ action: "skip", file: repair.file, detail: "already absent" });
       continue;
     }
@@ -8071,7 +9108,7 @@ async function planRepairs(activeRoot) {
       continue;
     }
     const target = repair.target;
-    if (await exists2(path55.join(activeRoot, target))) {
+    if (await exists3(path63.join(activeRoot, target))) {
       plans.push({
         action: "skip",
         file: repair.file,
@@ -8085,7 +9122,7 @@ async function planRepairs(activeRoot) {
   return plans;
 }
 async function applyRepair(activeRoot, plan) {
-  const fullPath = path55.join(activeRoot, plan.file);
+  const fullPath = path63.join(activeRoot, plan.file);
   if (plan.action === "retrack" && plan.repaired !== void 0) {
     await writeFrontmatter(
       fullPath,
@@ -8096,34 +9133,34 @@ async function applyRepair(activeRoot, plan) {
     return;
   }
   if (plan.action === "relocate") {
-    const target = path55.join(activeRoot, plan.target);
-    await fs44.mkdir(path55.dirname(target), { recursive: true });
-    await fs44.rename(fullPath, target);
+    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 = path56.join("sources", "handoff-archive.md");
+var HANDOFF_ARCHIVE = path64.join("sources", "handoff-archive.md");
 async function pathExists(p) {
   try {
-    await fs45.access(p);
+    await fs53.access(p);
     return true;
   } catch {
     return false;
   }
 }
-async function listInitiativeSlugs2(activeRoot) {
+async function listInitiativeSlugs3(activeRoot) {
   let entries;
   try {
-    entries = await fs45.readdir(activeRoot, { withFileTypes: true });
+    entries = await fs53.readdir(activeRoot, { withFileTypes: true });
   } catch {
     return [];
   }
   const slugs = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    if (await pathExists(path56.join(activeRoot, entry.name, "brief.md"))) {
+    if (await pathExists(path64.join(activeRoot, entry.name, "brief.md"))) {
       slugs.push(entry.name);
     }
   }
@@ -8131,12 +9168,12 @@ async function listInitiativeSlugs2(activeRoot) {
 }
 async function maxOnDiskTaskNumber2(initiativeDir, prefix) {
   const re = new RegExp(`^${prefix}-(\\d+)\\.yml$`);
-  const tasksDir = path56.join(initiativeDir, "tasks");
+  const tasksDir = path64.join(initiativeDir, "tasks");
   let max = 0;
-  for (const dir of [tasksDir, path56.join(tasksDir, "archive")]) {
+  for (const dir of [tasksDir, path64.join(tasksDir, "archive")]) {
     let names;
     try {
-      names = await fs45.readdir(dir);
+      names = await fs53.readdir(dir);
     } catch {
       continue;
     }
@@ -8147,15 +9184,15 @@ async function maxOnDiskTaskNumber2(initiativeDir, prefix) {
   }
   return max;
 }
-async function nextTaskSeq(initiativeDir, frontmatter) {
-  if (frontmatter.task_seq !== void 0) return null;
-  const prefix = frontmatter.task_prefix;
+async function nextTaskSeq(initiativeDir, frontmatter2) {
+  if (frontmatter2.task_seq !== void 0) return null;
+  const prefix = frontmatter2.task_prefix;
   if (typeof prefix !== "string" || prefix.length === 0) return null;
   const max = await maxOnDiskTaskNumber2(initiativeDir, prefix);
   return max > 0 ? max : null;
 }
 async function planBrief(initiativeDir, slug) {
-  const raw = await readRawFrontmatter(path56.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 };
@@ -8172,12 +9209,12 @@ async function planBrief(initiativeDir, slug) {
   };
 }
 async function planHandoff(initiativeDir) {
-  if (!await pathExists(path56.join(initiativeDir, HANDOFF_FILE))) return "absent";
-  if (await pathExists(path56.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) {
-  const frontmatter = SessionFrontmatterSchema.parse({
+  const frontmatter2 = SessionFrontmatterSchema.parse({
     session_id: entry.session_id,
     // A synthetic session is an instant, not an interval: it stands for a
     // state read off the handoff, so `started === ended`.
@@ -8189,11 +9226,11 @@ function buildOpenSession(entry) {
     resolves: []
   });
   const stem = buildSessionStem(entry.ended, entry.session_id);
-  return { kind: "open", stem, frontmatter, body: buildOpenBody(entry, stem) };
+  return { kind: "open", stem, frontmatter: frontmatter2, body: buildOpenBody(entry, stem) };
 }
 function buildAbandonSession(entry, openStem, abandonedAt) {
   const sessionId = `${entry.session_id}-abandonment`;
-  const frontmatter = SessionFrontmatterSchema.parse({
+  const frontmatter2 = SessionFrontmatterSchema.parse({
     session_id: sessionId,
     started: abandonedAt,
     ended: abandonedAt,
@@ -8209,7 +9246,7 @@ function buildAbandonSession(entry, openStem, abandonedAt) {
   return {
     kind: "abandon",
     stem,
-    frontmatter,
+    frontmatter: frontmatter2,
     body: buildAbandonBody(entry, openStem, stem)
   };
 }
@@ -8263,7 +9300,7 @@ function draftSessions(entry, abandonedAt) {
   return [open, buildAbandonSession(entry, open.stem, abandonedAt)];
 }
 async function planInitiative(activeRoot, slug, entry, abandonedAt) {
-  const initiativeDir = path56.join(activeRoot, slug);
+  const initiativeDir = path64.join(activeRoot, slug);
   const brief = await planBrief(initiativeDir, slug);
   const base = {
     slug,
@@ -8290,7 +9327,7 @@ function assertProposalSlugsExist(proposal, known) {
 }
 async function planV2ToV3(activeRoot) {
   const { proposal, origin } = await loadProposal();
-  const slugs = await listInitiativeSlugs2(activeRoot);
+  const slugs = await listInitiativeSlugs3(activeRoot);
   assertProposalSlugsExist(proposal, slugs);
   const byslug = new Map(proposal.initiatives.map((i) => [i.slug, i]));
   const initiatives = [];
@@ -8302,11 +9339,11 @@ async function planV2ToV3(activeRoot) {
   return { proposalOrigin: origin, initiatives, repairs: await planRepairs(activeRoot) };
 }
 async function archiveHandoff(initiativeDir) {
-  const source = path56.join(initiativeDir, HANDOFF_FILE);
-  const target = path56.join(initiativeDir, HANDOFF_ARCHIVE);
-  await fs45.mkdir(path56.dirname(target), { recursive: true });
-  await fs45.copyFile(source, target);
-  await fs45.rm(source);
+  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);
 }
 async function writePlannedSession(activeRoot, slug, session) {
   const fm = session.frontmatter;
@@ -8323,15 +9360,15 @@ async function writePlannedSession(activeRoot, slug, session) {
   });
 }
 async function applyInitiative(activeRoot, plan) {
-  const initiativeDir = path56.join(activeRoot, plan.slug);
-  await withFileLock(path56.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(
-        path56.join(initiativeDir, "brief.md"),
+        path64.join(initiativeDir, "brief.md"),
         plan.brief.frontmatter,
         plan.brief.body,
         BriefFrontmatterSchema
@@ -8361,13 +9398,13 @@ var v2ToV3OpenLoops = {
 };
 
 // src/migrations/v3-to-v4-worktrees.ts
-import { promises as fs46 } from "fs";
-import path57 from "path";
-import matter3 from "gray-matter";
-import YAML2 from "yaml";
+import { promises as fs54 } from "fs";
+import path65 from "path";
+import matter5 from "gray-matter";
+import YAML5 from "yaml";
 function normalize(value) {
-  const expanded = value.startsWith("~") ? path57.join(process.env.HOME ?? "", value.slice(1)) : value;
-  return path57.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 [];
@@ -8403,7 +9440,7 @@ function mergeWorktrees(existing, incoming) {
 }
 async function readArtifacts2(file) {
   try {
-    const raw = YAML2.parse(await fs46.readFile(file, "utf8"));
+    const raw = YAML5.parse(await fs54.readFile(file, "utf8"));
     return {
       branches: Array.isArray(raw?.branches) ? raw.branches : [],
       stashes: Array.isArray(raw?.stashes) ? raw.stashes : [],
@@ -8414,20 +9451,20 @@ async function readArtifacts2(file) {
   }
 }
 async function migrateOne2(initiativeDir) {
-  const briefPath = path57.join(initiativeDir, "brief.md");
+  const briefPath = path65.join(initiativeDir, "brief.md");
   let raw;
   try {
-    raw = await fs46.readFile(briefPath, "utf8");
+    raw = await fs54.readFile(briefPath, "utf8");
   } catch {
     return 0;
   }
-  const parsed = matter3(raw);
+  const parsed = matter5(raw);
   const data = parsed.data;
   if (!("worktrees" in data)) return 0;
   const incoming = toEntries(data.worktrees);
   delete data.worktrees;
   if (incoming.length > 0) {
-    const artifactsPath2 = path57.join(initiativeDir, "artifacts.yml");
+    const artifactsPath2 = path65.join(initiativeDir, "artifacts.yml");
     const current = await readArtifacts2(artifactsPath2);
     await writeYaml(
       artifactsPath2,
@@ -8439,22 +9476,22 @@ async function migrateOne2(initiativeDir) {
       ArtifactsSchema
     );
   }
-  await atomicWrite(briefPath, matter3.stringify(parsed.content, data));
+  await atomicWrite(briefPath, matter5.stringify(parsed.content, data));
   return incoming.length;
 }
 async function initiativeDirs(activeRoot) {
   const out = [];
   let entries;
   try {
-    entries = await fs46.readdir(activeRoot, { withFileTypes: true });
+    entries = await fs54.readdir(activeRoot, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    const dir = path57.join(activeRoot, entry.name);
+    const dir = path65.join(activeRoot, entry.name);
     try {
-      await fs46.access(path57.join(dir, "brief.md"));
+      await fs54.access(path65.join(dir, "brief.md"));
       out.push(dir);
     } catch {
     }
@@ -8469,12 +9506,12 @@ var v3ToV4Worktrees = {
     const moved = [];
     for (const dir of await initiativeDirs(activeRoot)) {
       const count = await migrateOne2(dir);
-      if (count > 0) moved.push(`${path57.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 fs46.appendFile(
-      path57.join(activeRoot, ".migrations.log"),
+    await fs54.appendFile(
+      path65.join(activeRoot, ".migrations.log"),
       moved.map((line) => `${stamp}	v3->v4	${line}
 `).join(""),
       "utf8"
@@ -8489,7 +9526,7 @@ var CURRENT_VERSION = targetVersion(MIGRATIONS2);
 function targetVersion(migrations) {
   return migrations.reduce((highest, m) => Math.max(highest, m.to), BASE_VERSION);
 }
-async function runMigrations(activeRoot, fromVersion, migrations = MIGRATIONS2) {
+async function runMigrations2(activeRoot, fromVersion, migrations = MIGRATIONS2) {
   if (fromVersion === CURRENT_VERSION) {
     return { ran: [] };
   }
@@ -8527,10 +9564,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 path65 = schemaVersionPath(activeRoot);
+  const path67 = schemaVersionPath(activeRoot);
   let raw;
   try {
-    raw = await readFile(path65, "utf8");
+    raw = await readFile(path67, "utf8");
   } catch (err) {
     if (isNodeErrnoException(err) && err.code === "ENOENT") {
       return 0;
@@ -8540,13 +9577,13 @@ async function readSchemaVersion(activeRoot) {
   const trimmed = raw.trim();
   if (trimmed === "" || !/^\d+$/.test(trimmed)) {
     throw new Error(
-      `Invalid schema version in ${path65}: 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 ${path65}: expected a positive integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path67}: expected a positive integer, got ${JSON.stringify(raw)}`
     );
   }
   return parsed;
@@ -8559,10 +9596,10 @@ async function writeSchemaVersion(activeRoot, version) {
 `, "utf8");
 }
 async function readRawSchemaVersion(activeRoot) {
-  const path65 = schemaVersionPath(activeRoot);
+  const path67 = schemaVersionPath(activeRoot);
   let raw;
   try {
-    raw = await readFile(path65, "utf8");
+    raw = await readFile(path67, "utf8");
   } catch (err) {
     if (isNodeErrnoException(err) && err.code === "ENOENT") {
       return { present: false };
@@ -8572,13 +9609,13 @@ async function readRawSchemaVersion(activeRoot) {
   const trimmed = raw.trim();
   if (trimmed === "" || !/^\d+$/.test(trimmed)) {
     throw new Error(
-      `Invalid schema version in ${path65}: 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 ${path65}: 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 };
@@ -8598,7 +9635,7 @@ async function ensureSchemaVersion(activeRoot) {
   if (before === CURRENT_VERSION) {
     return { before, after: before, migrated: false, ran: [] };
   }
-  const { ran } = await runMigrations(activeRoot, before);
+  const { ran } = await runMigrations2(activeRoot, before);
   await writeSchemaVersion(activeRoot, CURRENT_VERSION);
   return {
     before,
@@ -8619,7 +9656,7 @@ function isLinux(platform = process.platform) {
   return platform === "linux";
 }
 function resolveLocalDeps(deps) {
-  const fs53 = deps.fs ?? fsp;
+  const fs57 = deps.fs ?? fsp;
   const spawn6 = deps.spawn ?? nodeSpawn;
   const homeDir = deps.paths?.homeDir ?? os3.homedir();
   const paths = deps.paths ?? {
@@ -8629,7 +9666,7 @@ function resolveLocalDeps(deps) {
     homeDir
   };
   const cliEntry = deps.cliEntry ?? process.argv[1] ?? "active-work";
-  return { fs: fs53, spawn: spawn6, paths, cliEntry, platform: process.platform };
+  return { fs: fs57, spawn: spawn6, paths, cliEntry, platform: process.platform };
 }
 function getUnitDir(homeDir) {
   return nodePath.join(homeDir, ".config", "systemd", "user");
@@ -8700,7 +9737,7 @@ async function isUnitActive(deps = {}) {
   return result.code === 0;
 }
 async function stepInstallSupervision(deps = {}, opts = {}) {
-  const { fs: fs53, spawn: spawn6, paths, cliEntry, platform } = resolveLocalDeps(deps);
+  const { fs: fs57, spawn: spawn6, paths, cliEntry, platform } = resolveLocalDeps(deps);
   if (!isLinux(platform)) {
     return {
       ok: true,
@@ -8713,16 +9750,16 @@ async function stepInstallSupervision(deps = {}, opts = {}) {
   const unitPath = getUnitPath(paths.homeDir);
   const desired = renderUnit({ cliEntry, port: opts.port });
   try {
-    await fs53.mkdir(unitDir, { recursive: true });
+    await fs57.mkdir(unitDir, { recursive: true });
     let existing = null;
     try {
-      existing = await fs53.readFile(unitPath, "utf8");
+      existing = await fs57.readFile(unitPath, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
     const unchanged = existing === desired;
     if (!unchanged) {
-      await fs53.writeFile(unitPath, desired, "utf8");
+      await fs57.writeFile(unitPath, desired, "utf8");
     }
     const reload = await runOnce(spawn6, "systemctl", ["--user", "daemon-reload"]);
     if (reload.spawnError) {
@@ -8784,7 +9821,7 @@ async function stepInstallSupervision(deps = {}, opts = {}) {
   }
 }
 async function uninstallSupervision(deps = {}) {
-  const { fs: fs53, spawn: spawn6, paths, platform } = resolveLocalDeps(deps);
+  const { fs: fs57, spawn: spawn6, paths, platform } = resolveLocalDeps(deps);
   if (!isLinux(platform)) {
     return {
       ok: true,
@@ -8797,7 +9834,7 @@ async function uninstallSupervision(deps = {}) {
   try {
     let present = true;
     try {
-      await fs53.stat(unitPath);
+      await fs57.stat(unitPath);
     } catch (err) {
       if (err.code === "ENOENT") present = false;
       else throw err;
@@ -8812,7 +9849,7 @@ async function uninstallSupervision(deps = {}) {
     }
     const disable = await runOnce(spawn6, "systemctl", ["--user", "disable", "--now", UNIT_NAME]);
     if (disable.spawnError) {
-      await fs53.rm(unitPath, { force: true });
+      await fs57.rm(unitPath, { force: true });
       return {
         ok: true,
         name: STEP_SUPERVISION,
@@ -8820,7 +9857,7 @@ async function uninstallSupervision(deps = {}) {
         message: `Removed ${unitPath} (systemctl unavailable: ${disable.spawnError.message})`
       };
     }
-    await fs53.rm(unitPath, { force: true });
+    await fs57.rm(unitPath, { force: true });
     const reload = await runOnce(spawn6, "systemctl", ["--user", "daemon-reload"]);
     if (reload.code !== 0 && !reload.spawnError) {
       return {
@@ -8856,7 +9893,7 @@ function isDarwin(platform = process.platform) {
   return platform === "darwin";
 }
 function resolveLocalDeps2(deps) {
-  const fs53 = deps.fs ?? fsp2;
+  const fs57 = deps.fs ?? fsp2;
   const spawn6 = deps.spawn ?? nodeSpawn2;
   const homeDir = deps.paths?.homeDir ?? os4.homedir();
   const paths = deps.paths ?? {
@@ -8867,7 +9904,7 @@ function resolveLocalDeps2(deps) {
   };
   const cliEntry = deps.cliEntry ?? process.argv[1] ?? "active-work";
   const uid = process.getuid?.() ?? 0;
-  return { fs: fs53, spawn: spawn6, paths, cliEntry, uid, platform: process.platform };
+  return { fs: fs57, spawn: spawn6, paths, cliEntry, uid, platform: process.platform };
 }
 function getAgentDir(homeDir) {
   return nodePath2.join(homeDir, "Library", "LaunchAgents");
@@ -8955,7 +9992,7 @@ async function isAgentLoaded(deps = {}) {
   return result.code === 0;
 }
 async function installLaunchAgent(deps = {}, opts = {}) {
-  const { fs: fs53, spawn: spawn6, paths, cliEntry, uid, platform } = resolveLocalDeps2(deps);
+  const { fs: fs57, spawn: spawn6, paths, cliEntry, uid, platform } = resolveLocalDeps2(deps);
   if (!isDarwin(platform)) {
     return {
       ok: true,
@@ -8967,11 +10004,11 @@ async function installLaunchAgent(deps = {}, opts = {}) {
   const plistPath = getPlistPath(paths.homeDir);
   const desired = renderPlist({ cliEntry, homeDir: paths.homeDir, port: opts.port });
   try {
-    await fs53.mkdir(getAgentDir(paths.homeDir), { recursive: true });
-    await fs53.mkdir(getLogDir(paths.homeDir), { recursive: true });
+    await fs57.mkdir(getAgentDir(paths.homeDir), { recursive: true });
+    await fs57.mkdir(getLogDir(paths.homeDir), { recursive: true });
     let existing = null;
     try {
-      existing = await fs53.readFile(plistPath, "utf8");
+      existing = await fs57.readFile(plistPath, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
@@ -8985,7 +10022,7 @@ async function installLaunchAgent(deps = {}, opts = {}) {
       };
     }
     if (!unchanged) {
-      await fs53.writeFile(plistPath, desired, "utf8");
+      await fs57.writeFile(plistPath, desired, "utf8");
     }
     const bootout = await runOnce2(spawn6, "launchctl", ["bootout", serviceTarget(uid)]);
     if (bootout.spawnError) {
@@ -9026,7 +10063,7 @@ async function installLaunchAgent(deps = {}, opts = {}) {
   }
 }
 async function uninstallLaunchAgent(deps = {}) {
-  const { fs: fs53, spawn: spawn6, paths, uid, platform } = resolveLocalDeps2(deps);
+  const { fs: fs57, spawn: spawn6, paths, uid, platform } = resolveLocalDeps2(deps);
   if (!isDarwin(platform)) {
     return {
       ok: true,
@@ -9039,7 +10076,7 @@ async function uninstallLaunchAgent(deps = {}) {
   try {
     let present = true;
     try {
-      await fs53.stat(plistPath);
+      await fs57.stat(plistPath);
     } catch (err) {
       if (err.code === "ENOENT") present = false;
       else throw err;
@@ -9053,7 +10090,7 @@ async function uninstallLaunchAgent(deps = {}) {
       };
     }
     const bootout = await runOnce2(spawn6, "launchctl", ["bootout", serviceTarget(uid)]);
-    await fs53.rm(plistPath, { force: true });
+    await fs57.rm(plistPath, { force: true });
     if (bootout.spawnError) {
       return {
         ok: true,
@@ -9114,7 +10151,7 @@ function findRepoRoot() {
   return nodePath3.resolve(nodePath3.dirname(fileURLToPath2(import.meta.url)), "..", "..");
 }
 function resolveDeps(deps) {
-  const fs53 = deps.fs ?? fsp3;
+  const fs57 = deps.fs ?? fsp3;
   const spawn6 = deps.spawn ?? nodeSpawn3;
   const prompts = deps.prompts ?? clackPrompts;
   const homeDir = deps.paths?.homeDir ?? os5.homedir();
@@ -9127,7 +10164,7 @@ function resolveDeps(deps) {
   const repoRoot = deps.repoRoot ?? findRepoRoot();
   const cliEntry = deps.cliEntry ?? process.argv[1] ?? "active-work";
   return {
-    fs: fs53,
+    fs: fs57,
     spawn: spawn6,
     prompts,
     paths,
@@ -9170,24 +10207,24 @@ async function stepCheckNode(deps = {}) {
     message: `Node v${process.versions.node} OK`
   };
 }
-async function ensureDir(fs53, dir) {
+async function ensureDir(fs57, dir) {
   try {
-    const stat = await fs53.stat(dir);
+    const stat = await fs57.stat(dir);
     if (stat.isDirectory()) return { created: false };
     throw new Error(`${dir} exists but is not a directory`);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") throw err;
   }
-  await fs53.mkdir(dir, { recursive: true });
+  await fs57.mkdir(dir, { recursive: true });
   return { created: true };
 }
 async function stepCreateActiveRoot(deps = {}) {
-  const { fs: fs53, paths } = resolveDeps(deps);
+  const { fs: fs57, paths } = resolveDeps(deps);
   try {
     const created = [];
     for (const dir of [paths.activeRoot, paths.stateRoot, paths.configRoot]) {
-      const { created: didCreate } = await ensureDir(fs53, dir);
+      const { created: didCreate } = await ensureDir(fs57, dir);
       if (didCreate) created.push(dir);
     }
     const message = created.length === 0 ? `Active/state/config dirs already present` : `Created ${created.length} dir(s)`;
@@ -9236,18 +10273,18 @@ var CONFIG_STUB = {
   channels: ["plugin:agent-chat@agent-chat-local"]
 };
 async function stepWriteConfigStub(deps = {}) {
-  const { fs: fs53, paths, update } = resolveDeps(deps);
+  const { fs: fs57, paths, update } = resolveDeps(deps);
   const configPath = nodePath3.join(paths.configRoot, "config.json");
   try {
-    await ensureDir(fs53, paths.configRoot);
-    let exists3 = false;
+    await ensureDir(fs57, paths.configRoot);
+    let exists4 = false;
     try {
-      await fs53.stat(configPath);
-      exists3 = true;
+      await fs57.stat(configPath);
+      exists4 = true;
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    if (exists3 && !update) {
+    if (exists4 && !update) {
       return {
         ok: true,
         name: STEP_CONFIG,
@@ -9255,7 +10292,7 @@ async function stepWriteConfigStub(deps = {}) {
         message: `Config exists at ${configPath} (left untouched)`
       };
     }
-    await fs53.writeFile(configPath, JSON.stringify(CONFIG_STUB, null, 2) + "\n", "utf8");
+    await fs57.writeFile(configPath, JSON.stringify(CONFIG_STUB, null, 2) + "\n", "utf8");
     return {
       ok: true,
       name: STEP_CONFIG,
@@ -9270,40 +10307,40 @@ async function stepWriteConfigStub(deps = {}) {
     };
   }
 }
-async function pathExists2(fs53, p) {
+async function pathExists2(fs57, p) {
   try {
-    await fs53.stat(p);
+    await fs57.stat(p);
     return true;
   } catch (err) {
     if (err.code === "ENOENT") return false;
     throw err;
   }
 }
-async function copyTree(fs53, src, dest) {
-  const cp = fs53.cp;
+async function copyTree(fs57, src, dest) {
+  const cp = fs57.cp;
   if (cp) {
     await cp(src, dest, { recursive: true });
     return;
   }
-  await fs53.mkdir(dest, { recursive: true });
-  const entries = await fs53.readdir(src, { withFileTypes: true });
+  await fs57.mkdir(dest, { recursive: true });
+  const entries = await fs57.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
     const from = nodePath3.join(src, entry.name);
     const to = nodePath3.join(dest, entry.name);
     if (entry.isDirectory()) {
-      await copyTree(fs53, from, to);
+      await copyTree(fs57, from, to);
     } else {
-      await fs53.copyFile(from, to);
+      await fs57.copyFile(from, to);
     }
   }
 }
 async function stepInstallSkill(deps = {}) {
-  const { fs: fs53, paths, repoRoot } = resolveDeps(deps);
+  const { fs: fs57, paths, repoRoot } = resolveDeps(deps);
   const targetDir = nodePath3.join(paths.homeDir, ".claude", "skills", "active-work");
   const targetMarker = nodePath3.join(targetDir, "SKILL.md");
   const sourceDir = nodePath3.join(repoRoot, "skill");
   try {
-    if (await pathExists2(fs53, targetMarker)) {
+    if (await pathExists2(fs57, targetMarker)) {
       return {
         ok: true,
         name: STEP_SKILL,
@@ -9311,7 +10348,7 @@ async function stepInstallSkill(deps = {}) {
         message: `Skill already installed at ${targetDir}`
       };
     }
-    if (!await pathExists2(fs53, sourceDir)) {
+    if (!await pathExists2(fs57, sourceDir)) {
       return {
         ok: true,
         name: STEP_SKILL,
@@ -9319,8 +10356,8 @@ async function stepInstallSkill(deps = {}) {
         message: `Skill source not found at ${sourceDir}; skipping`
       };
     }
-    await fs53.mkdir(nodePath3.dirname(targetDir), { recursive: true });
-    await copyTree(fs53, sourceDir, targetDir);
+    await fs57.mkdir(nodePath3.dirname(targetDir), { recursive: true });
+    await copyTree(fs57, sourceDir, targetDir);
     return {
       ok: true,
       name: STEP_SKILL,
@@ -9336,12 +10373,12 @@ async function stepInstallSkill(deps = {}) {
   }
 }
 async function stepInstallCommand(deps = {}) {
-  const { fs: fs53, paths, repoRoot } = resolveDeps(deps);
+  const { fs: fs57, paths, repoRoot } = resolveDeps(deps);
   const targetDir = nodePath3.join(paths.homeDir, ".claude", "commands");
   const target = nodePath3.join(targetDir, "aw-prompt.md");
   const source = nodePath3.join(repoRoot, "claude-commands", "aw-prompt.md");
   try {
-    if (!await pathExists2(fs53, source)) {
+    if (!await pathExists2(fs57, source)) {
       return {
         ok: true,
         name: STEP_COMMAND,
@@ -9349,8 +10386,8 @@ async function stepInstallCommand(deps = {}) {
         message: `Command source not found at ${source}; skipping`
       };
     }
-    await fs53.mkdir(targetDir, { recursive: true });
-    await fs53.copyFile(source, target);
+    await fs57.mkdir(targetDir, { recursive: true });
+    await fs57.copyFile(source, target);
     return {
       ok: true,
       name: STEP_COMMAND,
@@ -9451,11 +10488,11 @@ function agentChatHooksPath(paths) {
   return nodePath3.join(home, "hooks.json");
 }
 async function stepRegisterAgentChatHooks(deps = {}) {
-  const { fs: fs53, paths } = resolveDeps(deps);
+  const { fs: fs57, paths } = resolveDeps(deps);
   const hooksPath = agentChatHooksPath(paths);
   const agentChatHome = nodePath3.dirname(hooksPath);
   try {
-    await fs53.stat(agentChatHome);
+    await fs57.stat(agentChatHome);
   } catch (err) {
     if (err.code === "ENOENT") {
       return {
@@ -9470,7 +10507,7 @@ async function stepRegisterAgentChatHooks(deps = {}) {
   try {
     let config = {};
     try {
-      const raw = await fs53.readFile(hooksPath, "utf8");
+      const raw = await fs57.readFile(hooksPath, "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed === "object" && parsed !== null) config = parsed;
     } catch (err) {
@@ -9499,7 +10536,7 @@ async function stepRegisterAgentChatHooks(deps = {}) {
         message: `Already registered in ${hooksPath}`
       };
     }
-    await fs53.writeFile(hooksPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    await fs57.writeFile(hooksPath, JSON.stringify(config, null, 2) + "\n", "utf8");
     return {
       ok: true,
       name: STEP_AGENT_CHAT_HOOKS,
@@ -9673,10 +10710,10 @@ async function confirmStep(prompts, yes, message, initial = true) {
   return answer === true;
 }
 async function uninstallSkill(deps = {}) {
-  const { fs: fs53, paths } = resolveDeps(deps);
+  const { fs: fs57, paths } = resolveDeps(deps);
   const target = nodePath3.join(paths.homeDir, ".claude", "skills", "active-work");
   try {
-    if (!await pathExists2(fs53, target)) {
+    if (!await pathExists2(fs57, target)) {
       return {
         ok: true,
         name: STEP_SKILL,
@@ -9684,7 +10721,7 @@ async function uninstallSkill(deps = {}) {
         message: `Skill not present at ${target}`
       };
     }
-    await fs53.rm(target, { recursive: true, force: true });
+    await fs57.rm(target, { recursive: true, force: true });
     return {
       ok: true,
       name: STEP_SKILL,
@@ -9696,10 +10733,10 @@ async function uninstallSkill(deps = {}) {
   }
 }
 async function uninstallCommand(deps = {}) {
-  const { fs: fs53, paths } = resolveDeps(deps);
+  const { fs: fs57, paths } = resolveDeps(deps);
   const target = nodePath3.join(paths.homeDir, ".claude", "commands", "aw-prompt.md");
   try {
-    if (!await pathExists2(fs53, target)) {
+    if (!await pathExists2(fs57, target)) {
       return {
         ok: true,
         name: STEP_COMMAND,
@@ -9707,7 +10744,7 @@ async function uninstallCommand(deps = {}) {
         message: `Command not present at ${target}`
       };
     }
-    await fs53.rm(target, { force: true });
+    await fs57.rm(target, { force: true });
     return {
       ok: true,
       name: STEP_COMMAND,
@@ -9972,64 +11009,33 @@ import { promises as fsp4 } from "fs";
 import nodePath4 from "path";
 import os6 from "os";
 
-// src/lint/index.ts
-import { promises as fs51 } from "fs";
-import path63 from "path";
-
-// src/lint/brief.ts
-import { promises as fs47 } from "fs";
-import path58 from "path";
-
-// src/lint/hashes.ts
-import { promises as fs48 } from "fs";
-import path59 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 fs48.readFile(path59.join(initiativeDir, relPath), "utf8");
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT") continue;
-      throw err;
-    }
-    if (hashContent(content) === storedHash) continue;
-    findings.push({
-      level: "warn",
-      slug,
-      file: relPath,
-      message: `${relPath} was hand-edited outside active-work (content no longer matches the last CLI write) \u2014 re-apply the change through the CLI/MCP tools instead of editing the file directly`
-    });
-  }
-  return findings;
+// src/workspace-index/doctor.ts
+import { promises as fs55 } from "fs";
+var INDEXED_REFS = `
+  SELECT initiative_ref AS ref, path FROM initiative
+  UNION ALL SELECT note_ref,    path FROM note
+  UNION ALL SELECT task_ref,    path FROM workspace_task
+  UNION ALL SELECT session_ref, path FROM session_record
+  UNION ALL SELECT source_ref,  path FROM source
+  ORDER BY path
+`;
+async function checkWorkspaceIndex(graph, activeRoot) {
+  const indexed = graph.db.prepare(INDEXED_REFS).all();
+  const results = await Promise.all(
+    indexed.map(async (row) => await opens(toAbsolute(activeRoot, row.path)) ? null : row)
+  );
+  return {
+    checked: indexed.length,
+    missing: results.filter((row) => row !== null).map((row) => `${row.ref} -> ${row.path}`)
+  };
 }
-
-// src/lint/open-loops.ts
-import path60 from "path";
-
-// src/lint/task.ts
-import { promises as fs49 } from "fs";
-import path61 from "path";
-import YAML3 from "yaml";
-
-// src/lint/zero-loops.ts
-import { promises as fs50 } from "fs";
-import path62 from "path";
-import YAML4 from "yaml";
-
-// src/lint/index.ts
-async function listInitiativeSlugs3(activeRoot) {
-  let entries;
+async function opens(absolutePath) {
   try {
-    entries = await fs51.readdir(activeRoot, { withFileTypes: true });
-  } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") return [];
-    throw err;
+    await fs55.access(absolutePath);
+    return true;
+  } catch {
+    return false;
   }
-  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
 }
 
 // src/doctor.ts
@@ -10078,19 +11084,19 @@ function parseMajor(version) {
   const match = /^v?(\d+)\./.exec(version);
   return match ? Number(match[1]) : 0;
 }
-async function fileExists3(fs53, target) {
+async function fileExists3(fs57, target) {
   try {
-    await fs53.access(target);
+    await fs57.access(target);
     return true;
   } catch {
     return false;
   }
 }
 var MCP_SERVER_NAMES = ["@hjewkes/active-work", "active-work"];
-async function readMcpRegistered(fs53, homeDir) {
+async function readMcpRegistered(fs57, homeDir) {
   const configPath = nodePath4.join(homeDir, ".claude.json");
   try {
-    const raw = await fs53.readFile(configPath, "utf8");
+    const raw = await fs57.readFile(configPath, "utf8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers ?? {};
     return MCP_SERVER_NAMES.some((name) => Boolean(servers[name]));
@@ -10112,9 +11118,9 @@ async function checkNode(deps) {
   };
 }
 async function checkActiveRoot(deps) {
-  const fs53 = deps.fs ?? fsp4;
+  const fs57 = deps.fs ?? fsp4;
   const activeRoot = deps.activeRoot ?? getActiveRoot();
-  if (!await fileExists3(fs53, activeRoot)) {
+  if (!await fileExists3(fs57, activeRoot)) {
     return {
       name: "active-root",
       status: "fail",
@@ -10122,7 +11128,7 @@ async function checkActiveRoot(deps) {
     };
   }
   const schemaFile = nodePath4.join(activeRoot, ".schema-version");
-  if (!await fileExists3(fs53, schemaFile)) {
+  if (!await fileExists3(fs57, schemaFile)) {
     return {
       name: "active-root",
       status: "warn",
@@ -10159,9 +11165,9 @@ async function checkDaemon(deps) {
   };
 }
 async function checkMcp(deps) {
-  const fs53 = deps.fs ?? fsp4;
+  const fs57 = deps.fs ?? fsp4;
   const homeDir = deps.homeDir ?? os6.homedir();
-  if (await readMcpRegistered(fs53, homeDir)) {
+  if (await readMcpRegistered(fs57, homeDir)) {
     return { name: "mcp-registration", status: "ok", detail: "registered in ~/.claude.json" };
   }
   return {
@@ -10171,10 +11177,10 @@ async function checkMcp(deps) {
   };
 }
 async function checkSkill(deps) {
-  const fs53 = deps.fs ?? fsp4;
+  const fs57 = deps.fs ?? fsp4;
   const homeDir = deps.homeDir ?? os6.homedir();
   const skill = nodePath4.join(homeDir, ".claude", "skills", "active-work", "SKILL.md");
-  if (await fileExists3(fs53, skill)) {
+  if (await fileExists3(fs57, skill)) {
     return { name: "skill", status: "ok", detail: skill };
   }
   return {
@@ -10251,7 +11257,7 @@ function sessionFilesCheck(malformed) {
 }
 async function checkSessions(deps) {
   const activeRoot = deps.activeRoot ?? getActiveRoot();
-  const slugs = await listInitiativeSlugs3(activeRoot);
+  const slugs = await listInitiativeSlugs2(activeRoot);
   const byKind = /* @__PURE__ */ new Map();
   const malformed = [];
   const badTaskRefs = [];
@@ -10293,7 +11299,7 @@ function noteTitlesCheck(entries) {
 }
 async function checkNoteTitles(deps) {
   const activeRoot = deps.activeRoot ?? getActiveRoot();
-  const slugs = await listInitiativeSlugs3(activeRoot);
+  const slugs = await listInitiativeSlugs2(activeRoot);
   const overlong = [];
   for (const slug of slugs) {
     const { notes } = await loadNotesFromDir(nodePath4.join(activeRoot, slug));
@@ -10333,9 +11339,42 @@ function artifactHashesCheck(drifted) {
     detail: `hand-edited outside active-work: ${drifted.join("; ")}`
   };
 }
+function workspaceIndexCheck(health) {
+  if (health === null) {
+    return { name: "workspace-index", status: "ok", detail: "no index built yet" };
+  }
+  if (health.missing.length === 0) {
+    return {
+      name: "workspace-index",
+      status: "ok",
+      detail: `${health.checked} indexed refs all resolve to a file that opens`
+    };
+  }
+  return {
+    name: "workspace-index",
+    status: "warn",
+    // Brain's whole failure, made visible: 5,013 of 5,065 notes detached on one
+    // directory move and nothing noticed, because nothing checked.
+    detail: `${health.missing.length} of ${health.checked} indexed refs point at a file that no longer opens (run \`active-work miner refresh\`): ${health.missing.slice(0, 5).join("; ")}`
+  };
+}
+async function checkWorkspaceIndexRefs(deps) {
+  const activeRoot = deps.activeRoot ?? getActiveRoot();
+  let graph;
+  try {
+    graph = openGraph();
+  } catch {
+    return workspaceIndexCheck(null);
+  }
+  try {
+    return workspaceIndexCheck(await checkWorkspaceIndex(graph, activeRoot));
+  } finally {
+    graph.db.close();
+  }
+}
 async function checkArtifactHashes(deps) {
   const activeRoot = deps.activeRoot ?? getActiveRoot();
-  const slugs = await listInitiativeSlugs3(activeRoot);
+  const slugs = await listInitiativeSlugs2(activeRoot);
   const drifted = [];
   for (const slug of slugs) {
     const findings = await lintHashes(slug, nodePath4.join(activeRoot, slug));
@@ -10344,7 +11383,7 @@ async function checkArtifactHashes(deps) {
   return artifactHashesCheck(drifted);
 }
 async function runDoctor(deps = {}) {
-  const [installChecks, sessionChecks, noteTitles, artifactHashes, leases] = await Promise.all([
+  const [installChecks, sessionChecks, noteTitles, artifactHashes, leases, workspaceIndex] = await Promise.all([
     Promise.all([
       checkNode(deps),
       checkActiveRoot(deps),
@@ -10356,9 +11395,17 @@ async function runDoctor(deps = {}) {
     checkSessions(deps),
     checkNoteTitles(deps),
     checkArtifactHashes(deps),
-    checkLeases(deps)
+    checkLeases(deps),
+    checkWorkspaceIndexRefs(deps)
   ]);
-  const checks = [...installChecks, ...sessionChecks, noteTitles, artifactHashes, leases];
+  const checks = [
+    ...installChecks,
+    ...sessionChecks,
+    noteTitles,
+    artifactHashes,
+    leases,
+    workspaceIndex
+  ];
   return { ok: checks.every((c) => c.status !== "fail"), checks };
 }
 
@@ -10428,7 +11475,7 @@ var ResultSchema48 = z61.object({
   repairs: z61.array(z61.object({ action: z61.string(), file: z61.string(), detail: z61.string() })),
   uncovered: z61.array(z61.string())
 });
-function describe(plan, applied) {
+function describe2(plan, applied) {
   const initiatives = plan.initiatives.map((i) => ({
     slug: i.slug,
     sessions: i.sessions.map((s) => ({
@@ -10514,7 +11561,7 @@ var migrate_default = defineCommand({
   async run(args, ctx) {
     if (args.apply !== true) {
       const plan2 = await planV2ToV3(ctx.activeRoot);
-      const result2 = describe(plan2, false);
+      const result2 = describe2(plan2, false);
       if (ctx.format !== "json") process.stderr.write(render(result2));
       return result2;
     }
@@ -10530,7 +11577,7 @@ var migrate_default = defineCommand({
     const plan = await planV2ToV3(ctx.activeRoot);
     await applyV2ToV3(ctx.activeRoot, plan);
     await writeSchemaVersion(ctx.activeRoot, CURRENT_VERSION);
-    const result = describe(plan, true);
+    const result = describe2(plan, true);
     if (ctx.format !== "json") process.stderr.write(render(result));
     return result;
   }
@@ -10785,16 +11832,16 @@ for (const cmd of ALL_COMMANDS) {
 import { readCommanderOption } from "@titan-design/registry";
 
 // src/utils/usage-log.ts
-import { promises as fs52 } from "fs";
-import path64 from "path";
+import { promises as fs56 } from "fs";
+import path66 from "path";
 function usageLogPath() {
-  return path64.join(getStateRoot(), "usage.jsonl");
+  return path66.join(getStateRoot(), "usage.jsonl");
 }
 async function appendUsage(rec) {
   try {
     const file = usageLogPath();
-    await fs52.mkdir(path64.dirname(file), { recursive: true });
-    await fs52.appendFile(file, JSON.stringify(rec) + "\n", "utf8");
+    await fs56.mkdir(path66.dirname(file), { recursive: true });
+    await fs56.appendFile(file, JSON.stringify(rec) + "\n", "utf8");
   } catch {
   }
 }