@titan-design/active-work 0.5.0 → 0.7.0

package/dist/cli.js

@@ -13,6 +13,7 @@ import {
   NotFoundError,
   NoteFrontmatterSchema,
   NoteKindSchema,
+  SCHEMA_VERSION,
   SessionFrontmatterSchema,
   SessionIdSchema,
   SessionResolveSchema,
@@ -21,11 +22,13 @@ import {
   TaskSeqSchema,
   UsageError,
   ValidationError,
+  WORKSPACE_SPAN_SOURCE_BASE,
   WorktreeEntrySchema,
   assembleBootstrap,
   atomicWrite,
   coerceDates,
   color,
+  defaultGraphPath,
   defineCommand,
   deriveOpenLoops,
   deriveOpenLoopsFrom,
@@ -48,6 +51,8 @@ import {
   loadNotesFromDir,
   loadSessionsFromDir,
   nowIso,
+  openGraph,
+  openGraphReadOnly,
   open_default,
   probeHealth,
   readArtifactHashes,
@@ -76,7 +81,7 @@ import {
   writeFrontmatter,
   writeNoteFile,
   writeYaml
-} from "./chunk-RLSQSE7I.js";
+} from "./chunk-KAR6NOS2.js";
 
 // src/cli.ts
 import { Command, CommanderError } from "commander";
@@ -3849,29 +3854,249 @@ 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/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 path35 from "path";
+import { readLocatorText } from "@titan-design/locator";
+
+// src/workspace-index/refs.ts
+import path34 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 path34.relative(activeRoot, absolutePath).split(path34.sep).join("/");
+}
+function toAbsolute(activeRoot, relativePath) {
+  return path34.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("~") ? path35.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 +4171,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 path36 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) => path36.resolve(expandTilde(a)) === path36.resolve(expandTilde(b));
 var worktree_set_default = defineCommand({
   name: "worktree.set",
   description: "Add or update a registered worktree on an existing initiative. A lone worktree is made default automatically; use --default to promote an added one. Registered worktrees live in artifacts.yml alongside the ones wrap sweeps, and are what `aw` resolves a cwd against.",
@@ -3985,8 +4210,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 = path36.join(getActiveRoot(), args.slug);
+    const briefPath = path36.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(args.slug), async () => {
       let frontmatter2;
       let body;
@@ -4040,15 +4265,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 path37 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 +4284,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 = path37.join(getActiveRoot(), slug);
+    const briefPath = path37.join(initiativeDir, "brief.md");
     return withFileLock(getLockPath(slug), async () => {
       let frontmatter2;
       let body;
@@ -4091,11 +4316,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 path41 from "path";
 
 // src/discover/run-command.ts
 import { spawn } from "child_process";
@@ -4192,13 +4417,13 @@ async function discoverGitHub(repos, run = runCommand) {
 }
 
 // src/discover/git.ts
-import path36 from "path";
+import path38 from "path";
 var BRANCH_LIMIT = 20;
 async function discoverGit(repoPaths, run = runCommand) {
   const hits = [];
   const errors = [];
   for (const repoPath of repoPaths) {
-    const repoName = path36.basename(repoPath);
+    const repoName = path38.basename(repoPath);
     await collectBranches(repoPath, repoName, hits, errors, run);
     await collectWorktrees(repoPath, repoName, hits, errors, run);
     await collectStashes(repoPath, repoName, hits, errors, run);
@@ -4313,14 +4538,14 @@ function errStr(err) {
 
 // src/discover/projects.ts
 import { promises as fs27 } from "fs";
-import path37 from "path";
+import path39 from "path";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var RECENT_THRESHOLD_DAYS = 30;
 async function discoverProjects(projectsRoot) {
   const hits = [];
   const errors = [];
   if (!projectsRoot) return { hits, errors };
-  const resolved = path37.resolve(expandTilde(projectsRoot));
+  const resolved = path39.resolve(expandTilde(projectsRoot));
   let entries;
   try {
     entries = await fs27.readdir(resolved, { withFileTypes: true });
@@ -4336,7 +4561,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 = path39.join(resolved, entry.name);
     let mtimeMs = 0;
     try {
       const stat = await fs27.stat(fullPath);
@@ -4369,11 +4594,11 @@ async function discoverProjects(projectsRoot) {
 // src/discover/claude.ts
 import { promises as fs28 } from "fs";
 import os2 from "os";
-import path38 from "path";
+import path40 from "path";
 var MAX_SCAN_LINES = 200;
 var COMPACTION_SUBJECT_PREFIX = "[compaction] ";
 async function discoverClaudeSessions() {
-  const root = process.env.CLAUDE_PROJECTS_ROOT ?? path38.join(os2.homedir(), ".claude", "projects");
+  const root = process.env.CLAUDE_PROJECTS_ROOT ?? path40.join(os2.homedir(), ".claude", "projects");
   const hits = [];
   const errors = [];
   let projectDirs;
@@ -4388,7 +4613,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 = path40.join(root, dir.name);
     let files;
     try {
       files = await fs28.readdir(dirPath, { withFileTypes: true });
@@ -4401,7 +4626,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 = path40.join(dirPath, file.name);
       try {
         await aggregateSession(filePath, byCwd);
       } catch (err) {
@@ -4457,7 +4682,7 @@ async function aggregateSession(filePath, byCwd) {
   }
   if (!cwd) return;
   const subject = lastCompactionSummary ? `${COMPACTION_SUBJECT_PREFIX}${truncate2(lastCompactionSummary, 120)}` : firstUserMessage ? truncate2(firstUserMessage, 120) : "";
-  const sessionId = path38.basename(filePath, ".jsonl");
+  const sessionId = path40.basename(filePath, ".jsonl");
   const existing = byCwd.get(cwd);
   if (!existing) {
     byCwd.set(cwd, {
@@ -4557,7 +4782,7 @@ async function loadSlugs(activeRoot) {
   }
 }
 async function loadTriagedRefs(activeRoot) {
-  const logPath = path39.join(activeRoot, ".triaged.log");
+  const logPath = path41.join(activeRoot, ".triaged.log");
   const refs = /* @__PURE__ */ new Set();
   try {
     const raw = await fs29.readFile(logPath, "utf8");
@@ -4583,28 +4808,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 +4856,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 path42 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 = path42.join(root, ".triaged.log");
   let existing = "";
   try {
     existing = await fs30.readFile(logPath, "utf8");
@@ -4652,18 +4877,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 +4906,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 path43 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 +4948,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 = path43.join(initiativeDir, "sessions");
     await fs31.mkdir(sessionsDir, { recursive: true });
     const startedIso = nowIso();
     const stem = buildSessionStem(startedIso, `folded-${sanitizeRef(args.ref)}`);
@@ -4756,27 +4981,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 path44 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 +5028,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(path44.join(dir, "tasks"), { recursive: true });
+    await fs32.mkdir(path44.join(dir, "sessions"), { recursive: true });
+    await fs32.mkdir(path44.join(dir, "sources"), { recursive: true });
     const title = args.title ?? deriveTitle(args.slug);
     const briefBody = buildBriefBody(title, args.ref);
     await writeFrontmatter(
-      path42.join(dir, "brief.md"),
+      path44.join(dir, "brief.md"),
       {
         schema_version: 1,
         title,
@@ -4825,8 +5050,8 @@ var track_default = defineCommand({
     const artifacts = ArtifactsSchema.parse({
       worktrees: args.worktree ? [{ path: args.worktree, repo: args.worktree, name: "main", default: true }] : []
     });
-    await atomicWrite(path42.join(dir, "artifacts.yml"), yamlStringify(artifacts));
-    await atomicWrite(path42.join(dir, "sources", ".gitkeep"), "");
+    await atomicWrite(path44.join(dir, "artifacts.yml"), yamlStringify(artifacts));
+    await atomicWrite(path44.join(dir, "sources", ".gitkeep"), "");
     await appendTriagedLog("track", args.ref, `slug:${args.slug}`);
     return { slug: args.slug, dir, ref: args.ref };
   }
@@ -4856,24 +5081,26 @@ 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(),
+  // Rank the notes against this instead of the top task and brief titles.
+  about: z41.string().min(1).optional(),
   // Skip the check for another session already live on this initiative.
-  no_sibling_check: 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: {
@@ -4889,12 +5116,16 @@ var promptCommand = defineCommand({
         long: "--adhoc",
         description: "Frame the prompt as ad-hoc work on the workstream, awaiting the user\u2019s task, not a continuation of the handoff / top task."
       },
+      about: {
+        long: "--about",
+        description: "What this session is about, ranking the notes against it instead of the top task and brief titles."
+      },
       no_sibling_check: {
         long: "--no-sibling-check",
         description: "Skip the check for another session already live on this initiative."
       }
     },
-    usage: "active-work prompt [slug] [--offline] [--cwd <dir>] [--adhoc] [--no-sibling-check]"
+    usage: "active-work prompt [slug] [--offline] [--cwd <dir>] [--adhoc] [--about <text>] [--no-sibling-check]"
   },
   async run(args, ctx) {
     const activeRoot = ctx.activeRoot ?? getActiveRoot();
@@ -4916,6 +5147,7 @@ var promptCommand = defineCommand({
       slug,
       includeLiveStatus: !args.offline,
       adhoc: args.adhoc,
+      ...args.about !== void 0 ? { about: args.about } : {},
       detectSiblings: !args.no_sibling_check && !args.offline,
       ...process.env.AW_LEASE_ID ? { ownLeaseId: process.env.AW_LEASE_ID } : {}
     });
@@ -4926,19 +5158,19 @@ var prompt_default = promptCommand;
 
 // src/commands/edit.ts
 import { promises as fs33 } from "fs";
-import path43 from "path";
+import path45 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 +5209,7 @@ var defaultDeps = {
   spawner: defaultSpawner
 };
 function targetFile(slug) {
-  return path43.join(getInitiativeDir(slug), "brief.md");
+  return path45.join(getInitiativeDir(slug), "brief.md");
 }
 async function fileExists2(p) {
   try {
@@ -5025,8 +5257,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 +5271,7 @@ var edit_default = edit;
 
 // src/commands/mcp-serve.ts
 import { spawn as spawn3 } from "child_process";
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 
 // src/server/mcp.ts
 import {
@@ -5056,7 +5288,7 @@ import {
 } from "@titan-design/registry";
 
 // src/version.ts
-var BUILD_VERSION = "0.5.0";
+var BUILD_VERSION = "0.7.0";
 
 // src/server/mcp.ts
 var TOOL_NAME_PREFIX = "active__";
@@ -5079,7 +5311,7 @@ import { DaemonAlreadyRunningError, startDaemon } from "@titan-design/daemon";
 
 // src/server/dashboard-routes.ts
 import { promises as fs34 } from "fs";
-import path44 from "path";
+import path46 from "path";
 import { fileURLToPath } from "url";
 var PLACEHOLDER_HTML = `<!doctype html>
 <html lang="en">
@@ -5111,17 +5343,17 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filename) {
-  const ext = path44.extname(filename).toLowerCase();
+  const ext = path46.extname(filename).toLowerCase();
   return CONTENT_TYPES[ext] ?? "application/octet-stream";
 }
 function dashboardDirCandidates() {
-  const here = path44.dirname(fileURLToPath(import.meta.url));
+  const here = path46.dirname(fileURLToPath(import.meta.url));
   return [
-    path44.resolve(here, "dashboard"),
+    path46.resolve(here, "dashboard"),
     // bundled: dist/cli.js -> dist/dashboard
-    path44.resolve(here, "..", "dashboard"),
+    path46.resolve(here, "..", "dashboard"),
     // legacy: dist/server -> dist/dashboard
-    path44.resolve(here, "..", "..", "dist", "dashboard")
+    path46.resolve(here, "..", "..", "dist", "dashboard")
     // dev: src/server -> dist/dashboard
   ];
 }
@@ -5147,13 +5379,13 @@ async function handleDashboard(c) {
   const url = new URL(c.req.url);
   const subpath = url.pathname.replace(/^\/ui\/?/, "");
   const relative = subpath === "" ? "index.html" : subpath;
-  const target = path44.resolve(root, relative);
-  if (!target.startsWith(root + path44.sep) && target !== root) {
+  const target = path46.resolve(root, relative);
+  if (!target.startsWith(root + path46.sep) && target !== root) {
     return c.text("forbidden", 403);
   }
   const stat = await safeStat(target);
   if (!stat.exists || !stat.isFile) {
-    const indexPath = path44.join(root, "index.html");
+    const indexPath = path46.join(root, "index.html");
     const indexStat = await safeStat(indexPath);
     if (!indexStat.exists) {
       return c.html(PLACEHOLDER_HTML, 200);
@@ -5171,13 +5403,13 @@ async function handleDashboard(c) {
 
 // src/server/logger.ts
 import { mkdirSync, createWriteStream } from "fs";
-import path45 from "path";
+import path47 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 logPath = path47.join(stateRoot, "daemon.log");
   const fileStream = createWriteStream(logPath, { flags: "a" });
   const stderrIsTTY = process.stderr.isTTY === true;
   const stderrStream = stderrIsTTY ? pino.transport({
@@ -5197,144 +5429,6 @@ 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);
-    }
-  }
-];
-var PRESERVE_DDL = `
-  CREATE TABLE IF NOT EXISTS preserved_row (
-    table_name   TEXT NOT NULL,
-    identity     TEXT NOT NULL,
-    row_key      TEXT NOT NULL,
-    payload      TEXT NOT NULL,
-    origin       TEXT NOT NULL,
-    mode         TEXT NOT NULL DEFAULT 'insert',
-    preserved_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
-    PRIMARY KEY (table_name, row_key)
-  );
-`;
-var PRESERVE_MIGRATION = {
-  version: nextVersion([...SESSION_GRAPH_MIGRATIONS, ...WORKSPACE_MIGRATIONS]),
-  name: "preserved rows",
-  up: (db) => db.exec(PRESERVE_DDL)
-};
-var MIGRATIONS = [
-  ...SESSION_GRAPH_MIGRATIONS,
-  ...WORKSPACE_MIGRATIONS,
-  PRESERVE_MIGRATION
-];
-
-// src/session-index/graph.ts
-var SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
-function defaultGraphPath() {
-  return path46.join(getMinerRoot(), "graph.sqlite3");
-}
-function openGraph(dbPath = defaultGraphPath()) {
-  const graph = openSessionGraph(dbPath);
-  runMigrations(graph.db, MIGRATIONS);
-  return {
-    ...graph,
-    workspaceFiles: new WatermarkTable(graph.db, { name: WORKSPACE_KIT.watermark })
-  };
-}
-function openGraphReadOnly(dbPath = defaultGraphPath()) {
-  return new Database(dbPath, { readonly: true });
-}
-
 // src/session-index/refresh.ts
 import path56 from "path";
 import { promises as fs44 } from "fs";
@@ -5344,7 +5438,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 path48 from "path";
 var AMBIGUOUS = null;
 async function initiativeSlugs(root) {
   try {
@@ -5356,7 +5450,7 @@ async function initiativeSlugs(root) {
   }
 }
 async function readInitiative(root, slug) {
-  const dir = path47.join(root, slug, "tasks");
+  const dir = path48.join(root, slug, "tasks");
   let files;
   try {
     files = await fs35.readdir(dir);
@@ -5368,7 +5462,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(path48.join(dir, file), TaskSchema);
       found.push([task.id, { initiative: slug, title: task.title, status: task.status }]);
     } catch {
       continue;
@@ -5401,22 +5495,7 @@ function taskResolver(root) {
 // src/workspace-index/refresh.ts
 import { promises as fs43 } from "fs";
 import matter4 from "gray-matter";
-import { z as z42 } from "zod";
-
-// 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;
@@ -6032,7 +6111,7 @@ function isUnchanged(row, file) {
 }
 var BATCH = 200;
 function describeFailure(err) {
-  if (err instanceof z42.ZodError) {
+  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);
@@ -6538,15 +6617,15 @@ async function runDaemon(options = {}) {
 }
 
 // src/commands/mcp-serve.ts
-var ArgsSchema38 = z43.object({
-  stdio: z43.boolean().optional(),
-  detach: z43.boolean().optional(),
-  port: z43.number().int().positive().optional()
+var ArgsSchema39 = z44.object({
+  stdio: z44.boolean().optional(),
+  detach: z44.boolean().optional(),
+  port: z44.number().int().positive().optional()
 });
-var ResultSchema34 = z43.object({
-  mode: z43.enum(["stdio", "http", "detached"]),
-  pid: z43.number().optional(),
-  port: z43.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];
@@ -6568,8 +6647,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: {
@@ -6601,11 +6680,11 @@ var mcp_serve_default = defineCommand({
 });
 
 // src/commands/mcp-stop.ts
-import { z as z44 } from "zod";
-var ArgsSchema39 = z44.object({});
-var ResultSchema35 = z44.union([
-  z44.object({ stopped: z44.literal(true), pid: z44.number() }),
-  z44.object({ stopped: z44.literal(false), reason: z44.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;
@@ -6620,8 +6699,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) {
@@ -6650,13 +6729,13 @@ var mcp_stop_default = defineCommand({
 
 // src/commands/mcp-restart.ts
 import { spawn as spawn4 } from "child_process";
-import { z as z45 } from "zod";
-var ArgsSchema40 = z45.object({
-  port: z45.number().int().positive().optional()
+import { z as z46 } from "zod";
+var ArgsSchema41 = z46.object({
+  port: z46.number().int().positive().optional()
 });
-var ResultSchema36 = z45.object({
-  pid: z45.number(),
-  port: z45.number()
+var ResultSchema37 = z46.object({
+  pid: z46.number(),
+  port: z46.number()
 });
 var SHUTDOWN_TIMEOUT_MS2 = 15e3;
 var KILL_TIMEOUT_MS = 3e3;
@@ -6724,8 +6803,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: {
@@ -6744,17 +6823,17 @@ var mcp_restart_default = defineCommand({
 });
 
 // src/commands/mcp-status.ts
-import { z as z46 } from "zod";
-var ArgsSchema41 = z46.object({});
-var ResultSchema37 = z46.object({
-  running: z46.boolean(),
-  pid: z46.number().optional(),
-  port: z46.number().optional(),
-  version: z46.string().optional(),
-  uptime_ms: z46.number().optional(),
-  healthy: z46.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: z46.boolean().optional()
+  orphaned: z47.boolean().optional()
 });
 async function statusByPort(port) {
   const health = await probeHealth(port);
@@ -6772,8 +6851,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) {
@@ -6807,19 +6886,19 @@ var mcp_status_default = defineCommand({
 // src/commands/mcp-logs.ts
 import { promises as fs45 } from "fs";
 import path57 from "path";
-import { z as z47 } from "zod";
-var ArgsSchema42 = z47.object({
-  lines: z47.number().int().positive().optional()
+import { z as z48 } from "zod";
+var ArgsSchema43 = z48.object({
+  lines: z48.number().int().positive().optional()
 });
-var ResultSchema38 = z47.object({
-  lines: z47.array(z47.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: {
@@ -6849,7 +6928,7 @@ var mcp_logs_default = defineCommand({
 });
 
 // src/commands/miner-drain-ingest.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 
 // src/drain/transcript-reader.ts
 import { nextOffset, prefixHash, readJsonLines, resumePoint } from "@titan-design/locator";
@@ -6863,29 +6942,29 @@ import { promises as fs46 } from "fs";
 import path58 from "path";
 
 // src/schemas/template.ts
-import { z as z48 } from "zod";
-var LocatorSchema = z48.tuple([
-  z48.number().int().nonnegative(),
-  z48.number().int().nonnegative(),
-  z48.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 = z48.object({
-  templateId: z48.string().min(1),
-  toolType: z48.string().min(1),
-  maskedSignature: z48.string().min(1),
-  createdAt: z48.string().min(1),
-  occurrenceCount: z48.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 = z48.object({
-  templateId: z48.string().min(1),
+var OccurrenceSchema = z49.object({
+  templateId: z49.string().min(1),
   locator: LocatorSchema,
-  sessionId: z48.string().min(1),
-  timestamp: z48.string().min(1),
-  extractedParams: z48.record(z48.string(), z48.string()).optional()
+  sessionId: z49.string().min(1),
+  timestamp: z49.string().min(1),
+  extractedParams: z49.record(z49.string(), z49.string()).optional()
 });
-var TemplatesFileSchema = z48.object({
-  templates: z48.array(TemplateSchema).default([])
+var TemplatesFileSchema = z49.object({
+  templates: z49.array(TemplateSchema).default([])
 });
 
 // src/drain/store.ts
@@ -6932,27 +7011,27 @@ async function appendOccurrences(occurrences, root = getMinerRoot()) {
 // src/drain/tree-store.ts
 import { promises as fs47 } from "fs";
 import path59 from "path";
-import { z as z49 } from "zod";
-var PartitionSchema = z49.object({
-  partition: z49.string().min(1),
-  nextClusterId: z49.number().int().positive(),
-  clusters: z49.array(
-    z49.object({
-      clusterId: z49.number().int().positive(),
-      tokens: z49.array(z49.string()),
-      size: z49.number().int().nonnegative()
+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: z49.array(z49.tuple([z49.number().int().positive(), z49.string().min(1)]))
+  templateIds: z50.array(z50.tuple([z50.number().int().positive(), z50.string().min(1)]))
 });
-var TreeSnapshotFileSchema = z49.object({
-  version: z49.literal(1).default(1),
-  partitions: z49.array(PartitionSchema).default([])
+var TreeSnapshotFileSchema = z50.object({
+  version: z50.literal(1).default(1),
+  partitions: z50.array(PartitionSchema).default([])
 });
-var LegacySnapshotFileSchema = z49.object({
-  version: z49.literal(1),
-  trees: z49.array(PartitionSchema.omit({ partition: true }).extend({ toolType: z49.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");
@@ -7135,23 +7214,23 @@ function extractBlobs(line, toolNames) {
 // src/drain/reader-state.ts
 import { promises as fs48 } from "fs";
 import path60 from "path";
-import { z as z50 } from "zod";
-var TranscriptStateSchema = z50.object({
+import { z as z51 } from "zod";
+var TranscriptStateSchema = z51.object({
   /** `~`-relative path, matching `session-index/discover.ts`'s display form. */
-  path: z50.string().min(1),
-  lastByteOffset: z50.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: z50.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: z50.record(z50.string(), z50.string()).default({})
+  pendingToolNames: z51.record(z51.string(), z51.string()).default({})
 });
-var ReaderStateSchema = z50.object({
-  version: z50.literal(1).default(1),
-  transcripts: z50.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()) {
@@ -7322,33 +7401,33 @@ async function runDrainIngest(options = {}) {
 }
 
 // src/commands/miner-drain-ingest.ts
-var ArgsSchema43 = z51.object({
-  full: z51.boolean().optional(),
-  limit: z51.coerce.number().int().positive().optional(),
-  verify_hashes: z51.boolean().optional()
-});
-var ResultSchema39 = z51.object({
-  startedAt: z51.string(),
-  durationMs: z51.number(),
-  transcripts: z51.number(),
-  scanned: z51.number(),
-  unchanged: z51.number(),
-  rewound: z51.number(),
-  linesRead: z51.number(),
-  malformedLines: z51.number(),
-  blobs: z51.number(),
-  ingested: z51.number(),
-  newTemplates: z51.number(),
-  templates: z51.number(),
-  evicting: z51.boolean(),
-  curve: z51.array(z51.object({ blobs: z51.number(), templates: z51.number(), evicting: z51.boolean() })),
-  errors: z51.array(z51.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: {
@@ -7375,52 +7454,52 @@ var miner_drain_ingest_default = defineCommand({
 });
 
 // src/commands/miner-refresh.ts
-import { z as z52 } from "zod";
-var ArgsSchema44 = z52.object({
-  full: z52.boolean().optional(),
-  limit: z52.coerce.number().int().positive().optional(),
-  verify_hashes: z52.boolean().optional()
-});
-var WorkspaceSchema = z52.object({
-  files: z52.number(),
-  indexed: z52.number(),
-  unchanged: z52.number(),
-  removed: z52.number(),
-  malformed: z52.array(z52.object({ path: z52.string(), reason: z52.string() })),
-  rows: z52.object({
-    initiative: z52.number(),
-    note: z52.number(),
-    task: z52.number(),
-    session: z52.number(),
-    source: z52.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: z52.object({ holds: z52.number(), mentions: z52.number(), sharesTag: z52.number() }),
-  orphanRatio: z52.number()
+  edges: z53.object({ holds: z53.number(), mentions: z53.number(), sharesTag: z53.number() }),
+  orphanRatio: z53.number()
 });
-var ResultSchema40 = z52.object({
-  startedAt: z52.string(),
-  durationMs: z52.number(),
-  transcripts: z52.number(),
-  scanned: z52.number(),
-  indexed: z52.number(),
-  rewound: z52.number(),
-  unchanged: z52.number(),
-  quarantined: z52.number(),
-  missing: z52.number(),
-  reconciledMissing: z52.number(),
-  factsAdded: z52.number(),
-  turnsRolledUp: z52.number(),
-  tasksRequested: z52.number(),
-  tasksApplied: z52.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: z52.object({ restored: z52.number(), merged: z52.number(), skipped: z52.number() }),
-  errors: z52.array(z52.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: {
@@ -7446,7 +7525,7 @@ var miner_refresh_default = defineCommand({
 
 // src/commands/miner-liveness.ts
 import { existsSync as existsSync3 } from "fs";
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 
 // src/session-index/liveness.ts
 import { existsSync as existsSync2 } from "fs";
@@ -7563,22 +7642,22 @@ function runLiveness(db) {
 }
 
 // src/commands/miner-liveness.ts
-var ArgsSchema45 = z53.object({});
-var ResultSchema41 = z53.object({
-  emptyColumns: z53.array(
-    z53.object({ table: z53.string(), column: z53.string(), rows: z53.number(), nonNull: z53.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: z53.array(z53.string()),
-  undeclaredRelations: z53.array(z53.string()),
-  danglingNamespaces: z53.array(
-    z53.object({ namespace: z53.string(), edges: z53.number(), dangling: z53.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: z53.array(z53.string()),
-  expectedEmptyColumns: z53.array(
-    z53.object({ table: z53.string(), column: z53.string(), reason: z53.string() })
+  unmappedNamespaces: z54.array(z54.string()),
+  expectedEmptyColumns: z54.array(
+    z54.object({ table: z54.string(), column: z54.string(), reason: z54.string() })
   ),
-  staleTranscripts: z53.number(),
-  transcripts: z53.number()
+  staleTranscripts: z54.number(),
+  transcripts: z54.number()
 });
 function report(result) {
   const lines = [color.bold("active-work miner liveness")];
@@ -7630,8 +7709,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();
@@ -7669,40 +7748,40 @@ var miner_liveness_default = defineCommand({
 
 // src/commands/miner-status.ts
 import { existsSync as existsSync4, statSync } from "fs";
-import { z as z54 } from "zod";
-var ArgsSchema46 = z54.object({});
-var ResultSchema42 = z54.object({
-  dbPath: z54.string(),
-  schemaVersion: z54.number(),
-  sizeBytes: z54.number(),
-  counts: z54.object({
-    transcripts: z54.number(),
-    sessions: z54.number(),
-    facts: z54.number(),
-    turns: z54.number(),
-    edges: z54.number(),
-    spans: z54.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: z54.object({
-    ok: z54.number(),
-    quarantined: z54.number(),
-    missing: z54.number()
+  transcripts: z55.object({
+    ok: z55.number(),
+    quarantined: z55.number(),
+    missing: z55.number()
   }),
-  watermark: z54.object({
-    lastIndexedAt: z54.string().nullable(),
-    behindBytes: z54.number()
+  watermark: z55.object({
+    lastIndexedAt: z55.string().nullable(),
+    behindBytes: z55.number()
   }),
-  fts: z54.object({
-    rows: z54.number(),
-    orphanRows: z54.number(),
-    needsFullRebuild: z54.boolean()
+  fts: z55.object({
+    rows: z55.number(),
+    orphanRows: z55.number(),
+    needsFullRebuild: z55.boolean()
   }),
-  daemon: z54.object({
-    indexing: z54.boolean(),
-    pending: z54.boolean(),
-    lastRunAt: z54.string().nullable(),
-    lastDurationMs: z54.number().nullable(),
-    consecutiveErrors: z54.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;
@@ -7743,8 +7822,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);
@@ -7786,7 +7865,7 @@ var miner_status_default = defineCommand({
 });
 
 // src/commands/hooks-agent-chat-spawn.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 
 // src/utils/read-stdin-json.ts
 async function readStdinJson(stream = process.stdin) {
@@ -7807,12 +7886,12 @@ 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 z55 } from "zod";
-var SpawnContextSchema = z55.object({
-  slug: z55.string().min(1),
-  sessionId: z55.string().min(1),
-  name: z55.string(),
-  started: z55.string(),
+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
@@ -7820,10 +7899,10 @@ var SpawnContextSchema = z55.object({
    * another live entry in this same directory — which is gone by the time
    * on_complete runs, because reading one deletes it.
    */
-  parentSessionId: z55.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: z55.string().nullable().default(null),
-  briefing: z55.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");
@@ -7855,10 +7934,10 @@ async function peekSpawnContext(agentId) {
 }
 
 // src/commands/hooks-agent-chat-spawn.ts
-var ArgsSchema47 = z56.object({});
-var ResultSchema43 = z56.object({
-  matched: z56.boolean(),
-  slug: z56.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];
@@ -7887,8 +7966,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)"
   },
@@ -7900,11 +7979,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 z57 } from "zod";
-var ArgsSchema48 = z57.object({});
-var ResultSchema44 = z57.object({
-  recorded: z57.boolean(),
-  slug: z57.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];
@@ -7971,8 +8050,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)"
   },
@@ -7983,7 +8062,7 @@ var hooks_agent_chat_complete_default = defineCommand({
 });
 
 // src/commands/setup.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 
 // src/setup/steps.ts
 import { promises as fsp3, existsSync as existsSync5 } from "fs";
@@ -8134,7 +8213,7 @@ import path64 from "path";
 
 // src/migrations/v3-proposal.ts
 import { promises as fs51 } from "fs";
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 
 // src/migrations/data/v3-open-loops-proposal.ts
 var V3_OPEN_LOOPS_PROPOSAL = {
@@ -8930,36 +9009,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 = z58.object({ note: z58.string().min(1) });
+var AbandonedSchema = z59.object({ note: z59.string().min(1) });
 var ProposalNextStepSchema = NextStepSchema.extend({
   abandoned: AbandonedSchema.optional()
 });
-var ProposalInitiativeSchema = z58.object({
-  slug: z58.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: z58.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: z58.string().min(1),
-  next_steps: z58.array(ProposalNextStepSchema).default([])
+  body: z59.string().min(1),
+  next_steps: z59.array(ProposalNextStepSchema).default([])
 });
-var ProposalSchema = z58.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: z58.string().regex(ISO_INSTANT, {
+  abandoned_at: z59.string().regex(ISO_INSTANT, {
     message: "abandoned_at must be an ISO 8601 instant with timezone"
   }).optional(),
-  initiatives: z58.array(ProposalInitiativeSchema)
+  initiatives: z59.array(ProposalInitiativeSchema)
 }).superRefine((value, ctx) => {
   const withAbandoned = value.initiatives.filter(
     (i) => i.next_steps.some((n) => n.abandoned !== void 0)
@@ -9522,12 +9601,12 @@ var v3ToV4Worktrees = {
 
 // src/migrations/index.ts
 var BASE_VERSION = 1;
-var MIGRATIONS2 = [v1ToV2Artifacts, v2ToV3OpenLoops, v3ToV4Worktrees];
-var CURRENT_VERSION = targetVersion(MIGRATIONS2);
+var MIGRATIONS = [v1ToV2Artifacts, v2ToV3OpenLoops, v3ToV4Worktrees];
+var CURRENT_VERSION = targetVersion(MIGRATIONS);
 function targetVersion(migrations) {
   return migrations.reduce((highest, m) => Math.max(highest, m.to), BASE_VERSION);
 }
-async function runMigrations2(activeRoot, fromVersion, migrations = MIGRATIONS2) {
+async function runMigrations(activeRoot, fromVersion, migrations = MIGRATIONS) {
   if (fromVersion === CURRENT_VERSION) {
     return { ran: [] };
   }
@@ -9636,7 +9715,7 @@ async function ensureSchemaVersion(activeRoot) {
   if (before === CURRENT_VERSION) {
     return { before, after: before, migrated: false, ran: [] };
   }
-  const { ran } = await runMigrations2(activeRoot, before);
+  const { ran } = await runMigrations(activeRoot, before);
   await writeSchemaVersion(activeRoot, CURRENT_VERSION);
   return {
     before,
@@ -10889,20 +10968,20 @@ async function runUninstall(deps = {}) {
 }
 
 // src/commands/setup.ts
-var ArgsSchema49 = z59.object({
-  update: z59.boolean().optional(),
-  yes: z59.boolean().optional()
+var ArgsSchema50 = z60.object({
+  update: z60.boolean().optional(),
+  yes: z60.boolean().optional()
 });
-var StepSchema = z59.object({
-  name: z59.string(),
-  ok: z59.boolean(),
-  done: z59.boolean().optional(),
-  message: z59.string().optional(),
-  error: z59.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 = z59.object({
-  banner: z59.string(),
-  steps: z59.array(StepSchema)
+var ResultSchema46 = z60.object({
+  banner: z60.string(),
+  steps: z60.array(StepSchema)
 });
 function printStep(step) {
   if (step.ok) {
@@ -10919,8 +10998,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: {
@@ -10955,25 +11034,25 @@ var setup_default = defineCommand({
 });
 
 // src/commands/uninstall.ts
-import { z as z60 } from "zod";
-var ArgsSchema50 = z60.object({
-  yes: z60.boolean().optional()
+import { z as z61 } from "zod";
+var ArgsSchema51 = z61.object({
+  yes: z61.boolean().optional()
 });
-var StepSchema2 = z60.object({
-  name: z60.string(),
-  done: z60.boolean(),
-  message: z60.string().optional(),
-  error: z60.string().optional()
+var StepSchema2 = z61.object({
+  name: z61.string(),
+  done: z61.boolean(),
+  message: z61.string().optional(),
+  error: z61.string().optional()
 });
-var ResultSchema46 = z60.object({
-  steps: z60.array(StepSchema2),
-  activeRootPreservedAt: z60.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: {
@@ -11003,7 +11082,7 @@ var uninstall_default = defineCommand({
 });
 
 // src/commands/doctor.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 
 // src/doctor.ts
 import { promises as fsp4 } from "fs";
@@ -11411,15 +11490,15 @@ async function runDoctor(deps = {}) {
 }
 
 // src/commands/doctor.ts
-var ArgsSchema51 = z61.object({});
-var CheckSchema = z61.object({
-  name: z61.string(),
-  status: z61.enum(["ok", "warn", "fail"]),
-  detail: z61.string()
+var ArgsSchema52 = z62.object({});
+var CheckSchema = z62.object({
+  name: z62.string(),
+  status: z62.enum(["ok", "warn", "fail"]),
+  detail: z62.string()
 });
-var ResultSchema47 = z61.object({
-  ok: z61.boolean(),
-  checks: z61.array(CheckSchema)
+var ResultSchema48 = z62.object({
+  ok: z62.boolean(),
+  checks: z62.array(CheckSchema)
 });
 function badge(status) {
   if (status === "ok") return color.green("OK  ");
@@ -11429,8 +11508,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") {
@@ -11447,34 +11526,34 @@ var doctor_default = defineCommand({
 });
 
 // src/commands/migrate.ts
-import { z as z62 } from "zod";
-var ArgsSchema52 = z62.object({
-  dry_run: z62.boolean().optional(),
-  apply: z62.boolean().optional()
-});
-var SessionSchema = z62.object({
-  kind: z62.enum(["open", "abandon"]),
-  action: z62.enum(["write", "exists"]),
-  file: z62.string(),
-  ended: z62.string(),
-  loops: z62.number().int().nonnegative(),
-  resolves: z62.number().int().nonnegative()
-});
-var InitiativeSchema = z62.object({
-  slug: z62.string(),
-  sessions: z62.array(SessionSchema),
-  task_seq_backfill: z62.number().int().positive().nullable(),
-  brief_repairs: z62.array(z62.string()),
-  brief_blocked: z62.string().optional(),
-  handoff: z62.enum(["archive-and-remove", "archive-exists", "absent"]),
-  note: z62.string().optional()
+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 ResultSchema48 = z62.object({
-  applied: z62.boolean(),
-  proposal: z62.string(),
-  initiatives: z62.array(InitiativeSchema),
-  repairs: z62.array(z62.object({ action: z62.string(), file: z62.string(), detail: z62.string() })),
-  uncovered: z62.array(z62.string())
+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) => ({
@@ -11550,8 +11629,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" },
@@ -11586,18 +11665,18 @@ var migrate_default = defineCommand({
 
 // src/commands/sync.ts
 import os7 from "os";
-import { z as z63 } from "zod";
-var ArgsSchema53 = z63.object({
-  message: z63.string().min(1).optional(),
-  require_clean: z63.boolean().optional()
-});
-var ResultSchema49 = z63.object({
-  branch: z63.string(),
-  committed: z63.boolean(),
-  committed_files: z63.number().int(),
-  rebased: z63.boolean(),
-  pushed: z63.boolean(),
-  summary: z63.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]);
@@ -11699,8 +11778,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: {
@@ -11794,6 +11873,7 @@ var ALL_COMMANDS = [
   audit_default,
   list_default,
   context_graph_default,
+  search_default,
   // discover / triage
   discover_default,
   fold_default,