@titan-design/active-work 0.4.0 → 0.6.0

package/dist/cli.js

@@ -76,7 +76,7 @@ import {
   writeFrontmatter,
   writeNoteFile,
   writeYaml
-} from "./chunk-BK25ASXA.js";
+} from "./chunk-RLSQSE7I.js";
 
 // src/cli.ts
 import { Command, CommanderError } from "commander";
@@ -1517,8 +1517,8 @@ var NO_UPSTREAM = { ahead: null, behind: null };
 function shortBranch(ref) {
   return ref.replace(/^refs\/heads\//, "");
 }
-function emptyWorktree(path67) {
-  return { path: path67, head: null, branch: null, detached: false, bare: false };
+function emptyWorktree(path68) {
+  return { path: path68, head: null, branch: null, detached: false, bare: false };
 }
 function parseWorktreePorcelain(stdout) {
   const out = [];
@@ -3849,29 +3849,387 @@ var context_graph_default = defineCommand({
   }
 });
 
-// src/commands/list.ts
+// src/commands/search.ts
 import { z as z33 } from "zod";
-var argsSchema2 = z33.object({}).strict();
-var itemSchema = z33.object({
-  slug: z33.string(),
-  title: z33.string(),
-  state: z33.enum(["focused", "backburner", "paused", "done"]),
-  rank: z33.number().int().positive().optional(),
-  ship_target: z33.string().optional(),
-  paused_since: z33.string().optional(),
-  updated: z33.string()
-});
-var sectionSchema = z33.object({
-  heading: z33.string(),
-  items: z33.array(itemSchema)
-});
-var parseErrorSchema2 = z33.object({
-  slug: z33.string(),
-  error: z33.string()
-});
-var resultSchema2 = z33.object({
-  sections: z33.array(sectionSchema),
-  parse_errors: z33.array(parseErrorSchema2)
+
+// src/search/index.ts
+import { createRetrievalEngine, ftsRetriever } from "@titan-design/retrieval";
+
+// src/session-index/graph.ts
+import Database from "better-sqlite3";
+import { openSessionGraph } from "@titan-design/session-graph";
+import { runMigrations, WatermarkTable } from "@titan-design/store-sqlite";
+import path34 from "path";
+
+// src/workspace-index/schema.ts
+import { kitDdl } from "@titan-design/store-sqlite";
+import { MIGRATIONS as SESSION_GRAPH_MIGRATIONS } from "@titan-design/session-graph";
+var WORKSPACE_KIT = {
+  watermark: "workspace_file",
+  edge: "edge",
+  spanFts: "search"
+};
+var WORKSPACE_SPAN_SOURCE_BASE = 1e9;
+var DOMAIN_DDL = `
+  CREATE TABLE IF NOT EXISTS initiative (
+    path            TEXT PRIMARY KEY,
+    initiative_ref  TEXT NOT NULL UNIQUE,
+    slug            TEXT NOT NULL,
+    title           TEXT,
+    state           TEXT,
+    rank            INTEGER,
+    ship_target     TEXT,
+    owner           TEXT,
+    task_prefix     TEXT,
+    updated         TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS note (
+    path        TEXT PRIMARY KEY,
+    note_ref    TEXT NOT NULL UNIQUE,
+    initiative  TEXT NOT NULL,
+    filename    TEXT NOT NULL,
+    kind        TEXT NOT NULL,
+    title       TEXT NOT NULL,
+    created     TEXT,
+    tags        TEXT,
+    hits        INTEGER NOT NULL DEFAULT 0,
+    promoted_at TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_note_initiative ON note(initiative);
+
+  CREATE TABLE IF NOT EXISTS workspace_task (
+    path        TEXT PRIMARY KEY,
+    task_ref    TEXT NOT NULL,
+    initiative  TEXT NOT NULL,
+    task_id     TEXT NOT NULL,
+    title       TEXT NOT NULL,
+    status      TEXT NOT NULL,
+    priority    INTEGER,
+    severity    TEXT,
+    estimate    REAL,
+    tags        TEXT,
+    created     TEXT,
+    updated     TEXT,
+    done_at     TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_workspace_task_ref ON workspace_task(task_ref);
+
+  CREATE TABLE IF NOT EXISTS session_record (
+    path              TEXT PRIMARY KEY,
+    session_ref       TEXT NOT NULL,
+    initiative        TEXT NOT NULL,
+    session_id        TEXT NOT NULL,
+    started           TEXT,
+    ended             TEXT,
+    track             TEXT,
+    parent_session_id TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_session_record_ref ON session_record(session_ref);
+
+  CREATE TABLE IF NOT EXISTS source (
+    path        TEXT PRIMARY KEY,
+    source_ref  TEXT NOT NULL UNIQUE,
+    initiative  TEXT NOT NULL,
+    title       TEXT,
+    kind        TEXT,
+    added       TEXT
+  );
+`;
+function nextVersion(chain) {
+  return (chain[chain.length - 1]?.version ?? 0) + 1;
+}
+var SPAN_SOURCE_INDEX = `
+  CREATE INDEX IF NOT EXISTS idx_search_span_source ON search_span(source_id);
+`;
+var WORKSPACE_MIGRATIONS = [
+  {
+    version: nextVersion(SESSION_GRAPH_MIGRATIONS),
+    name: "workspace index tables",
+    up: (db) => {
+      db.exec(kitDdl({ watermark: WORKSPACE_KIT.watermark }));
+      db.exec(DOMAIN_DDL);
+      db.exec(SPAN_SOURCE_INDEX);
+    }
+  }
+];
+var PRESERVE_DDL = `
+  CREATE TABLE IF NOT EXISTS preserved_row (
+    table_name   TEXT NOT NULL,
+    identity     TEXT NOT NULL,
+    row_key      TEXT NOT NULL,
+    payload      TEXT NOT NULL,
+    origin       TEXT NOT NULL,
+    mode         TEXT NOT NULL DEFAULT 'insert',
+    preserved_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+    PRIMARY KEY (table_name, row_key)
+  );
+`;
+var PRESERVE_MIGRATION = {
+  version: nextVersion([...SESSION_GRAPH_MIGRATIONS, ...WORKSPACE_MIGRATIONS]),
+  name: "preserved rows",
+  up: (db) => db.exec(PRESERVE_DDL)
+};
+var MIGRATIONS = [
+  ...SESSION_GRAPH_MIGRATIONS,
+  ...WORKSPACE_MIGRATIONS,
+  PRESERVE_MIGRATION
+];
+
+// src/session-index/graph.ts
+var SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
+function defaultGraphPath() {
+  return path34.join(getMinerRoot(), "graph.sqlite3");
+}
+function openGraph(dbPath = defaultGraphPath()) {
+  const graph = openSessionGraph(dbPath);
+  runMigrations(graph.db, MIGRATIONS);
+  return {
+    ...graph,
+    workspaceFiles: new WatermarkTable(graph.db, { name: WORKSPACE_KIT.watermark })
+  };
+}
+function openGraphReadOnly(dbPath = defaultGraphPath()) {
+  return new Database(dbPath, { readonly: true });
+}
+
+// src/search/classes.ts
+var TRANSCRIPT_FIELDS = ["prompt", "assistant_response", "tool_input", "tool_result"];
+var SEARCH_CLASSES = [
+  { name: "notes", scope: { ownerPrefix: "note:" }, weight: 1.3, share: 0.5 },
+  // Briefs are the most distilled statement of what an initiative is, and there
+  // are only 56 spans of them. The design's table predates the indexer and
+  // omits the class; including it costs nothing and makes `brief.md` findable.
+  { name: "initiatives", scope: { ownerPrefix: "initiative:" }, weight: 1.15, share: 0.2 },
+  { name: "sources", scope: { ownerPrefix: "source:" }, weight: 1.1, share: 0.3 },
+  { name: "tasks", scope: { ownerPrefix: "task:" }, weight: 1, share: 0.3 },
+  // Narrative restatements of the notes, written by the session that wrote
+  // them: the workspace's own duplicate content, so low on both counts.
+  {
+    name: "sessions",
+    scope: { ownerPrefix: "session:", fields: ["body"] },
+    weight: 0.6,
+    share: 0.2
+  },
+  {
+    name: "transcripts",
+    scope: { ownerPrefix: "session:", fields: TRANSCRIPT_FIELDS },
+    weight: 0.45,
+    share: 0.2
+  }
+];
+function capFor(cls, limit) {
+  return Math.max(1, Math.ceil(limit * cls.share));
+}
+function classOf(ref, field) {
+  const prefix = ref.slice(0, ref.indexOf(":"));
+  if (prefix !== "session") return `${prefix}s`;
+  return field !== void 0 && TRANSCRIPT_FIELDS.includes(field) ? "transcripts" : "sessions";
+}
+
+// src/search/resolve.ts
+import path36 from "path";
+import { readLocatorText } from "@titan-design/locator";
+
+// src/workspace-index/refs.ts
+import path35 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 path35.relative(activeRoot, absolutePath).split(path35.sep).join("/");
+}
+function toAbsolute(activeRoot, relativePath) {
+  return path35.join(activeRoot, ...relativePath.split("/"));
+}
+
+// src/search/resolve.ts
+var ROW_SOURCES = [
+  { table: "note", refColumn: "note_ref", title: "title" },
+  { table: "workspace_task", refColumn: "task_ref", title: "title" },
+  { table: "source", refColumn: "source_ref", title: "title" },
+  { table: "initiative", refColumn: "initiative_ref", title: "title" },
+  { table: "session_record", refColumn: "session_ref", title: "session_id" }
+];
+function rowFor(graph, ref) {
+  for (const { table, refColumn, title } of ROW_SOURCES) {
+    const row = graph.db.prepare(
+      `SELECT path, "${title}" AS title, ${table === "initiative" ? "slug" : "initiative"} AS initiative
+           FROM "${table}" WHERE "${refColumn}" = ? LIMIT 1`
+    ).get(ref);
+    if (row) return row;
+  }
+  return null;
+}
+function fileForSource(graph, sourceId, activeRoot) {
+  if (sourceId >= WORKSPACE_SPAN_SOURCE_BASE) {
+    const row2 = graph.db.prepare("SELECT source_key FROM workspace_file WHERE source_id = ?").get(sourceId - WORKSPACE_SPAN_SOURCE_BASE);
+    return row2 ? toAbsolute(activeRoot, row2.source_key) : null;
+  }
+  const row = graph.db.prepare("SELECT source_key FROM transcript WHERE source_id = ?").get(sourceId);
+  if (!row) return null;
+  return row.source_key.startsWith("~") ? path36.join(process.env.HOME ?? "", row.source_key.slice(1)) : row.source_key;
+}
+function oneLine(text, width) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= width ? flat : `${flat.slice(0, width - 1)}\u2026`;
+}
+async function excerptFor(graph, payload, activeRoot, width) {
+  if (!payload) return null;
+  const file = fileForSource(graph, payload.sourceId, activeRoot);
+  if (file === null) return null;
+  try {
+    const locator = [0, payload.byteOffset, payload.byteLength];
+    return oneLine(await readLocatorText(file, locator), width);
+  } catch {
+    return null;
+  }
+}
+function spanPayload(result) {
+  const first = Object.values(result.payloads)[0];
+  return first;
+}
+async function resolveHits(graph, results, activeRoot, excerptWidth) {
+  return Promise.all(
+    results.map(async (result) => {
+      const payload = spanPayload(result);
+      const row = rowFor(graph, result.id);
+      return {
+        ref: result.id,
+        class: classOf(result.id, payload?.field),
+        initiative: row?.initiative ?? null,
+        title: row?.title ?? null,
+        path: row?.path ?? null,
+        excerpt: await excerptFor(graph, payload, activeRoot, excerptWidth),
+        score: result.score,
+        sources: result.sources
+      };
+    })
+  );
+}
+
+// src/search/index.ts
+var AFFINITY_BOOST = 7e-3;
+async function searchWorkspace(query, options = {}) {
+  const activeRoot = options.activeRoot ?? getActiveRoot();
+  const graph = options.graph ?? openGraph(options.dbPath ?? defaultGraphPath());
+  const owned = options.graph === void 0;
+  const limit = options.limit ?? 10;
+  try {
+    const engine = createRetrievalEngine({
+      retrievers: SEARCH_CLASSES.map(
+        (cls) => ftsRetriever(graph.spans, {
+          name: cls.name,
+          scope: cls.scope,
+          cap: capFor(cls, limit)
+        })
+      ),
+      fusion: {
+        weights: Object.fromEntries(SEARCH_CLASSES.map((cls) => [cls.name, cls.weight]))
+      }
+    });
+    const response = await engine.search(query, { limit });
+    const resolved = await resolveHits(
+      graph,
+      response.results,
+      activeRoot,
+      options.excerptWidth ?? 160
+    );
+    const boosted = options.initiative ? resolved.map(
+      (hit) => hit.initiative === options.initiative ? { ...hit, score: hit.score + AFFINITY_BOOST } : hit
+    ).sort((a, b) => b.score - a.score) : resolved;
+    return {
+      hits: boosted.slice(0, limit),
+      degraded: response.degraded,
+      timingsMs: response.timingsMs
+    };
+  } finally {
+    if (owned) graph.db.close();
+  }
+}
+
+// src/commands/search.ts
+var ArgsSchema32 = z33.object({
+  query: z33.string().min(1),
+  limit: z33.number().int().positive().max(100).optional(),
+  initiative: z33.string().min(1).optional()
+});
+var HitSchema = z33.object({
+  ref: z33.string(),
+  class: z33.string(),
+  initiative: z33.string().nullable(),
+  title: z33.string().nullable(),
+  path: z33.string().nullable(),
+  excerpt: z33.string().nullable(),
+  score: z33.number(),
+  sources: z33.array(z33.string())
+});
+var ResultSchema29 = z33.object({
+  query: z33.string(),
+  hits: z33.array(HitSchema),
+  // A retriever that failed contributed nothing and is named here. The search
+  // still answers, with less; an index is allowed to be partly broken.
+  degraded: z33.array(z33.object({ retriever: z33.string(), reason: z33.string(), message: z33.string() }))
+});
+var search_default = defineCommand({
+  name: "search",
+  description: "Search every initiative at once: notes, briefs, sources, tasks, session records and mined transcripts.",
+  args: ArgsSchema32,
+  result: ResultSchema29,
+  cli: {
+    positional: ["query"],
+    options: {
+      limit: { long: "--limit", description: "How many results to return (default 10)" },
+      initiative: {
+        long: "--initiative",
+        description: "Bias towards this initiative. A boost, never a filter \u2014 foreign hits still rank."
+      }
+    },
+    usage: "active-work search <query> [--limit 10] [--initiative <slug>]"
+  },
+  async run(args) {
+    const { hits, degraded } = await searchWorkspace(args.query, {
+      limit: args.limit,
+      initiative: args.initiative
+    });
+    return {
+      query: args.query,
+      hits,
+      degraded: degraded.map((entry) => ({
+        retriever: entry.retriever,
+        reason: entry.reason,
+        message: entry.message
+      }))
+    };
+  }
+});
+
+// src/commands/list.ts
+import { z as z34 } from "zod";
+var argsSchema2 = z34.object({}).strict();
+var itemSchema = z34.object({
+  slug: z34.string(),
+  title: z34.string(),
+  state: z34.enum(["focused", "backburner", "paused", "done"]),
+  rank: z34.number().int().positive().optional(),
+  ship_target: z34.string().optional(),
+  paused_since: z34.string().optional(),
+  updated: z34.string()
+});
+var sectionSchema = z34.object({
+  heading: z34.string(),
+  items: z34.array(itemSchema)
+});
+var parseErrorSchema2 = z34.object({
+  slug: z34.string(),
+  error: z34.string()
+});
+var resultSchema2 = z34.object({
+  sections: z34.array(sectionSchema),
+  parse_errors: z34.array(parseErrorSchema2)
 });
 function toItem(slug, fm) {
   return {
@@ -3946,24 +4304,24 @@ var list_default = defineCommand({
 });
 
 // src/commands/worktree-set.ts
-import path34 from "path";
-import { z as z34 } from "zod";
-var argsSchema3 = z34.object({
-  slug: z34.string().min(1),
-  path: z34.string().min(1),
-  label: z34.string().min(1).optional(),
-  default: z34.boolean().optional()
+import path37 from "path";
+import { z as z35 } from "zod";
+var argsSchema3 = z35.object({
+  slug: z35.string().min(1),
+  path: z35.string().min(1),
+  label: z35.string().min(1).optional(),
+  default: z35.boolean().optional()
 });
-var resultSchema3 = z34.object({
-  slug: z34.string(),
-  label: z34.string(),
-  path: z34.string(),
-  default: z34.boolean(),
+var resultSchema3 = z35.object({
+  slug: z35.string(),
+  label: z35.string(),
+  path: z35.string(),
+  default: z35.boolean(),
   /** True when this promoted a worktree `wrap` had already swept (AW-67). */
-  promoted: z34.boolean()
+  promoted: z35.boolean()
 });
 var DEFAULT_LABEL = "main";
-var samePath = (a, b) => path34.resolve(expandTilde(a)) === path34.resolve(expandTilde(b));
+var samePath = (a, b) => path37.resolve(expandTilde(a)) === path37.resolve(expandTilde(b));
 var worktree_set_default = defineCommand({
   name: "worktree.set",
   description: "Add or update a registered worktree on an existing initiative. A lone worktree is made default automatically; use --default to promote an added one. Registered worktrees live in artifacts.yml alongside the ones wrap sweeps, and are what `aw` resolves a cwd against.",
@@ -3985,8 +4343,8 @@ var worktree_set_default = defineCommand({
   },
   async run(args) {
     const label = args.label ?? DEFAULT_LABEL;
-    const initiativeDir = path34.join(getActiveRoot(), args.slug);
-    const briefPath = path34.join(initiativeDir, "brief.md");
+    const initiativeDir = path37.join(getActiveRoot(), args.slug);
+    const briefPath = path37.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(args.slug), async () => {
       let frontmatter2;
       let body;
@@ -4040,15 +4398,15 @@ var worktree_set_default = defineCommand({
 });
 
 // src/commands/worktree-set-default.ts
-import path35 from "path";
-import { z as z35 } from "zod";
-var argsSchema4 = z35.object({
-  slug: z35.string().min(1),
-  label: z35.string().min(1)
+import path38 from "path";
+import { z as z36 } from "zod";
+var argsSchema4 = z36.object({
+  slug: z36.string().min(1),
+  label: z36.string().min(1)
 });
-var resultSchema4 = z35.object({
-  slug: z35.string(),
-  default_label: z35.string()
+var resultSchema4 = z36.object({
+  slug: z36.string(),
+  default_label: z36.string()
 });
 var worktree_set_default_default = defineCommand({
   name: "worktree.set-default",
@@ -4059,8 +4417,8 @@ var worktree_set_default_default = defineCommand({
     positional: ["slug", "label"]
   },
   async run({ slug, label }) {
-    const initiativeDir = path35.join(getActiveRoot(), slug);
-    const briefPath = path35.join(initiativeDir, "brief.md");
+    const initiativeDir = path38.join(getActiveRoot(), slug);
+    const briefPath = path38.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(slug), async () => {
       let frontmatter2;
       let body;
@@ -4091,11 +4449,11 @@ var worktree_set_default_default = defineCommand({
 });
 
 // src/commands/discover.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 
 // src/discover/index.ts
 import { promises as fs29 } from "fs";
-import path39 from "path";
+import path42 from "path";
 
 // src/discover/run-command.ts
 import { spawn } from "child_process";
@@ -4192,13 +4550,13 @@ async function discoverGitHub(repos, run = runCommand) {
 }
 
 // src/discover/git.ts
-import path36 from "path";
+import path39 from "path";
 var BRANCH_LIMIT = 20;
 async function discoverGit(repoPaths, run = runCommand) {
   const hits = [];
   const errors = [];
   for (const repoPath of repoPaths) {
-    const repoName = path36.basename(repoPath);
+    const repoName = path39.basename(repoPath);
     await collectBranches(repoPath, repoName, hits, errors, run);
     await collectWorktrees(repoPath, repoName, hits, errors, run);
     await collectStashes(repoPath, repoName, hits, errors, run);
@@ -4313,14 +4671,14 @@ function errStr(err) {
 
 // src/discover/projects.ts
 import { promises as fs27 } from "fs";
-import path37 from "path";
+import path40 from "path";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var RECENT_THRESHOLD_DAYS = 30;
 async function discoverProjects(projectsRoot) {
   const hits = [];
   const errors = [];
   if (!projectsRoot) return { hits, errors };
-  const resolved = path37.resolve(expandTilde(projectsRoot));
+  const resolved = path40.resolve(expandTilde(projectsRoot));
   let entries;
   try {
     entries = await fs27.readdir(resolved, { withFileTypes: true });
@@ -4336,7 +4694,7 @@ async function discoverProjects(projectsRoot) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     if (entry.name === "active") continue;
-    const fullPath = path37.join(resolved, entry.name);
+    const fullPath = path40.join(resolved, entry.name);
     let mtimeMs = 0;
     try {
       const stat = await fs27.stat(fullPath);
@@ -4369,11 +4727,11 @@ async function discoverProjects(projectsRoot) {
 // src/discover/claude.ts
 import { promises as fs28 } from "fs";
 import os2 from "os";
-import path38 from "path";
+import path41 from "path";
 var MAX_SCAN_LINES = 200;
 var COMPACTION_SUBJECT_PREFIX = "[compaction] ";
 async function discoverClaudeSessions() {
-  const root = process.env.CLAUDE_PROJECTS_ROOT ?? path38.join(os2.homedir(), ".claude", "projects");
+  const root = process.env.CLAUDE_PROJECTS_ROOT ?? path41.join(os2.homedir(), ".claude", "projects");
   const hits = [];
   const errors = [];
   let projectDirs;
@@ -4388,7 +4746,7 @@ async function discoverClaudeSessions() {
   const byCwd = /* @__PURE__ */ new Map();
   for (const dir of projectDirs) {
     if (!dir.isDirectory()) continue;
-    const dirPath = path38.join(root, dir.name);
+    const dirPath = path41.join(root, dir.name);
     let files;
     try {
       files = await fs28.readdir(dirPath, { withFileTypes: true });
@@ -4401,7 +4759,7 @@ async function discoverClaudeSessions() {
     }
     for (const file of files) {
       if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
-      const filePath = path38.join(dirPath, file.name);
+      const filePath = path41.join(dirPath, file.name);
       try {
         await aggregateSession(filePath, byCwd);
       } catch (err) {
@@ -4457,7 +4815,7 @@ async function aggregateSession(filePath, byCwd) {
   }
   if (!cwd) return;
   const subject = lastCompactionSummary ? `${COMPACTION_SUBJECT_PREFIX}${truncate2(lastCompactionSummary, 120)}` : firstUserMessage ? truncate2(firstUserMessage, 120) : "";
-  const sessionId = path38.basename(filePath, ".jsonl");
+  const sessionId = path41.basename(filePath, ".jsonl");
   const existing = byCwd.get(cwd);
   if (!existing) {
     byCwd.set(cwd, {
@@ -4557,7 +4915,7 @@ async function loadSlugs(activeRoot) {
   }
 }
 async function loadTriagedRefs(activeRoot) {
-  const logPath = path39.join(activeRoot, ".triaged.log");
+  const logPath = path42.join(activeRoot, ".triaged.log");
   const refs = /* @__PURE__ */ new Set();
   try {
     const raw = await fs29.readFile(logPath, "utf8");
@@ -4583,28 +4941,28 @@ function matchSlug(hit, slugs) {
 }
 
 // src/commands/discover.ts
-var ArgsSchema32 = z36.object({
-  github_repos: z36.array(z36.string().min(1)).optional(),
-  local_repos: z36.array(z36.string().min(1)).optional(),
-  projects_root: z36.string().optional()
-});
-var HitSchema = z36.object({
-  source: z36.string(),
-  ref: z36.string(),
-  detail: z36.string(),
-  metadata: z36.record(z36.string(), z36.unknown()).optional(),
-  slug_match: z36.string().optional(),
-  untracked: z36.boolean().optional()
-});
-var ResultSchema29 = z36.object({
-  hits: z36.array(HitSchema),
-  errors: z36.array(z36.object({ source: z36.string(), error: z36.string() }))
+var ArgsSchema33 = z37.object({
+  github_repos: z37.array(z37.string().min(1)).optional(),
+  local_repos: z37.array(z37.string().min(1)).optional(),
+  projects_root: z37.string().optional()
+});
+var HitSchema2 = z37.object({
+  source: z37.string(),
+  ref: z37.string(),
+  detail: z37.string(),
+  metadata: z37.record(z37.string(), z37.unknown()).optional(),
+  slug_match: z37.string().optional(),
+  untracked: z37.boolean().optional()
+});
+var ResultSchema30 = z37.object({
+  hits: z37.array(HitSchema2),
+  errors: z37.array(z37.object({ source: z37.string(), error: z37.string() }))
 });
 var discover_default = defineCommand({
   name: "discover",
   description: "Scan configured sources (gh PRs, local git, projects root, Claude sessions) and emit unfiltered discovery hits.",
-  args: ArgsSchema32,
-  result: ResultSchema29,
+  args: ArgsSchema33,
+  result: ResultSchema30,
   cli: {
     options: {
       github_repos: {
@@ -4631,15 +4989,15 @@ var discover_default = defineCommand({
 });
 
 // src/commands/drop.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 
 // src/discover/triaged-log.ts
 import { promises as fs30 } from "fs";
-import path40 from "path";
+import path43 from "path";
 async function appendTriagedLog(action, ref, extra) {
   const root = getActiveRoot();
   await fs30.mkdir(root, { recursive: true });
-  const logPath = path40.join(root, ".triaged.log");
+  const logPath = path43.join(root, ".triaged.log");
   let existing = "";
   try {
     existing = await fs30.readFile(logPath, "utf8");
@@ -4652,18 +5010,18 @@ async function appendTriagedLog(action, ref, extra) {
 }
 
 // src/commands/drop.ts
-var ArgsSchema33 = z37.object({
-  ref: z37.string().min(1),
-  reason: z37.string().optional()
+var ArgsSchema34 = z38.object({
+  ref: z38.string().min(1),
+  reason: z38.string().optional()
 });
-var ResultSchema30 = z37.object({
-  ref: z37.string()
+var ResultSchema31 = z38.object({
+  ref: z38.string()
 });
 var drop_default = defineCommand({
   name: "drop",
   description: "Mark a discover hit as dropped so future discovers suppress it.",
-  args: ArgsSchema33,
-  result: ResultSchema30,
+  args: ArgsSchema34,
+  result: ResultSchema31,
   cli: {
     positional: ["ref"],
     options: {
@@ -4681,23 +5039,23 @@ var drop_default = defineCommand({
 
 // src/commands/fold.ts
 import { promises as fs31 } from "fs";
-import path41 from "path";
-import { z as z38 } from "zod";
-var ArgsSchema34 = z38.object({
-  ref: z38.string().min(1),
-  into: z38.string().min(1),
-  note: z38.string().optional()
+import path44 from "path";
+import { z as z39 } from "zod";
+var ArgsSchema35 = z39.object({
+  ref: z39.string().min(1),
+  into: z39.string().min(1),
+  note: z39.string().optional()
 });
-var ResultSchema31 = z38.object({
-  ref: z38.string(),
-  into: z38.string(),
-  session_file: z38.string()
+var ResultSchema32 = z39.object({
+  ref: z39.string(),
+  into: z39.string(),
+  session_file: z39.string()
 });
 var fold_default = defineCommand({
   name: "fold",
   description: "Mark a discover hit as folded into an existing initiative.",
-  args: ArgsSchema34,
-  result: ResultSchema31,
+  args: ArgsSchema35,
+  result: ResultSchema32,
   cli: {
     positional: ["ref"],
     options: {
@@ -4723,7 +5081,7 @@ var fold_default = defineCommand({
       if (err instanceof NotFoundError) throw err;
       throw new NotFoundError(`Initiative not found: ${args.into}`);
     }
-    const sessionsDir = path41.join(initiativeDir, "sessions");
+    const sessionsDir = path44.join(initiativeDir, "sessions");
     await fs31.mkdir(sessionsDir, { recursive: true });
     const startedIso = nowIso();
     const stem = buildSessionStem(startedIso, `folded-${sanitizeRef(args.ref)}`);
@@ -4756,27 +5114,27 @@ function sanitizeRef(ref) {
 
 // src/commands/track.ts
 import { promises as fs32 } from "fs";
-import path42 from "path";
-import { z as z39 } from "zod";
+import path45 from "path";
+import { z as z40 } from "zod";
 import { stringify as yamlStringify } from "yaml";
-var ArgsSchema35 = z39.object({
-  ref: z39.string().min(1),
-  slug: z39.string().min(1),
-  title: z39.string().optional(),
-  ship_target: z39.string().optional(),
-  owner: z39.string().optional(),
-  worktree: z39.string().optional()
-});
-var ResultSchema32 = z39.object({
-  slug: z39.string(),
-  dir: z39.string(),
-  ref: z39.string()
+var ArgsSchema36 = z40.object({
+  ref: z40.string().min(1),
+  slug: z40.string().min(1),
+  title: z40.string().optional(),
+  ship_target: z40.string().optional(),
+  owner: z40.string().optional(),
+  worktree: z40.string().optional()
+});
+var ResultSchema33 = z40.object({
+  slug: z40.string(),
+  dir: z40.string(),
+  ref: z40.string()
 });
 var track_default = defineCommand({
   name: "track",
   description: "Scaffold a new initiative from a discover hit.",
-  args: ArgsSchema35,
-  result: ResultSchema32,
+  args: ArgsSchema36,
+  result: ResultSchema33,
   cli: {
     positional: ["ref"],
     options: {
@@ -4803,13 +5161,13 @@ var track_default = defineCommand({
     if (await dirExists5(dir)) {
       throw new UsageError(`Initiative already exists: ${args.slug}`);
     }
-    await fs32.mkdir(path42.join(dir, "tasks"), { recursive: true });
-    await fs32.mkdir(path42.join(dir, "sessions"), { recursive: true });
-    await fs32.mkdir(path42.join(dir, "sources"), { recursive: true });
+    await fs32.mkdir(path45.join(dir, "tasks"), { recursive: true });
+    await fs32.mkdir(path45.join(dir, "sessions"), { recursive: true });
+    await fs32.mkdir(path45.join(dir, "sources"), { recursive: true });
     const title = args.title ?? deriveTitle(args.slug);
     const briefBody = buildBriefBody(title, args.ref);
     await writeFrontmatter(
-      path42.join(dir, "brief.md"),
+      path45.join(dir, "brief.md"),
       {
         schema_version: 1,
         title,
@@ -4825,8 +5183,8 @@ var track_default = defineCommand({
     const artifacts = ArtifactsSchema.parse({
       worktrees: args.worktree ? [{ path: args.worktree, repo: args.worktree, name: "main", default: true }] : []
     });
-    await atomicWrite(path42.join(dir, "artifacts.yml"), yamlStringify(artifacts));
-    await atomicWrite(path42.join(dir, "sources", ".gitkeep"), "");
+    await atomicWrite(path45.join(dir, "artifacts.yml"), yamlStringify(artifacts));
+    await atomicWrite(path45.join(dir, "sources", ".gitkeep"), "");
     await appendTriagedLog("track", args.ref, `slug:${args.slug}`);
     return { slug: args.slug, dir, ref: args.ref };
   }
@@ -4856,24 +5214,24 @@ function buildBriefBody(title, ref) {
 }
 
 // src/commands/prompt.ts
-import { z as z40 } from "zod";
-var ArgsSchema36 = z40.object({
-  slug: z40.string().min(1).optional(),
-  offline: z40.boolean().optional(),
+import { z as z41 } from "zod";
+var ArgsSchema37 = z41.object({
+  slug: z41.string().min(1).optional(),
+  offline: z41.boolean().optional(),
   // Directory to resolve the initiative from when no slug is given. Falls back
   // to the interactive-surface context cwd; unset for daemon/MCP callers.
-  cwd: z40.string().min(1).optional(),
+  cwd: z41.string().min(1).optional(),
   // Frame the prompt as ad-hoc work on the workstream rather than a
   // continuation of its handoff / top task.
-  adhoc: z40.boolean().optional(),
+  adhoc: z41.boolean().optional(),
   // Skip the check for another session already live on this initiative.
-  no_sibling_check: z40.boolean().optional()
+  no_sibling_check: z41.boolean().optional()
 });
 var promptCommand = defineCommand({
   name: "prompt",
   description: "Print the bootstrap prompt for an initiative \u2014 the same text `aw` feeds Claude at launch \u2014 without any side effects. Resolves the initiative from a slug or the caller's cwd. Use it to re-seed context in a running session.",
-  args: ArgsSchema36,
-  result: z40.string(),
+  args: ArgsSchema37,
+  result: z41.string(),
   cli: {
     positional: ["slug"],
     options: {
@@ -4926,19 +5284,19 @@ var prompt_default = promptCommand;
 
 // src/commands/edit.ts
 import { promises as fs33 } from "fs";
-import path43 from "path";
+import path46 from "path";
 import { spawn as spawn2 } from "child_process";
-import { z as z41 } from "zod";
-var ArgsSchema37 = z41.object({
-  slug: z41.string().min(1),
-  target: z41.enum(["brief"]).default("brief")
+import { z as z42 } from "zod";
+var ArgsSchema38 = z42.object({
+  slug: z42.string().min(1),
+  target: z42.enum(["brief"]).default("brief")
 });
-var ResultSchema33 = z41.object({
-  slug: z41.string(),
-  target: z41.enum(["brief"]),
-  file: z41.string(),
-  validated: z41.boolean(),
-  aborted: z41.boolean().optional()
+var ResultSchema34 = z42.object({
+  slug: z42.string(),
+  target: z42.enum(["brief"]),
+  file: z42.string(),
+  validated: z42.boolean(),
+  aborted: z42.boolean().optional()
 });
 async function resolveEditor(filePath) {
   const editorEnv = process.env.EDITOR;
@@ -4977,7 +5335,7 @@ var defaultDeps = {
   spawner: defaultSpawner
 };
 function targetFile(slug) {
-  return path43.join(getInitiativeDir(slug), "brief.md");
+  return path46.join(getInitiativeDir(slug), "brief.md");
 }
 async function fileExists2(p) {
   try {
@@ -5025,8 +5383,8 @@ ${message}`,
 var edit = defineCommand({
   name: "edit",
   description: "Open the operator's editor on brief.md.",
-  args: ArgsSchema37,
-  result: ResultSchema33,
+  args: ArgsSchema38,
+  result: ResultSchema34,
   cli: {
     positional: ["slug", "target"],
     usage: "active-work edit <slug> [brief]"
@@ -5039,7 +5397,7 @@ var edit_default = edit;
 
 // src/commands/mcp-serve.ts
 import { spawn as spawn3 } from "child_process";
-import { z as z42 } from "zod";
+import { z as z44 } from "zod";
 
 // src/server/mcp.ts
 import {
@@ -5055,9 +5413,8 @@ import {
   toolNameToCommandName as pkgToolNameToCommandName
 } from "@titan-design/registry";
 
-// src/server/health.ts
-var DAEMON_VERSION = "0.1.0";
-var startedAt = Date.now();
+// src/version.ts
+var BUILD_VERSION = "0.6.0";
 
 // src/server/mcp.ts
 var TOOL_NAME_PREFIX = "active__";
@@ -5068,7 +5425,7 @@ function mcpOptions() {
     formatError,
     toolPrefix: TOOL_NAME_PREFIX,
     name: "@hjewkes/active-work",
-    version: DAEMON_VERSION
+    version: BUILD_VERSION
   };
 }
 async function runMcpStdio() {
@@ -5080,7 +5437,7 @@ import { DaemonAlreadyRunningError, startDaemon } from "@titan-design/daemon";
 
 // src/server/dashboard-routes.ts
 import { promises as fs34 } from "fs";
-import path44 from "path";
+import path47 from "path";
 import { fileURLToPath } from "url";
 var PLACEHOLDER_HTML = `<!doctype html>
 <html lang="en">
@@ -5112,17 +5469,17 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filename) {
-  const ext = path44.extname(filename).toLowerCase();
+  const ext = path47.extname(filename).toLowerCase();
   return CONTENT_TYPES[ext] ?? "application/octet-stream";
 }
 function dashboardDirCandidates() {
-  const here = path44.dirname(fileURLToPath(import.meta.url));
+  const here = path47.dirname(fileURLToPath(import.meta.url));
   return [
-    path44.resolve(here, "dashboard"),
+    path47.resolve(here, "dashboard"),
     // bundled: dist/cli.js -> dist/dashboard
-    path44.resolve(here, "..", "dashboard"),
+    path47.resolve(here, "..", "dashboard"),
     // legacy: dist/server -> dist/dashboard
-    path44.resolve(here, "..", "..", "dist", "dashboard")
+    path47.resolve(here, "..", "..", "dist", "dashboard")
     // dev: src/server -> dist/dashboard
   ];
 }
@@ -5139,205 +5496,67 @@ async function resolveDashboardDir() {
     if ((await safeStat(dir)).exists) return dir;
   }
   return null;
-}
-async function handleDashboard(c) {
-  const root = await resolveDashboardDir();
-  if (!root) {
-    return c.html(PLACEHOLDER_HTML, 200);
-  }
-  const url = new URL(c.req.url);
-  const subpath = url.pathname.replace(/^\/ui\/?/, "");
-  const relative = subpath === "" ? "index.html" : subpath;
-  const target = path44.resolve(root, relative);
-  if (!target.startsWith(root + path44.sep) && target !== root) {
-    return c.text("forbidden", 403);
-  }
-  const stat = await safeStat(target);
-  if (!stat.exists || !stat.isFile) {
-    const indexPath = path44.join(root, "index.html");
-    const indexStat = await safeStat(indexPath);
-    if (!indexStat.exists) {
-      return c.html(PLACEHOLDER_HTML, 200);
-    }
-    const body2 = await fs34.readFile(indexPath);
-    return c.body(new Uint8Array(body2), 200, {
-      "content-type": "text/html; charset=utf-8"
-    });
-  }
-  const body = await fs34.readFile(target);
-  return c.body(new Uint8Array(body), 200, {
-    "content-type": contentTypeFor(target)
-  });
-}
-
-// src/server/logger.ts
-import { mkdirSync, createWriteStream } from "fs";
-import path45 from "path";
-import pino, { multistream } from "pino";
-var cachedLogger;
-function buildLogger() {
-  const stateRoot = getStateRoot();
-  mkdirSync(stateRoot, { recursive: true });
-  const logPath = path45.join(stateRoot, "daemon.log");
-  const fileStream = createWriteStream(logPath, { flags: "a" });
-  const stderrIsTTY = process.stderr.isTTY === true;
-  const stderrStream = stderrIsTTY ? pino.transport({
-    target: "pino-pretty",
-    options: { destination: 2, colorize: true }
-  }) : process.stderr;
-  const streams = [{ stream: stderrStream }, { stream: fileStream }];
-  return pino({ level: process.env.AW_LOG_LEVEL ?? "info" }, multistream(streams));
-}
-function getLogger() {
-  cachedLogger ??= buildLogger();
-  return cachedLogger;
-}
-
-// src/server/session-index-watch.ts
-import { existsSync } from "fs";
-import { transcriptsRoot as transcriptsRoot2 } from "@titan-design/session-read";
-import { watchTree } from "@titan-design/daemon";
-
-// src/session-index/graph.ts
-import Database from "better-sqlite3";
-import { openSessionGraph } from "@titan-design/session-graph";
-import { runMigrations, WatermarkTable } from "@titan-design/store-sqlite";
-import 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);
+}
+async function handleDashboard(c) {
+  const root = await resolveDashboardDir();
+  if (!root) {
+    return c.html(PLACEHOLDER_HTML, 200);
+  }
+  const url = new URL(c.req.url);
+  const subpath = url.pathname.replace(/^\/ui\/?/, "");
+  const relative = subpath === "" ? "index.html" : subpath;
+  const target = path47.resolve(root, relative);
+  if (!target.startsWith(root + path47.sep) && target !== root) {
+    return c.text("forbidden", 403);
+  }
+  const stat = await safeStat(target);
+  if (!stat.exists || !stat.isFile) {
+    const indexPath = path47.join(root, "index.html");
+    const indexStat = await safeStat(indexPath);
+    if (!indexStat.exists) {
+      return c.html(PLACEHOLDER_HTML, 200);
     }
+    const body2 = await fs34.readFile(indexPath);
+    return c.body(new Uint8Array(body2), 200, {
+      "content-type": "text/html; charset=utf-8"
+    });
   }
-];
-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");
+  const body = await fs34.readFile(target);
+  return c.body(new Uint8Array(body), 200, {
+    "content-type": contentTypeFor(target)
+  });
 }
-function openGraph(dbPath = defaultGraphPath()) {
-  const graph = openSessionGraph(dbPath);
-  runMigrations(graph.db, MIGRATIONS);
-  return {
-    ...graph,
-    workspaceFiles: new WatermarkTable(graph.db, { name: WORKSPACE_KIT.watermark })
-  };
+
+// src/server/logger.ts
+import { mkdirSync, createWriteStream } from "fs";
+import path48 from "path";
+import pino, { multistream } from "pino";
+var cachedLogger;
+function buildLogger() {
+  const stateRoot = getStateRoot();
+  mkdirSync(stateRoot, { recursive: true });
+  const logPath = path48.join(stateRoot, "daemon.log");
+  const fileStream = createWriteStream(logPath, { flags: "a" });
+  const stderrIsTTY = process.stderr.isTTY === true;
+  const stderrStream = stderrIsTTY ? pino.transport({
+    target: "pino-pretty",
+    options: { destination: 2, colorize: true }
+  }) : process.stderr;
+  const streams = [{ stream: stderrStream }, { stream: fileStream }];
+  return pino({ level: process.env.AW_LOG_LEVEL ?? "info" }, multistream(streams));
 }
-function openGraphReadOnly(dbPath = defaultGraphPath()) {
-  return new Database(dbPath, { readonly: true });
+function getLogger() {
+  cachedLogger ??= buildLogger();
+  return cachedLogger;
 }
 
+// src/server/session-index-watch.ts
+import { existsSync } from "fs";
+import { transcriptsRoot as transcriptsRoot2 } from "@titan-design/session-read";
+import { watchTree } from "@titan-design/daemon";
+
 // src/session-index/refresh.ts
-import path56 from "path";
+import path57 from "path";
 import { promises as fs44 } from "fs";
 import lockfile from "proper-lockfile";
 import { discoverTranscripts, transcriptsRoot } from "@titan-design/session-read";
@@ -5345,7 +5564,7 @@ import { refreshCorpus, resetIndex } from "@titan-design/session-graph";
 
 // src/session-index/tasks.ts
 import { promises as fs35 } from "fs";
-import path47 from "path";
+import path49 from "path";
 var AMBIGUOUS = null;
 async function initiativeSlugs(root) {
   try {
@@ -5357,7 +5576,7 @@ async function initiativeSlugs(root) {
   }
 }
 async function readInitiative(root, slug) {
-  const dir = path47.join(root, slug, "tasks");
+  const dir = path49.join(root, slug, "tasks");
   let files;
   try {
     files = await fs35.readdir(dir);
@@ -5369,7 +5588,7 @@ async function readInitiative(root, slug) {
   for (const file of files) {
     if (!file.endsWith(".yml")) continue;
     try {
-      const task = await readYaml(path47.join(dir, file), TaskSchema);
+      const task = await readYaml(path49.join(dir, file), TaskSchema);
       found.push([task.id, { initiative: slug, title: task.title, status: task.status }]);
     } catch {
       continue;
@@ -5402,21 +5621,7 @@ 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("/"));
-}
+import { z as z43 } from "zod";
 
 // 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;
@@ -5437,8 +5642,8 @@ function extractMentions(body, initiative, index) {
   for (const id of matches(body, NOTE_REF)) {
     if (index.noteRefs.has(noteRef(id))) found.add(noteRef(id));
   }
-  for (const path67 of matches(body, SOURCE_PATH)) {
-    const scoped = `${initiative}/${path67}`;
+  for (const path68 of matches(body, SOURCE_PATH)) {
+    const scoped = `${initiative}/${path68}`;
     if (index.sourcePaths.has(scoped)) found.add(sourceRef(scoped));
   }
   return [...found].sort();
@@ -5775,26 +5980,26 @@ function compact(spans) {
 
 // src/workspace-index/scan.ts
 import { promises as fs42 } from "fs";
-import path55 from "path";
+import path56 from "path";
 
 // src/lint/index.ts
 import { promises as fs41 } from "fs";
-import path54 from "path";
+import path55 from "path";
 
 // src/lint/brief.ts
 import { promises as fs37 } from "fs";
-import path49 from "path";
+import path50 from "path";
 
 // src/lint/hashes.ts
 import { promises as fs38 } from "fs";
-import path50 from "path";
+import path51 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");
+      content = await fs38.readFile(path51.join(initiativeDir, relPath), "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") continue;
@@ -5812,16 +6017,16 @@ async function lintHashes(slug, initiativeDir) {
 }
 
 // src/lint/open-loops.ts
-import path51 from "path";
+import path52 from "path";
 
 // src/lint/task.ts
 import { promises as fs39 } from "fs";
-import path52 from "path";
+import path53 from "path";
 import YAML2 from "yaml";
 
 // src/lint/zero-loops.ts
 import { promises as fs40 } from "fs";
-import path53 from "path";
+import path54 from "path";
 import YAML3 from "yaml";
 
 // src/lint/index.ts
@@ -5850,21 +6055,21 @@ function isVisible(entry, extensions) {
 }
 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();
+  return entries.filter((entry) => isVisible(entry, extensions)).map((entry) => path56.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"]);
+  const archive = await filesIn(path56.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 dir = path56.join(activeRoot, slug);
+  const brief = path56.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"])
+    filesIn(path56.join(dir, "sources", "notes"), [".md"]),
+    taskFiles(path56.join(dir, "tasks")),
+    filesIn(path56.join(dir, "sessions"), [".md"]),
+    filesIn(path56.join(dir, "sources"), [".md"])
   ]);
   return [
     ...notes.map((p) => ["note", p]),
@@ -6031,16 +6236,17 @@ function isUnchanged(row, file) {
   return row.lastOffset > 0 && row.fileSize === file.size && row.fileMtime === file.mtime;
 }
 var BATCH = 200;
+function describeFailure(err) {
+  if (err instanceof z43.ZodError) {
+    return err.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+  }
+  return err instanceof Error ? err.message : String(err);
+}
 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)
-    };
+    return { file, watermarkId, record: null, reason: describeFailure(err) };
   }
 }
 function applyBatch(graph, writer, batch) {
@@ -6273,7 +6479,7 @@ function refreshLockPath() {
 }
 async function withRefreshLock(fn) {
   const target = refreshLockPath();
-  await fs44.mkdir(path56.dirname(target), { recursive: true });
+  await fs44.mkdir(path57.dirname(target), { recursive: true });
   await fs44.writeFile(target, "", { flag: "a" });
   const release = await lockfile.lock(target, {
     realpath: false,
@@ -6287,7 +6493,7 @@ async function withRefreshLock(fn) {
   }
 }
 async function runRefresh(options = {}) {
-  const startedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const started = Date.now();
   const graph = options.graph ?? openGraph(options.dbPath ?? defaultGraphPath());
   const owned = options.graph === void 0;
@@ -6312,7 +6518,7 @@ async function runRefresh(options = {}) {
     });
     const preserved = replayPreserved(graph);
     return {
-      startedAt: startedAt2,
+      startedAt,
       durationMs: Date.now() - started,
       transcripts: discovered.length,
       scanned: visiting.length,
@@ -6498,7 +6704,7 @@ async function runDaemon(options = {}) {
     stateDir: getStateRoot(),
     port: resolvePort(options),
     watchRoot: getActiveRoot(),
-    version: DAEMON_VERSION,
+    version: BUILD_VERSION,
     logger: log,
     health: () => ({ index: toHealthIndexState(indexWatch?.status()) }),
     mountRoutes: (app) => {
@@ -6537,15 +6743,15 @@ async function runDaemon(options = {}) {
 }
 
 // src/commands/mcp-serve.ts
-var ArgsSchema38 = z42.object({
-  stdio: z42.boolean().optional(),
-  detach: z42.boolean().optional(),
-  port: z42.number().int().positive().optional()
+var ArgsSchema39 = z44.object({
+  stdio: z44.boolean().optional(),
+  detach: z44.boolean().optional(),
+  port: z44.number().int().positive().optional()
 });
-var ResultSchema34 = z42.object({
-  mode: z42.enum(["stdio", "http", "detached"]),
-  pid: z42.number().optional(),
-  port: z42.number().optional()
+var ResultSchema35 = z44.object({
+  mode: z44.enum(["stdio", "http", "detached"]),
+  pid: z44.number().optional(),
+  port: z44.number().optional()
 });
 function detachedSpawn(port) {
   const entry = process.argv[1];
@@ -6567,8 +6773,8 @@ function detachedSpawn(port) {
 var mcp_serve_default = defineCommand({
   name: "mcp.serve",
   description: "Start the MCP server. --stdio for stdio mode; --detach to fork the HTTP daemon; otherwise runs the HTTP daemon in the foreground.",
-  args: ArgsSchema38,
-  result: ResultSchema34,
+  args: ArgsSchema39,
+  result: ResultSchema35,
   cli: {
     options: {
       stdio: {
@@ -6600,11 +6806,11 @@ var mcp_serve_default = defineCommand({
 });
 
 // src/commands/mcp-stop.ts
-import { z as z43 } from "zod";
-var ArgsSchema39 = z43.object({});
-var ResultSchema35 = z43.union([
-  z43.object({ stopped: z43.literal(true), pid: z43.number() }),
-  z43.object({ stopped: z43.literal(false), reason: z43.string() })
+import { z as z45 } from "zod";
+var ArgsSchema40 = z45.object({});
+var ResultSchema36 = z45.union([
+  z45.object({ stopped: z45.literal(true), pid: z45.number() }),
+  z45.object({ stopped: z45.literal(false), reason: z45.string() })
 ]);
 var SHUTDOWN_TIMEOUT_MS = 3e3;
 var POLL_INTERVAL_MS = 100;
@@ -6619,8 +6825,8 @@ async function waitForExit(pid, timeoutMs) {
 var mcp_stop_default = defineCommand({
   name: "mcp.stop",
   description: "Stop the running MCP HTTP daemon (sends SIGTERM, waits for exit).",
-  args: ArgsSchema39,
-  result: ResultSchema35,
+  args: ArgsSchema40,
+  result: ResultSchema36,
   async run() {
     const pidEntry = await readPidFile();
     if (!pidEntry) {
@@ -6649,13 +6855,13 @@ var mcp_stop_default = defineCommand({
 
 // src/commands/mcp-restart.ts
 import { spawn as spawn4 } from "child_process";
-import { z as z44 } from "zod";
-var ArgsSchema40 = z44.object({
-  port: z44.number().int().positive().optional()
+import { z as z46 } from "zod";
+var ArgsSchema41 = z46.object({
+  port: z46.number().int().positive().optional()
 });
-var ResultSchema36 = z44.object({
-  pid: z44.number(),
-  port: z44.number()
+var ResultSchema37 = z46.object({
+  pid: z46.number(),
+  port: z46.number()
 });
 var SHUTDOWN_TIMEOUT_MS2 = 15e3;
 var KILL_TIMEOUT_MS = 3e3;
@@ -6723,8 +6929,8 @@ async function confirmStarted(pid, port) {
 var mcp_restart_default = defineCommand({
   name: "mcp.restart",
   description: "Restart the MCP HTTP daemon (stop, then spawn a fresh detached instance).",
-  args: ArgsSchema40,
-  result: ResultSchema36,
+  args: ArgsSchema41,
+  result: ResultSchema37,
   cli: {
     options: {
       port: {
@@ -6743,17 +6949,17 @@ var mcp_restart_default = defineCommand({
 });
 
 // src/commands/mcp-status.ts
-import { z as z45 } from "zod";
-var ArgsSchema41 = z45.object({});
-var ResultSchema37 = z45.object({
-  running: z45.boolean(),
-  pid: z45.number().optional(),
-  port: z45.number().optional(),
-  version: z45.string().optional(),
-  uptime_ms: z45.number().optional(),
-  healthy: z45.boolean().optional(),
+import { z as z47 } from "zod";
+var ArgsSchema42 = z47.object({});
+var ResultSchema38 = z47.object({
+  running: z47.boolean(),
+  pid: z47.number().optional(),
+  port: z47.number().optional(),
+  version: z47.string().optional(),
+  uptime_ms: z47.number().optional(),
+  healthy: z47.boolean().optional(),
   /** Answering `/health` with no PID file naming it — see `removePidFile`. */
-  orphaned: z45.boolean().optional()
+  orphaned: z47.boolean().optional()
 });
 async function statusByPort(port) {
   const health = await probeHealth(port);
@@ -6771,8 +6977,8 @@ async function statusByPort(port) {
 var mcp_status_default = defineCommand({
   name: "mcp.status",
   description: "Report the MCP HTTP daemon status (pid, port, version, uptime).",
-  args: ArgsSchema41,
-  result: ResultSchema37,
+  args: ArgsSchema42,
+  result: ResultSchema38,
   async run() {
     const entry = await readPidFile();
     if (!entry) {
@@ -6805,20 +7011,20 @@ var mcp_status_default = defineCommand({
 
 // src/commands/mcp-logs.ts
 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()
+import path58 from "path";
+import { z as z48 } from "zod";
+var ArgsSchema43 = z48.object({
+  lines: z48.number().int().positive().optional()
 });
-var ResultSchema38 = z46.object({
-  lines: z46.array(z46.string())
+var ResultSchema39 = z48.object({
+  lines: z48.array(z48.string())
 });
 var DEFAULT_LINES = 50;
 var mcp_logs_default = defineCommand({
   name: "mcp.logs",
   description: "Return the last N lines of the daemon log (default 50).",
-  args: ArgsSchema42,
-  result: ResultSchema38,
+  args: ArgsSchema43,
+  result: ResultSchema39,
   cli: {
     options: {
       lines: {
@@ -6829,7 +7035,7 @@ var mcp_logs_default = defineCommand({
   },
   async run(args) {
     const n = args.lines ?? DEFAULT_LINES;
-    const logPath = path57.join(getStateRoot(), "daemon.log");
+    const logPath = path58.join(getStateRoot(), "daemon.log");
     let content;
     try {
       content = await fs45.readFile(logPath, "utf8");
@@ -6848,7 +7054,7 @@ var mcp_logs_default = defineCommand({
 });
 
 // src/commands/miner-drain-ingest.ts
-import { z as z50 } from "zod";
+import { z as z52 } from "zod";
 
 // src/drain/transcript-reader.ts
 import { nextOffset, prefixHash, readJsonLines, resumePoint } from "@titan-design/locator";
@@ -6859,40 +7065,40 @@ import { Clusterer } from "@titan-design/cluster";
 
 // src/drain/store.ts
 import { promises as fs46 } from "fs";
-import path58 from "path";
+import path59 from "path";
 
 // src/schemas/template.ts
-import { z as z47 } from "zod";
-var LocatorSchema = z47.tuple([
-  z47.number().int().nonnegative(),
-  z47.number().int().nonnegative(),
-  z47.number().int().positive()
+import { z as z49 } from "zod";
+var LocatorSchema = z49.tuple([
+  z49.number().int().nonnegative(),
+  z49.number().int().nonnegative(),
+  z49.number().int().positive()
 ]);
-var TemplateSchema = z47.object({
-  templateId: z47.string().min(1),
-  toolType: z47.string().min(1),
-  maskedSignature: z47.string().min(1),
-  createdAt: z47.string().min(1),
-  occurrenceCount: z47.number().int().nonnegative(),
+var TemplateSchema = z49.object({
+  templateId: z49.string().min(1),
+  toolType: z49.string().min(1),
+  maskedSignature: z49.string().min(1),
+  createdAt: z49.string().min(1),
+  occurrenceCount: z49.number().int().nonnegative(),
   exemplarLocator: LocatorSchema
 });
-var OccurrenceSchema = z47.object({
-  templateId: z47.string().min(1),
+var OccurrenceSchema = z49.object({
+  templateId: z49.string().min(1),
   locator: LocatorSchema,
-  sessionId: z47.string().min(1),
-  timestamp: z47.string().min(1),
-  extractedParams: z47.record(z47.string(), z47.string()).optional()
+  sessionId: z49.string().min(1),
+  timestamp: z49.string().min(1),
+  extractedParams: z49.record(z49.string(), z49.string()).optional()
 });
-var TemplatesFileSchema = z47.object({
-  templates: z47.array(TemplateSchema).default([])
+var TemplatesFileSchema = z49.object({
+  templates: z49.array(TemplateSchema).default([])
 });
 
 // src/drain/store.ts
 function templatesPath(root) {
-  return path58.join(root, "templates.yml");
+  return path59.join(root, "templates.yml");
 }
 function occurrencesPath(root) {
-  return path58.join(root, "occurrences.jsonl");
+  return path59.join(root, "occurrences.jsonl");
 }
 async function loadTemplates(root = getMinerRoot()) {
   try {
@@ -6930,31 +7136,31 @@ async function appendOccurrences(occurrences, root = getMinerRoot()) {
 
 // src/drain/tree-store.ts
 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),
-  nextClusterId: z48.number().int().positive(),
-  clusters: z48.array(
-    z48.object({
-      clusterId: z48.number().int().positive(),
-      tokens: z48.array(z48.string()),
-      size: z48.number().int().nonnegative()
+import path60 from "path";
+import { z as z50 } from "zod";
+var PartitionSchema = z50.object({
+  partition: z50.string().min(1),
+  nextClusterId: z50.number().int().positive(),
+  clusters: z50.array(
+    z50.object({
+      clusterId: z50.number().int().positive(),
+      tokens: z50.array(z50.string()),
+      size: z50.number().int().nonnegative()
     })
   ),
   /** `clusterId -> templateId`, as pairs so the file has a stable order. */
-  templateIds: z48.array(z48.tuple([z48.number().int().positive(), z48.string().min(1)]))
+  templateIds: z50.array(z50.tuple([z50.number().int().positive(), z50.string().min(1)]))
 });
-var TreeSnapshotFileSchema = z48.object({
-  version: z48.literal(1).default(1),
-  partitions: z48.array(PartitionSchema).default([])
+var TreeSnapshotFileSchema = z50.object({
+  version: z50.literal(1).default(1),
+  partitions: z50.array(PartitionSchema).default([])
 });
-var LegacySnapshotFileSchema = z48.object({
-  version: z48.literal(1),
-  trees: z48.array(PartitionSchema.omit({ partition: true }).extend({ toolType: z48.string().min(1) }))
+var LegacySnapshotFileSchema = z50.object({
+  version: z50.literal(1),
+  trees: z50.array(PartitionSchema.omit({ partition: true }).extend({ toolType: z50.string().min(1) }))
 });
 function snapshotPath(root) {
-  return path59.join(root, "drain-trees.json");
+  return path60.join(root, "drain-trees.json");
 }
 function empty() {
   return { version: 1, partitions: [] };
@@ -7133,28 +7339,28 @@ function extractBlobs(line, toolNames) {
 
 // src/drain/reader-state.ts
 import { promises as fs48 } from "fs";
-import path60 from "path";
-import { z as z49 } from "zod";
-var TranscriptStateSchema = z49.object({
+import path61 from "path";
+import { z as z51 } from "zod";
+var TranscriptStateSchema = z51.object({
   /** `~`-relative path, matching `session-index/discover.ts`'s display form. */
-  path: z49.string().min(1),
-  lastByteOffset: z49.number().int().nonnegative().default(0),
+  path: z51.string().min(1),
+  lastByteOffset: z51.number().int().nonnegative().default(0),
   /** sha256 of bytes `[0, lastByteOffset)`; detects rewrite vs. append. */
-  prefixHash: z49.string().nullable().default(null),
+  prefixHash: z51.string().nullable().default(null),
   /**
    * `tool_use_id -> tool name` pairs seen but not yet consumed by a result.
    * Persisted because a chunk boundary routinely falls between an assistant's
    * `tool_use` and the user line carrying its result.
    */
-  pendingToolNames: z49.record(z49.string(), z49.string()).default({})
+  pendingToolNames: z51.record(z51.string(), z51.string()).default({})
 });
-var ReaderStateSchema = z49.object({
-  version: z49.literal(1).default(1),
-  transcripts: z49.array(TranscriptStateSchema).default([])
+var ReaderStateSchema = z51.object({
+  version: z51.literal(1).default(1),
+  transcripts: z51.array(TranscriptStateSchema).default([])
 });
 var MAX_PENDING_TOOL_NAMES = 256;
 function readerStatePath(root = getMinerRoot()) {
-  return path60.join(root, "reader-state.json");
+  return path61.join(root, "reader-state.json");
 }
 async function loadReaderState(root = getMinerRoot()) {
   try {
@@ -7261,7 +7467,7 @@ async function ingestLine(parsed, locator, toolNames, ingestor, counters, sample
   }
 }
 async function runDrainIngest(options = {}) {
-  const startedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const started = process.hrtime.bigint();
   const root = options.root ?? getMinerRoot();
   const corpusRoot = options.corpusRoot ?? transcriptsRoot3();
@@ -7308,7 +7514,7 @@ async function runDrainIngest(options = {}) {
   await ingestor.flush();
   await saveReaderState(state, root);
   return {
-    startedAt: startedAt2,
+    startedAt,
     durationMs: Number(process.hrtime.bigint() - started) / 1e6,
     transcripts: discovered.length,
     scanned,
@@ -7321,33 +7527,33 @@ async function runDrainIngest(options = {}) {
 }
 
 // src/commands/miner-drain-ingest.ts
-var ArgsSchema43 = z50.object({
-  full: z50.boolean().optional(),
-  limit: z50.coerce.number().int().positive().optional(),
-  verify_hashes: z50.boolean().optional()
-});
-var ResultSchema39 = z50.object({
-  startedAt: z50.string(),
-  durationMs: z50.number(),
-  transcripts: z50.number(),
-  scanned: z50.number(),
-  unchanged: z50.number(),
-  rewound: z50.number(),
-  linesRead: z50.number(),
-  malformedLines: z50.number(),
-  blobs: z50.number(),
-  ingested: z50.number(),
-  newTemplates: z50.number(),
-  templates: z50.number(),
-  evicting: z50.boolean(),
-  curve: z50.array(z50.object({ blobs: z50.number(), templates: z50.number(), evicting: z50.boolean() })),
-  errors: z50.array(z50.string())
+var ArgsSchema44 = z52.object({
+  full: z52.boolean().optional(),
+  limit: z52.coerce.number().int().positive().optional(),
+  verify_hashes: z52.boolean().optional()
+});
+var ResultSchema40 = z52.object({
+  startedAt: z52.string(),
+  durationMs: z52.number(),
+  transcripts: z52.number(),
+  scanned: z52.number(),
+  unchanged: z52.number(),
+  rewound: z52.number(),
+  linesRead: z52.number(),
+  malformedLines: z52.number(),
+  blobs: z52.number(),
+  ingested: z52.number(),
+  newTemplates: z52.number(),
+  templates: z52.number(),
+  evicting: z52.boolean(),
+  curve: z52.array(z52.object({ blobs: z52.number(), templates: z52.number(), evicting: z52.boolean() })),
+  errors: z52.array(z52.string())
 });
 var miner_drain_ingest_default = defineCommand({
   name: "miner.drain-ingest",
   description: "Cluster new tool-result/error blobs from Claude transcripts into the template store.",
-  args: ArgsSchema43,
-  result: ResultSchema39,
+  args: ArgsSchema44,
+  result: ResultSchema40,
   cli: {
     options: {
       full: {
@@ -7374,52 +7580,52 @@ var miner_drain_ingest_default = defineCommand({
 });
 
 // src/commands/miner-refresh.ts
-import { z as z51 } from "zod";
-var ArgsSchema44 = z51.object({
-  full: z51.boolean().optional(),
-  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()
+import { z as z53 } from "zod";
+var ArgsSchema45 = z53.object({
+  full: z53.boolean().optional(),
+  limit: z53.coerce.number().int().positive().optional(),
+  verify_hashes: z53.boolean().optional()
+});
+var WorkspaceSchema = z53.object({
+  files: z53.number(),
+  indexed: z53.number(),
+  unchanged: z53.number(),
+  removed: z53.number(),
+  malformed: z53.array(z53.object({ path: z53.string(), reason: z53.string() })),
+  rows: z53.object({
+    initiative: z53.number(),
+    note: z53.number(),
+    task: z53.number(),
+    session: z53.number(),
+    source: z53.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(),
-  transcripts: z51.number(),
-  scanned: z51.number(),
-  indexed: z51.number(),
-  rewound: z51.number(),
-  unchanged: z51.number(),
-  quarantined: z51.number(),
-  missing: z51.number(),
-  reconciledMissing: z51.number(),
-  factsAdded: z51.number(),
-  turnsRolledUp: z51.number(),
-  tasksRequested: z51.number(),
-  tasksApplied: z51.number(),
+  edges: z53.object({ holds: z53.number(), mentions: z53.number(), sharesTag: z53.number() }),
+  orphanRatio: z53.number()
+});
+var ResultSchema41 = z53.object({
+  startedAt: z53.string(),
+  durationMs: z53.number(),
+  transcripts: z53.number(),
+  scanned: z53.number(),
+  indexed: z53.number(),
+  rewound: z53.number(),
+  unchanged: z53.number(),
+  quarantined: z53.number(),
+  missing: z53.number(),
+  reconciledMissing: z53.number(),
+  factsAdded: z53.number(),
+  turnsRolledUp: z53.number(),
+  tasksRequested: z53.number(),
+  tasksApplied: z53.number(),
   workspace: WorkspaceSchema.nullable(),
-  preserved: z51.object({ restored: z51.number(), merged: z51.number(), skipped: z51.number() }),
-  errors: z51.array(z51.string())
+  preserved: z53.object({ restored: z53.number(), merged: z53.number(), skipped: z53.number() }),
+  errors: z53.array(z53.string())
 });
 var miner_refresh_default = defineCommand({
   name: "miner.refresh",
   description: "Index new Claude session transcripts into the session-signal index.",
-  args: ArgsSchema44,
-  result: ResultSchema40,
+  args: ArgsSchema45,
+  result: ResultSchema41,
   cli: {
     options: {
       full: {
@@ -7445,7 +7651,7 @@ var miner_refresh_default = defineCommand({
 
 // src/commands/miner-liveness.ts
 import { existsSync as existsSync3 } from "fs";
-import { z as z52 } from "zod";
+import { z as z54 } from "zod";
 
 // src/session-index/liveness.ts
 import { existsSync as existsSync2 } from "fs";
@@ -7562,22 +7768,22 @@ function runLiveness(db) {
 }
 
 // src/commands/miner-liveness.ts
-var ArgsSchema45 = z52.object({});
-var ResultSchema41 = z52.object({
-  emptyColumns: z52.array(
-    z52.object({ table: z52.string(), column: z52.string(), rows: z52.number(), nonNull: z52.number() })
+var ArgsSchema46 = z54.object({});
+var ResultSchema42 = z54.object({
+  emptyColumns: z54.array(
+    z54.object({ table: z54.string(), column: z54.string(), rows: z54.number(), nonNull: z54.number() })
   ),
-  unusedRelations: z52.array(z52.string()),
-  undeclaredRelations: z52.array(z52.string()),
-  danglingNamespaces: z52.array(
-    z52.object({ namespace: z52.string(), edges: z52.number(), dangling: z52.number() })
+  unusedRelations: z54.array(z54.string()),
+  undeclaredRelations: z54.array(z54.string()),
+  danglingNamespaces: z54.array(
+    z54.object({ namespace: z54.string(), edges: z54.number(), dangling: z54.number() })
   ),
-  unmappedNamespaces: z52.array(z52.string()),
-  expectedEmptyColumns: z52.array(
-    z52.object({ table: z52.string(), column: z52.string(), reason: z52.string() })
+  unmappedNamespaces: z54.array(z54.string()),
+  expectedEmptyColumns: z54.array(
+    z54.object({ table: z54.string(), column: z54.string(), reason: z54.string() })
   ),
-  staleTranscripts: z52.number(),
-  transcripts: z52.number()
+  staleTranscripts: z54.number(),
+  transcripts: z54.number()
 });
 function report(result) {
   const lines = [color.bold("active-work miner liveness")];
@@ -7629,8 +7835,8 @@ function report(result) {
 var miner_liveness_default = defineCommand({
   name: "miner.liveness",
   description: "Report which declared index structures nothing ever populates: empty columns, unused edge relations, dangling refs, stale transcripts.",
-  args: ArgsSchema45,
-  result: ResultSchema41,
+  args: ArgsSchema46,
+  result: ResultSchema42,
   cli: { usage: "active-work miner liveness" },
   async run(_args, ctx) {
     const dbPath = defaultGraphPath();
@@ -7668,40 +7874,40 @@ var miner_liveness_default = defineCommand({
 
 // src/commands/miner-status.ts
 import { existsSync as existsSync4, statSync } from "fs";
-import { z as z53 } from "zod";
-var ArgsSchema46 = z53.object({});
-var ResultSchema42 = z53.object({
-  dbPath: z53.string(),
-  schemaVersion: z53.number(),
-  sizeBytes: z53.number(),
-  counts: z53.object({
-    transcripts: z53.number(),
-    sessions: z53.number(),
-    facts: z53.number(),
-    turns: z53.number(),
-    edges: z53.number(),
-    spans: z53.number()
+import { z as z55 } from "zod";
+var ArgsSchema47 = z55.object({});
+var ResultSchema43 = z55.object({
+  dbPath: z55.string(),
+  schemaVersion: z55.number(),
+  sizeBytes: z55.number(),
+  counts: z55.object({
+    transcripts: z55.number(),
+    sessions: z55.number(),
+    facts: z55.number(),
+    turns: z55.number(),
+    edges: z55.number(),
+    spans: z55.number()
   }),
-  transcripts: z53.object({
-    ok: z53.number(),
-    quarantined: z53.number(),
-    missing: z53.number()
+  transcripts: z55.object({
+    ok: z55.number(),
+    quarantined: z55.number(),
+    missing: z55.number()
   }),
-  watermark: z53.object({
-    lastIndexedAt: z53.string().nullable(),
-    behindBytes: z53.number()
+  watermark: z55.object({
+    lastIndexedAt: z55.string().nullable(),
+    behindBytes: z55.number()
   }),
-  fts: z53.object({
-    rows: z53.number(),
-    orphanRows: z53.number(),
-    needsFullRebuild: z53.boolean()
+  fts: z55.object({
+    rows: z55.number(),
+    orphanRows: z55.number(),
+    needsFullRebuild: z55.boolean()
   }),
-  daemon: z53.object({
-    indexing: z53.boolean(),
-    pending: z53.boolean(),
-    lastRunAt: z53.string().nullable(),
-    lastDurationMs: z53.number().nullable(),
-    consecutiveErrors: z53.number()
+  daemon: z55.object({
+    indexing: z55.boolean(),
+    pending: z55.boolean(),
+    lastRunAt: z55.string().nullable(),
+    lastDurationMs: z55.number().nullable(),
+    consecutiveErrors: z55.number()
   }).nullable()
 });
 var ORPHAN_WARN_RATIO = 0.2;
@@ -7742,8 +7948,8 @@ async function emptyStatus(dbPath) {
 var miner_status_default = defineCommand({
   name: "miner.status",
   description: "Report session-signal index size, freshness, and daemon indexing state.",
-  args: ArgsSchema46,
-  result: ResultSchema42,
+  args: ArgsSchema47,
+  result: ResultSchema43,
   async run() {
     const dbPath = defaultGraphPath();
     if (!existsSync4(dbPath)) return emptyStatus(dbPath);
@@ -7785,7 +7991,7 @@ var miner_status_default = defineCommand({
 });
 
 // src/commands/hooks-agent-chat-spawn.ts
-import { z as z55 } from "zod";
+import { z as z57 } from "zod";
 
 // src/utils/read-stdin-json.ts
 async function readStdinJson(stream = process.stdin) {
@@ -7805,13 +8011,13 @@ async function readStdinJson(stream = process.stdin) {
 
 // src/utils/agent-chat-hook-state.ts
 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),
-  sessionId: z54.string().min(1),
-  name: z54.string(),
-  started: z54.string(),
+import path62 from "path";
+import { z as z56 } from "zod";
+var SpawnContextSchema = z56.object({
+  slug: z56.string().min(1),
+  sessionId: z56.string().min(1),
+  name: z56.string(),
+  started: z56.string(),
   /**
    * The spawning session, already resolved from the payload's `parent`
    * agentId to a session id. Resolved at spawn time on purpose: `parent` names
@@ -7819,16 +8025,16 @@ var SpawnContextSchema = z54.object({
    * another live entry in this same directory — which is gone by the time
    * on_complete runs, because reading one deletes it.
    */
-  parentSessionId: z54.string().min(1).nullable().default(null),
+  parentSessionId: z56.string().min(1).nullable().default(null),
   /** agent-chat profile and briefing slug, for the recorded session's prose. */
-  profile: z54.string().nullable().default(null),
-  briefing: z54.string().nullable().default(null)
+  profile: z56.string().nullable().default(null),
+  briefing: z56.string().nullable().default(null)
 });
 function stateDir() {
-  return path61.join(getStateRoot(), "agent-chat-hooks");
+  return path62.join(getStateRoot(), "agent-chat-hooks");
 }
 function stateFile(agentId) {
-  return path61.join(stateDir(), `${agentId}.json`);
+  return path62.join(stateDir(), `${agentId}.json`);
 }
 async function stashSpawnContext(agentId, context) {
   await fs49.mkdir(stateDir(), { recursive: true });
@@ -7854,10 +8060,10 @@ async function peekSpawnContext(agentId) {
 }
 
 // src/commands/hooks-agent-chat-spawn.ts
-var ArgsSchema47 = z55.object({});
-var ResultSchema43 = z55.object({
-  matched: z55.boolean(),
-  slug: z55.string().nullable()
+var ArgsSchema48 = z57.object({});
+var ResultSchema44 = z57.object({
+  matched: z57.boolean(),
+  slug: z57.string().nullable()
 });
 function str2(source, key) {
   const value = source?.[key];
@@ -7886,8 +8092,8 @@ async function handleOnSpawn(payload, activeRoot) {
 var hooks_agent_chat_spawn_default = defineCommand({
   name: "hooks.agent-chat-spawn",
   description: "agent-chat on_spawn hook consumer (AW-99): stash a spawned peer's context, keyed by agentId, for the matching on_complete call.",
-  args: ArgsSchema47,
-  result: ResultSchema43,
+  args: ArgsSchema48,
+  result: ResultSchema44,
   cli: {
     usage: "active-work hooks agent-chat-spawn   (reads the on_spawn JSON payload from stdin)"
   },
@@ -7899,11 +8105,11 @@ var hooks_agent_chat_spawn_default = defineCommand({
 
 // src/commands/hooks-agent-chat-complete.ts
 import { spawn as spawn5 } from "child_process";
-import { z as z56 } from "zod";
-var ArgsSchema48 = z56.object({});
-var ResultSchema44 = z56.object({
-  recorded: z56.boolean(),
-  slug: z56.string().nullable()
+import { z as z58 } from "zod";
+var ArgsSchema49 = z58.object({});
+var ResultSchema45 = z58.object({
+  recorded: z58.boolean(),
+  slug: z58.string().nullable()
 });
 function str3(source, key) {
   const value = source?.[key];
@@ -7970,8 +8176,8 @@ async function handleOnComplete(payload) {
 var hooks_agent_chat_complete_default = defineCommand({
   name: "hooks.agent-chat-complete",
   description: "agent-chat on_complete hook consumer (AW-99): record a spawned peer's run as a track:adhoc session via wrap.",
-  args: ArgsSchema48,
-  result: ResultSchema44,
+  args: ArgsSchema49,
+  result: ResultSchema45,
   cli: {
     usage: "active-work hooks agent-chat-complete   (reads the on_complete JSON payload from stdin)"
   },
@@ -7982,7 +8188,7 @@ var hooks_agent_chat_complete_default = defineCommand({
 });
 
 // src/commands/setup.ts
-import { z as z58 } from "zod";
+import { z as z60 } from "zod";
 
 // src/setup/steps.ts
 import { promises as fsp3, existsSync as existsSync5 } from "fs";
@@ -7998,7 +8204,7 @@ import { join } from "path";
 
 // src/migrations/v1-to-v2-artifacts.ts
 import { promises as fs50 } from "fs";
-import path62 from "path";
+import path63 from "path";
 import YAML4 from "yaml";
 function asArray(value) {
   return Array.isArray(value) ? value : [];
@@ -8058,7 +8264,7 @@ async function walkArtifactsFiles(activeRoot) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      const candidate = path62.join(activeRoot, entry.name, "artifacts.yml");
+      const candidate = path63.join(activeRoot, entry.name, "artifacts.yml");
       try {
         await fs50.access(candidate);
         out.push(candidate);
@@ -8067,14 +8273,14 @@ async function walkArtifactsFiles(activeRoot) {
     }
   } catch {
   }
-  const archiveRoot = path62.resolve(activeRoot, "..");
+  const archiveRoot = path63.resolve(activeRoot, "..");
   try {
     const domains = await fs50.readdir(archiveRoot, { withFileTypes: true });
     for (const domain of domains) {
       if (!domain.isDirectory()) continue;
       if (domain.name.startsWith(".")) continue;
-      if (path62.join(archiveRoot, domain.name) === path62.resolve(activeRoot)) continue;
-      const archiveDir = path62.join(archiveRoot, domain.name, "archive");
+      if (path63.join(archiveRoot, domain.name) === path63.resolve(activeRoot)) continue;
+      const archiveDir = path63.join(archiveRoot, domain.name, "archive");
       let archived;
       try {
         archived = await fs50.readdir(archiveDir, { withFileTypes: true });
@@ -8083,7 +8289,7 @@ async function walkArtifactsFiles(activeRoot) {
       }
       for (const entry of archived) {
         if (!entry.isDirectory()) continue;
-        const candidate = path62.join(archiveDir, entry.name, "artifacts.yml");
+        const candidate = path63.join(archiveDir, entry.name, "artifacts.yml");
         try {
           await fs50.access(candidate);
           out.push(candidate);
@@ -8097,7 +8303,7 @@ async function walkArtifactsFiles(activeRoot) {
 }
 async function appendMigrationLog(activeRoot, lines) {
   if (lines.length === 0) return;
-  const logPath = path62.join(activeRoot, ".migrations.log");
+  const logPath = path63.join(activeRoot, ".migrations.log");
   const stamp = (/* @__PURE__ */ new Date()).toISOString();
   const body = lines.map((l) => `${stamp}	v1->v2	${l}
 `).join("");
@@ -8129,11 +8335,11 @@ var v1ToV2Artifacts = {
 
 // src/migrations/v2-to-v3-open-loops.ts
 import { promises as fs53 } from "fs";
-import path64 from "path";
+import path65 from "path";
 
 // src/migrations/v3-proposal.ts
 import { promises as fs51 } from "fs";
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
 
 // src/migrations/data/v3-open-loops-proposal.ts
 var V3_OPEN_LOOPS_PROPOSAL = {
@@ -8929,36 +9135,36 @@ var KEBAB_SESSION_ID = SessionIdSchema.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, {
   message: "session_id must be kebab-case ([a-z0-9-], no leading/trailing dash)"
 });
 var ISO_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
-var AbandonedSchema = z57.object({ note: z57.string().min(1) });
+var AbandonedSchema = z59.object({ note: z59.string().min(1) });
 var ProposalNextStepSchema = NextStepSchema.extend({
   abandoned: AbandonedSchema.optional()
 });
-var ProposalInitiativeSchema = z57.object({
-  slug: z57.string().min(1),
+var ProposalInitiativeSchema = z59.object({
+  slug: z59.string().min(1),
   /**
    * Real last-touch of the initiative, hand-supplied. Never `Date.now()` and
    * never file mtime — several initiatives have mtimes months adrift from
    * their true last-touch, and the whole point of back-dating is to preserve
    * the staleness signal.
    */
-  ended: z57.string().regex(ISO_INSTANT, {
+  ended: z59.string().regex(ISO_INSTANT, {
     message: "ended must be an ISO 8601 instant with timezone"
   }),
   session_id: KEBAB_SESSION_ID,
-  body: z57.string().min(1),
-  next_steps: z57.array(ProposalNextStepSchema).default([])
+  body: z59.string().min(1),
+  next_steps: z59.array(ProposalNextStepSchema).default([])
 });
-var ProposalSchema = z57.object({
+var ProposalSchema = z59.object({
   /**
    * When the abandonment decision was made. Hand-supplied rather than read
    * from the clock: the second session's filename derives from it, and the
    * migration keys idempotence on exact paths, so `Date.now()` would mint a
    * fresh path — and a duplicate abandonment session — on every re-run.
    */
-  abandoned_at: z57.string().regex(ISO_INSTANT, {
+  abandoned_at: z59.string().regex(ISO_INSTANT, {
     message: "abandoned_at must be an ISO 8601 instant with timezone"
   }).optional(),
-  initiatives: z57.array(ProposalInitiativeSchema)
+  initiatives: z59.array(ProposalInitiativeSchema)
 }).superRefine((value, ctx) => {
   const withAbandoned = value.initiatives.filter(
     (i) => i.next_steps.some((n) => n.abandoned !== void 0)
@@ -9029,17 +9235,17 @@ async function loadProposal() {
 
 // src/migrations/v3-repairs.ts
 import { promises as fs52 } from "fs";
-import path63 from "path";
+import path64 from "path";
 var KNOWN_REPAIRS = [
   {
-    file: path63.join("audiobook", "sessions", "2026-07-23-0549-2026-07-26-book1-m4b-packaging.md"),
+    file: path64.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: path63.join("voltras-workspace", "sessions", "ARCHIVED-handoff-through-2026-07-15.md"),
+    file: path64.join("voltras-workspace", "sessions", "ARCHIVED-handoff-through-2026-07-15.md"),
     kind: "relocate",
-    target: path63.join("voltras-workspace", "sources", "ARCHIVED-handoff-through-2026-07-15.md"),
+    target: path64.join("voltras-workspace", "sources", "ARCHIVED-handoff-through-2026-07-15.md"),
     why: "not a session file \u2014 a hand-archived handoff parked in sessions/"
   }
 ];
@@ -9098,7 +9304,7 @@ async function exists3(p) {
 async function planRepairs(activeRoot) {
   const plans = [];
   for (const repair of KNOWN_REPAIRS) {
-    const fullPath = path63.join(activeRoot, repair.file);
+    const fullPath = path64.join(activeRoot, repair.file);
     if (!await exists3(fullPath)) {
       plans.push({ action: "skip", file: repair.file, detail: "already absent" });
       continue;
@@ -9108,7 +9314,7 @@ async function planRepairs(activeRoot) {
       continue;
     }
     const target = repair.target;
-    if (await exists3(path63.join(activeRoot, target))) {
+    if (await exists3(path64.join(activeRoot, target))) {
       plans.push({
         action: "skip",
         file: repair.file,
@@ -9122,7 +9328,7 @@ async function planRepairs(activeRoot) {
   return plans;
 }
 async function applyRepair(activeRoot, plan) {
-  const fullPath = path63.join(activeRoot, plan.file);
+  const fullPath = path64.join(activeRoot, plan.file);
   if (plan.action === "retrack" && plan.repaired !== void 0) {
     await writeFrontmatter(
       fullPath,
@@ -9133,15 +9339,15 @@ async function applyRepair(activeRoot, plan) {
     return;
   }
   if (plan.action === "relocate") {
-    const target = path63.join(activeRoot, plan.target);
-    await fs52.mkdir(path63.dirname(target), { recursive: true });
+    const target = path64.join(activeRoot, plan.target);
+    await fs52.mkdir(path64.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 = path64.join("sources", "handoff-archive.md");
+var HANDOFF_ARCHIVE = path65.join("sources", "handoff-archive.md");
 async function pathExists(p) {
   try {
     await fs53.access(p);
@@ -9160,7 +9366,7 @@ async function listInitiativeSlugs3(activeRoot) {
   const slugs = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    if (await pathExists(path64.join(activeRoot, entry.name, "brief.md"))) {
+    if (await pathExists(path65.join(activeRoot, entry.name, "brief.md"))) {
       slugs.push(entry.name);
     }
   }
@@ -9168,9 +9374,9 @@ async function listInitiativeSlugs3(activeRoot) {
 }
 async function maxOnDiskTaskNumber2(initiativeDir, prefix) {
   const re = new RegExp(`^${prefix}-(\\d+)\\.yml$`);
-  const tasksDir = path64.join(initiativeDir, "tasks");
+  const tasksDir = path65.join(initiativeDir, "tasks");
   let max = 0;
-  for (const dir of [tasksDir, path64.join(tasksDir, "archive")]) {
+  for (const dir of [tasksDir, path65.join(tasksDir, "archive")]) {
     let names;
     try {
       names = await fs53.readdir(dir);
@@ -9192,7 +9398,7 @@ async function nextTaskSeq(initiativeDir, frontmatter2) {
   return max > 0 ? max : null;
 }
 async function planBrief(initiativeDir, slug) {
-  const raw = await readRawFrontmatter(path64.join(initiativeDir, "brief.md"));
+  const raw = await readRawFrontmatter(path65.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 };
@@ -9209,8 +9415,8 @@ async function planBrief(initiativeDir, slug) {
   };
 }
 async function planHandoff(initiativeDir) {
-  if (!await pathExists(path64.join(initiativeDir, HANDOFF_FILE))) return "absent";
-  if (await pathExists(path64.join(initiativeDir, HANDOFF_ARCHIVE))) return "archive-exists";
+  if (!await pathExists(path65.join(initiativeDir, HANDOFF_FILE))) return "absent";
+  if (await pathExists(path65.join(initiativeDir, HANDOFF_ARCHIVE))) return "archive-exists";
   return "archive-and-remove";
 }
 function buildOpenSession(entry) {
@@ -9300,7 +9506,7 @@ function draftSessions(entry, abandonedAt) {
   return [open, buildAbandonSession(entry, open.stem, abandonedAt)];
 }
 async function planInitiative(activeRoot, slug, entry, abandonedAt) {
-  const initiativeDir = path64.join(activeRoot, slug);
+  const initiativeDir = path65.join(activeRoot, slug);
   const brief = await planBrief(initiativeDir, slug);
   const base = {
     slug,
@@ -9339,9 +9545,9 @@ async function planV2ToV3(activeRoot) {
   return { proposalOrigin: origin, initiatives, repairs: await planRepairs(activeRoot) };
 }
 async function archiveHandoff(initiativeDir) {
-  const source = path64.join(initiativeDir, HANDOFF_FILE);
-  const target = path64.join(initiativeDir, HANDOFF_ARCHIVE);
-  await fs53.mkdir(path64.dirname(target), { recursive: true });
+  const source = path65.join(initiativeDir, HANDOFF_FILE);
+  const target = path65.join(initiativeDir, HANDOFF_ARCHIVE);
+  await fs53.mkdir(path65.dirname(target), { recursive: true });
   await fs53.copyFile(source, target);
   await fs53.rm(source);
 }
@@ -9360,15 +9566,15 @@ async function writePlannedSession(activeRoot, slug, session) {
   });
 }
 async function applyInitiative(activeRoot, plan) {
-  const initiativeDir = path64.join(activeRoot, plan.slug);
-  await withFileLock(path64.join(initiativeDir, ".lock"), async () => {
+  const initiativeDir = path65.join(activeRoot, plan.slug);
+  await withFileLock(path65.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(
-        path64.join(initiativeDir, "brief.md"),
+        path65.join(initiativeDir, "brief.md"),
         plan.brief.frontmatter,
         plan.brief.body,
         BriefFrontmatterSchema
@@ -9399,12 +9605,12 @@ var v2ToV3OpenLoops = {
 
 // src/migrations/v3-to-v4-worktrees.ts
 import { promises as fs54 } from "fs";
-import path65 from "path";
+import path66 from "path";
 import matter5 from "gray-matter";
 import YAML5 from "yaml";
 function normalize(value) {
-  const expanded = value.startsWith("~") ? path65.join(process.env.HOME ?? "", value.slice(1)) : value;
-  return path65.resolve(expanded);
+  const expanded = value.startsWith("~") ? path66.join(process.env.HOME ?? "", value.slice(1)) : value;
+  return path66.resolve(expanded);
 }
 function toEntries(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return [];
@@ -9451,7 +9657,7 @@ async function readArtifacts2(file) {
   }
 }
 async function migrateOne2(initiativeDir) {
-  const briefPath = path65.join(initiativeDir, "brief.md");
+  const briefPath = path66.join(initiativeDir, "brief.md");
   let raw;
   try {
     raw = await fs54.readFile(briefPath, "utf8");
@@ -9464,7 +9670,7 @@ async function migrateOne2(initiativeDir) {
   const incoming = toEntries(data.worktrees);
   delete data.worktrees;
   if (incoming.length > 0) {
-    const artifactsPath2 = path65.join(initiativeDir, "artifacts.yml");
+    const artifactsPath2 = path66.join(initiativeDir, "artifacts.yml");
     const current = await readArtifacts2(artifactsPath2);
     await writeYaml(
       artifactsPath2,
@@ -9489,9 +9695,9 @@ async function initiativeDirs(activeRoot) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    const dir = path65.join(activeRoot, entry.name);
+    const dir = path66.join(activeRoot, entry.name);
     try {
-      await fs54.access(path65.join(dir, "brief.md"));
+      await fs54.access(path66.join(dir, "brief.md"));
       out.push(dir);
     } catch {
     }
@@ -9506,12 +9712,12 @@ var v3ToV4Worktrees = {
     const moved = [];
     for (const dir of await initiativeDirs(activeRoot)) {
       const count = await migrateOne2(dir);
-      if (count > 0) moved.push(`${path65.basename(dir)}	${count} worktree(s)`);
+      if (count > 0) moved.push(`${path66.basename(dir)}	${count} worktree(s)`);
     }
     if (moved.length === 0) return;
     const stamp = (/* @__PURE__ */ new Date()).toISOString();
     await fs54.appendFile(
-      path65.join(activeRoot, ".migrations.log"),
+      path66.join(activeRoot, ".migrations.log"),
       moved.map((line) => `${stamp}	v3->v4	${line}
 `).join(""),
       "utf8"
@@ -9564,10 +9770,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 path67 = schemaVersionPath(activeRoot);
+  const path68 = schemaVersionPath(activeRoot);
   let raw;
   try {
-    raw = await readFile(path67, "utf8");
+    raw = await readFile(path68, "utf8");
   } catch (err) {
     if (isNodeErrnoException(err) && err.code === "ENOENT") {
       return 0;
@@ -9577,13 +9783,13 @@ async function readSchemaVersion(activeRoot) {
   const trimmed = raw.trim();
   if (trimmed === "" || !/^\d+$/.test(trimmed)) {
     throw new Error(
-      `Invalid schema version in ${path67}: expected a positive integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path68}: 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 ${path67}: expected a positive integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path68}: expected a positive integer, got ${JSON.stringify(raw)}`
     );
   }
   return parsed;
@@ -9596,10 +9802,10 @@ async function writeSchemaVersion(activeRoot, version) {
 `, "utf8");
 }
 async function readRawSchemaVersion(activeRoot) {
-  const path67 = schemaVersionPath(activeRoot);
+  const path68 = schemaVersionPath(activeRoot);
   let raw;
   try {
-    raw = await readFile(path67, "utf8");
+    raw = await readFile(path68, "utf8");
   } catch (err) {
     if (isNodeErrnoException(err) && err.code === "ENOENT") {
       return { present: false };
@@ -9609,13 +9815,13 @@ async function readRawSchemaVersion(activeRoot) {
   const trimmed = raw.trim();
   if (trimmed === "" || !/^\d+$/.test(trimmed)) {
     throw new Error(
-      `Invalid schema version in ${path67}: expected a non-negative integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path68}: 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 ${path67}: expected a non-negative integer, got ${JSON.stringify(raw)}`
+      `Invalid schema version in ${path68}: expected a non-negative integer, got ${JSON.stringify(raw)}`
     );
   }
   return { present: true, version: parsed };
@@ -10888,20 +11094,20 @@ async function runUninstall(deps = {}) {
 }
 
 // src/commands/setup.ts
-var ArgsSchema49 = z58.object({
-  update: z58.boolean().optional(),
-  yes: z58.boolean().optional()
+var ArgsSchema50 = z60.object({
+  update: z60.boolean().optional(),
+  yes: z60.boolean().optional()
 });
-var StepSchema = z58.object({
-  name: z58.string(),
-  ok: z58.boolean(),
-  done: z58.boolean().optional(),
-  message: z58.string().optional(),
-  error: z58.string().optional()
+var StepSchema = z60.object({
+  name: z60.string(),
+  ok: z60.boolean(),
+  done: z60.boolean().optional(),
+  message: z60.string().optional(),
+  error: z60.string().optional()
 });
-var ResultSchema45 = z58.object({
-  banner: z58.string(),
-  steps: z58.array(StepSchema)
+var ResultSchema46 = z60.object({
+  banner: z60.string(),
+  steps: z60.array(StepSchema)
 });
 function printStep(step) {
   if (step.ok) {
@@ -10918,8 +11124,8 @@ function printStep(step) {
 var setup_default = defineCommand({
   name: "setup",
   description: "Interactive wizard: verifies Node, scaffolds directories, registers the MCP server, and optionally starts the daemon and walks through ingestion.",
-  args: ArgsSchema49,
-  result: ResultSchema45,
+  args: ArgsSchema50,
+  result: ResultSchema46,
   cli: {
     options: {
       update: {
@@ -10954,25 +11160,25 @@ var setup_default = defineCommand({
 });
 
 // src/commands/uninstall.ts
-import { z as z59 } from "zod";
-var ArgsSchema50 = z59.object({
-  yes: z59.boolean().optional()
+import { z as z61 } from "zod";
+var ArgsSchema51 = z61.object({
+  yes: z61.boolean().optional()
 });
-var StepSchema2 = z59.object({
-  name: z59.string(),
-  done: z59.boolean(),
-  message: z59.string().optional(),
-  error: z59.string().optional()
+var StepSchema2 = z61.object({
+  name: z61.string(),
+  done: z61.boolean(),
+  message: z61.string().optional(),
+  error: z61.string().optional()
 });
-var ResultSchema46 = z59.object({
-  steps: z59.array(StepSchema2),
-  activeRootPreservedAt: z59.string()
+var ResultSchema47 = z61.object({
+  steps: z61.array(StepSchema2),
+  activeRootPreservedAt: z61.string()
 });
 var uninstall_default = defineCommand({
   name: "uninstall",
   description: "Reverse what setup did: remove the skill, stop the daemon, unregister MCP. Preserves the active root.",
-  args: ArgsSchema50,
-  result: ResultSchema46,
+  args: ArgsSchema51,
+  result: ResultSchema47,
   cli: {
     options: {
       yes: {
@@ -11002,7 +11208,7 @@ var uninstall_default = defineCommand({
 });
 
 // src/commands/doctor.ts
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 
 // src/doctor.ts
 import { promises as fsp4 } from "fs";
@@ -11410,15 +11616,15 @@ async function runDoctor(deps = {}) {
 }
 
 // src/commands/doctor.ts
-var ArgsSchema51 = z60.object({});
-var CheckSchema = z60.object({
-  name: z60.string(),
-  status: z60.enum(["ok", "warn", "fail"]),
-  detail: z60.string()
+var ArgsSchema52 = z62.object({});
+var CheckSchema = z62.object({
+  name: z62.string(),
+  status: z62.enum(["ok", "warn", "fail"]),
+  detail: z62.string()
 });
-var ResultSchema47 = z60.object({
-  ok: z60.boolean(),
-  checks: z60.array(CheckSchema)
+var ResultSchema48 = z62.object({
+  ok: z62.boolean(),
+  checks: z62.array(CheckSchema)
 });
 function badge(status) {
   if (status === "ok") return color.green("OK  ");
@@ -11428,8 +11634,8 @@ function badge(status) {
 var doctor_default = defineCommand({
   name: "doctor",
   description: "Health-check the install: Node, active root, daemon, MCP registration, skill, and supervision.",
-  args: ArgsSchema51,
-  result: ResultSchema47,
+  args: ArgsSchema52,
+  result: ResultSchema48,
   async run(_args, ctx) {
     const report2 = await runDoctor();
     if (ctx.format !== "json") {
@@ -11446,34 +11652,34 @@ var doctor_default = defineCommand({
 });
 
 // src/commands/migrate.ts
-import { z as z61 } from "zod";
-var ArgsSchema52 = z61.object({
-  dry_run: z61.boolean().optional(),
-  apply: z61.boolean().optional()
-});
-var SessionSchema = z61.object({
-  kind: z61.enum(["open", "abandon"]),
-  action: z61.enum(["write", "exists"]),
-  file: z61.string(),
-  ended: z61.string(),
-  loops: z61.number().int().nonnegative(),
-  resolves: z61.number().int().nonnegative()
-});
-var InitiativeSchema = z61.object({
-  slug: z61.string(),
-  sessions: z61.array(SessionSchema),
-  task_seq_backfill: z61.number().int().positive().nullable(),
-  brief_repairs: z61.array(z61.string()),
-  brief_blocked: z61.string().optional(),
-  handoff: z61.enum(["archive-and-remove", "archive-exists", "absent"]),
-  note: z61.string().optional()
-});
-var ResultSchema48 = z61.object({
-  applied: z61.boolean(),
-  proposal: z61.string(),
-  initiatives: z61.array(InitiativeSchema),
-  repairs: z61.array(z61.object({ action: z61.string(), file: z61.string(), detail: z61.string() })),
-  uncovered: z61.array(z61.string())
+import { z as z63 } from "zod";
+var ArgsSchema53 = z63.object({
+  dry_run: z63.boolean().optional(),
+  apply: z63.boolean().optional()
+});
+var SessionSchema = z63.object({
+  kind: z63.enum(["open", "abandon"]),
+  action: z63.enum(["write", "exists"]),
+  file: z63.string(),
+  ended: z63.string(),
+  loops: z63.number().int().nonnegative(),
+  resolves: z63.number().int().nonnegative()
+});
+var InitiativeSchema = z63.object({
+  slug: z63.string(),
+  sessions: z63.array(SessionSchema),
+  task_seq_backfill: z63.number().int().positive().nullable(),
+  brief_repairs: z63.array(z63.string()),
+  brief_blocked: z63.string().optional(),
+  handoff: z63.enum(["archive-and-remove", "archive-exists", "absent"]),
+  note: z63.string().optional()
+});
+var ResultSchema49 = z63.object({
+  applied: z63.boolean(),
+  proposal: z63.string(),
+  initiatives: z63.array(InitiativeSchema),
+  repairs: z63.array(z63.object({ action: z63.string(), file: z63.string(), detail: z63.string() })),
+  uncovered: z63.array(z63.string())
 });
 function describe2(plan, applied) {
   const initiatives = plan.initiatives.map((i) => ({
@@ -11549,8 +11755,8 @@ function render(result) {
 var migrate_default = defineCommand({
   name: "migrate",
   description: "Preview (or apply) the pending v2\u2192v3 open-loops migration.",
-  args: ArgsSchema52,
-  result: ResultSchema48,
+  args: ArgsSchema53,
+  result: ResultSchema49,
   cli: {
     options: {
       dry_run: { long: "--dry-run", description: "Report what would change; write nothing" },
@@ -11585,18 +11791,18 @@ var migrate_default = defineCommand({
 
 // src/commands/sync.ts
 import os7 from "os";
-import { z as z62 } from "zod";
-var ArgsSchema53 = z62.object({
-  message: z62.string().min(1).optional(),
-  require_clean: z62.boolean().optional()
-});
-var ResultSchema49 = z62.object({
-  branch: z62.string(),
-  committed: z62.boolean(),
-  committed_files: z62.number().int(),
-  rebased: z62.boolean(),
-  pushed: z62.boolean(),
-  summary: z62.string()
+import { z as z64 } from "zod";
+var ArgsSchema54 = z64.object({
+  message: z64.string().min(1).optional(),
+  require_clean: z64.boolean().optional()
+});
+var ResultSchema50 = z64.object({
+  branch: z64.string(),
+  committed: z64.boolean(),
+  committed_files: z64.number().int(),
+  rebased: z64.boolean(),
+  pushed: z64.boolean(),
+  summary: z64.string()
 });
 async function git(root, args) {
   return getGitRunner()("git", ["-C", root, ...args]);
@@ -11698,8 +11904,8 @@ async function push(root) {
 var sync_default = defineCommand({
   name: "sync",
   description: "Sync the active root over git: auto-commit local edits, pull --rebase, then push.",
-  args: ArgsSchema53,
-  result: ResultSchema49,
+  args: ArgsSchema54,
+  result: ResultSchema50,
   cli: {
     options: {
       message: {
@@ -11793,6 +11999,7 @@ var ALL_COMMANDS = [
   audit_default,
   list_default,
   context_graph_default,
+  search_default,
   // discover / triage
   discover_default,
   fold_default,
@@ -11833,14 +12040,14 @@ import { readCommanderOption } from "@titan-design/registry";
 
 // src/utils/usage-log.ts
 import { promises as fs56 } from "fs";
-import path66 from "path";
+import path67 from "path";
 function usageLogPath() {
-  return path66.join(getStateRoot(), "usage.jsonl");
+  return path67.join(getStateRoot(), "usage.jsonl");
 }
 async function appendUsage(rec) {
   try {
     const file = usageLogPath();
-    await fs56.mkdir(path66.dirname(file), { recursive: true });
+    await fs56.mkdir(path67.dirname(file), { recursive: true });
     await fs56.appendFile(file, JSON.stringify(rec) + "\n", "utf8");
   } catch {
   }
@@ -12012,7 +12219,7 @@ function attachCommand(root, cmd) {
 function buildProgram() {
   const program = new Command();
   program.exitOverride();
-  program.name("active-work").description("active-work CLI \u2014 durable workspace state for engineering work").version("0.1.0").option("--json", "emit machine-readable JSON envelope on stdout").addHelpText(
+  program.name("active-work").description("active-work CLI \u2014 durable workspace state for engineering work").version(BUILD_VERSION).option("--json", "emit machine-readable JSON envelope on stdout").addHelpText(
     "after",
     "\nRun `active-work <command> --help` for command-specific options.\nTip: `aw [slug]` launches Claude with the bootstrap prompt.\n"
   );