@titan-design/active-work 0.6.0 → 0.7.0

package/dist/aw.js

@@ -12,7 +12,7 @@ import {
   releaseLeaseSync,
   resolveLaunchCwd,
   resume_default
-} from "./chunk-RLSQSE7I.js";
+} from "./chunk-KAR6NOS2.js";
 
 // src/aw.ts
 import { spawn } from "child_process";

package/dist/{chunk-RLSQSE7I.js → chunk-KAR6NOS2.js}

@@ -151,7 +151,7 @@ function parseLauncherFlags(args) {
 
 // src/commands/_open-helpers.ts
 import { promises as fs11 } from "fs";
-import path11 from "path";
+import path12 from "path";
 
 // src/schemas/brief.ts
 import { z } from "zod";
@@ -461,7 +461,7 @@ async function writeArtifactsFile(initiativeDir, artifacts) {
 
 // src/bootstrap/prompt.ts
 import { promises as fs10 } from "fs";
-import path10 from "path";
+import path11 from "path";
 
 // src/schemas/task.ts
 import { z as z3 } from "zod";
@@ -1014,10 +1014,228 @@ async function writeNoteFile(initiativeDir, frontmatter, body) {
   return { path: fullPath, filename };
 }
 
+// src/bootstrap/rank-notes.ts
+import { fuseByRRF } 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 path8 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 path8.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/bootstrap/rank-notes.ts
+var FOREIGN_CAP = 3;
+var FOREIGN_FLOOR_PER_TERM = 3.5;
+var SEARCH_DEPTH = 300;
+var STOP_WORDS = new Set(
+  "a an and are as at be but by for from in into is it of on or the to with via than then that this these those over under new old add fix use using not no all any each per".split(" ")
+);
+function subjectTerms(subject) {
+  const tokens = subject.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [];
+  return [...new Set(tokens.filter((token) => token.length > 2 && !STOP_WORDS.has(token)))];
+}
+function subjectOf(input) {
+  if (input.about !== void 0 && input.about.trim().length > 0) return input.about.trim();
+  return [input.topTaskTitle, input.briefTitle].filter(Boolean).join(" ").trim();
+}
+function graphNoteRelevance(dbPath) {
+  return (terms) => {
+    const graph = openGraph(dbPath ?? defaultGraphPath());
+    try {
+      const expression = terms.map((term) => `"${term}"`).join(" OR ");
+      const titleOf = graph.db.prepare("SELECT title FROM note WHERE note_ref = ? LIMIT 1");
+      const seen = /* @__PURE__ */ new Set();
+      const hits = [];
+      for (const span of graph.spans.search(expression, SEARCH_DEPTH, { ownerPrefix: "note:" })) {
+        if (seen.has(span.ownerRef)) continue;
+        seen.add(span.ownerRef);
+        const row = titleOf.get(span.ownerRef);
+        hits.push({
+          ref: span.ownerRef,
+          scorePerTerm: -span.rank / terms.length,
+          ...row ? { title: row.title } : {}
+        });
+      }
+      return hits;
+    } finally {
+      graph.db.close();
+    }
+  };
+}
+function refOf(slug, note) {
+  return `note:${slug}/${note.filename}`;
+}
+function initiativeOf(ref) {
+  return ref.slice("note:".length).split("/")[0] ?? "";
+}
+function fuseWithRecency(notes, slug, relevantRefs) {
+  const byRef = new Map(notes.map((note) => [refOf(slug, note), note]));
+  const fused = fuseByRRF([
+    { name: "recency", hits: notes.map((note, i) => ({ id: refOf(slug, note), rank: i + 1 })) },
+    {
+      name: "relevance",
+      hits: relevantRefs.filter((ref) => byRef.has(ref)).map((ref, i) => ({ id: ref, rank: i + 1 }))
+    }
+  ]);
+  return fused.map((result) => byRef.get(result.id)).filter((note) => !!note);
+}
+function rankNotes(input) {
+  const dateOrder = { local: input.notes, foreign: [], ranked: false };
+  if (input.notes.length === 0) return dateOrder;
+  const terms = subjectTerms(input.subject);
+  if (terms.length === 0) return dateOrder;
+  let hits;
+  try {
+    hits = (input.relevance ?? graphNoteRelevance())(terms);
+  } catch {
+    return dateOrder;
+  }
+  if (hits.length === 0) return dateOrder;
+  const foreign = hits.filter((hit) => initiativeOf(hit.ref) !== input.slug).filter((hit) => hit.scorePerTerm >= FOREIGN_FLOOR_PER_TERM).slice(0, FOREIGN_CAP).map((hit) => ({
+    initiative: initiativeOf(hit.ref),
+    title: hit.title ?? hit.ref,
+    ref: hit.ref
+  }));
+  const localRefs = hits.filter((hit) => initiativeOf(hit.ref) === input.slug).map((hit) => hit.ref);
+  return { local: fuseWithRecency(input.notes, input.slug, localRefs), foreign, ranked: true };
+}
+
 // src/sessions/lease.ts
 import { promises as fs9, unlinkSync } from "fs";
 import { randomBytes as randomBytes2 } from "crypto";
-import path8 from "path";
+import path9 from "path";
 
 // src/schemas/lease.ts
 import { z as z7 } from "zod";
@@ -1086,10 +1304,10 @@ var ONESHOT_TTL_MS = 90 * 6e4;
 var LAUNCHER_MAX_AGE_MS = 36 * 60 * 6e4;
 var LEASE_DIR_NAME = ".sessions";
 function leaseDir(activeRoot, slug) {
-  return path8.join(activeRoot, LEASE_DIR_NAME, slug);
+  return path9.join(activeRoot, LEASE_DIR_NAME, slug);
 }
 function leasePath(activeRoot, slug, leaseId) {
-  return path8.join(leaseDir(activeRoot, slug), `${leaseId}.json`);
+  return path9.join(leaseDir(activeRoot, slug), `${leaseId}.json`);
 }
 async function acquireLease(input) {
   const {
@@ -1192,7 +1410,7 @@ async function readLiveLeases(input) {
     const live = [];
     for (const name of entries) {
       if (!name.endsWith(".json")) continue;
-      const file = path8.join(dir, name);
+      const file = path9.join(dir, name);
       const lease = await readOneLease(file);
       if (!lease || !isLive(lease, now, isAlive, getComm)) {
         await unlinkQuietly(file);
@@ -1207,7 +1425,7 @@ async function readLiveLeases(input) {
   }
 }
 async function sweepAllLeases(activeRoot, options = {}) {
-  const root = path8.join(activeRoot, LEASE_DIR_NAME);
+  const root = path9.join(activeRoot, LEASE_DIR_NAME);
   let slugs;
   try {
     const entries = await fs9.readdir(root, { withFileTypes: true });
@@ -1233,7 +1451,7 @@ async function sweepAllLeases(activeRoot, options = {}) {
 
 // src/utils/git-gh.ts
 import { spawn } from "child_process";
-import path9 from "path";
+import path10 from "path";
 var DEFAULT_TIMEOUT_MS = 1e4;
 var defaultRunner = (bin, args, opts = {}) => new Promise((resolve, reject) => {
   const child = spawn(bin, args, {
@@ -1285,7 +1503,7 @@ function looksLikeOrgRepo(repo) {
 }
 function resolveLocalRepoPath(repo) {
   if (looksLikeOrgRepo(repo)) return null;
-  return path9.resolve(expandTilde(repo));
+  return path10.resolve(expandTilde(repo));
 }
 async function deriveOrgRepoFromPath(repoPath) {
   try {
@@ -1356,7 +1574,7 @@ function describe2(err) {
   return err instanceof Error ? err.message : String(err);
 }
 async function loadTasks(initiativeDir) {
-  const tasksDir = path10.join(initiativeDir, "tasks");
+  const tasksDir = path11.join(initiativeDir, "tasks");
   let entries;
   try {
     entries = await fs10.readdir(tasksDir);
@@ -1367,7 +1585,7 @@ async function loadTasks(initiativeDir) {
   const tasks = [];
   const malformed = [];
   for (const filename of ymlFiles) {
-    const fullPath = path10.join(tasksDir, filename);
+    const fullPath = path11.join(tasksDir, filename);
     try {
       tasks.push(await readYaml(fullPath, TaskSchema));
     } catch (err) {
@@ -1380,7 +1598,7 @@ function isMissingFile(err) {
   return err?.code === "ENOENT";
 }
 async function loadArtifacts(initiativeDir) {
-  const artifactsPath = path10.join(initiativeDir, "artifacts.yml");
+  const artifactsPath = path11.join(initiativeDir, "artifacts.yml");
   const empty = { branches: [], stashes: [], worktrees: [] };
   try {
     return { artifacts: await readYaml(artifactsPath, ArtifactsSchema) };
@@ -1489,24 +1707,35 @@ function renderNoteLine(note) {
   const { kind, title, created } = note.frontmatter;
   return `- [${kind}] ${title} (${created})`;
 }
-function renderDurableNotes(loaded, slug) {
-  const { notes, malformed } = loaded;
+function renderDurableNotes(loaded, ranking, slug) {
+  const { malformed } = loaded;
+  const notes = ranking.local;
   if (notes.length === 0 && malformed.length === 0) return null;
   const shown = notes.slice(0, DURABLE_NOTES_LIMIT);
   const lines = shown.map(renderNoteLine);
   const overflow = notes.length - shown.length;
+  const ordering = ranking.ranked ? "most relevant" : "newest";
   if (overflow > 0) {
-    lines.push(`(+${overflow} older \u2014 \`active-work note list ${slug}\`)`);
+    const rest = ranking.ranked ? "more" : "older";
+    lines.push(`(+${overflow} ${rest} \u2014 \`active-work note list ${slug}\`)`);
   }
   if (malformed.length > 0) {
     lines.push(
       `(${malformed.length} note file(s) unreadable \u2014 run \`active-work note list ${slug}\`)`
     );
   }
-  const heading = overflow > 0 ? `# Durable notes (newest ${shown.length} of ${notes.length})` : `# Durable notes (${notes.length})`;
+  const heading = overflow > 0 ? `# Durable notes (${ordering} ${shown.length} of ${notes.length})` : `# Durable notes (${notes.length})`;
   return `${heading}
 ${lines.join("\n")}`;
 }
+function renderForeignNotes(ranking) {
+  if (ranking.foreign.length === 0) return null;
+  const lines = ranking.foreign.map(
+    (note) => `- [from \`${note.initiative}\`] ${note.title} (\`${note.ref}\`)`
+  );
+  return `# From other initiatives
+${lines.join("\n")}`;
+}
 function renderNoOpenLoops(newestSession) {
   if (newestSession?.frontmatter.no_loops === true) {
     return `Nothing hanging \u2014 the ${endedDate(newestSession.ended)} session asserted the ledger is clear.`;
@@ -1883,7 +2112,7 @@ function renderBriefState(brief, now) {
 ${lines.join("\n")}`;
 }
 async function loadBrief(initiativeDir, slug) {
-  const briefPath = path10.join(initiativeDir, "brief.md");
+  const briefPath = path11.join(initiativeDir, "brief.md");
   try {
     return await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
   } catch (err) {
@@ -1904,9 +2133,11 @@ async function assembleBootstrap(input) {
     adhoc = false,
     detectSiblings = true,
     siblingProbe = readLiveLeases,
-    ownLeaseId
+    ownLeaseId,
+    about,
+    noteRelevance
   } = input;
-  const initiativeDir = path10.join(activeRoot, slug);
+  const initiativeDir = path11.join(activeRoot, slug);
   const { frontmatter: brief, body: briefBody } = await loadBrief(initiativeDir, slug);
   const [loaded, loadedTasks, loadedArtifacts, notes] = await Promise.all([
     loadSessionsNewestFirst(initiativeDir),
@@ -1923,7 +2154,7 @@ async function assembleBootstrap(input) {
   const narrativeSession = latestCanonical ?? sessions[0];
   const usedFallbackTrack = !latestCanonical && narrativeSession !== void 0;
   const parallelBody = renderParallelSessions(selectParallelSessions(sessions, narrativeSession));
-  const briefExcerpt = truncateLines(briefBody, BRIEF_BODY_MAX_LINES, path10.join(initiativeDir, "brief.md")) || "_(no brief body)_";
+  const briefExcerpt = truncateLines(briefBody, BRIEF_BODY_MAX_LINES, path11.join(initiativeDir, "brief.md")) || "_(no brief body)_";
   const { body: tasksBody, count: openTaskCount } = renderTopTasks(tasks, topNTasks, slug);
   const { body: recentlyDoneBody, count: recentlyDoneCount } = renderRecentlyDone(
     tasks,
@@ -1958,6 +2189,16 @@ async function assembleBootstrap(input) {
     }
   }
   const topTaskTitle = tasks.filter((t) => t.status === "open").sort(compareTasksByPriority)[0]?.title;
+  const noteRanking = rankNotes({
+    notes: notes.notes,
+    slug,
+    subject: subjectOf({
+      ...about !== void 0 ? { about } : {},
+      briefTitle: brief.title,
+      ...topTaskTitle !== void 0 ? { topTaskTitle } : {}
+    }),
+    ...noteRelevance ? { relevance: noteRelevance } : {}
+  });
   const sections = [];
   sections.push(
     adhoc ? `Starting an ad-hoc session on \`${slug}\` (${brief.title}). This session is scoped to ad-hoc work related to this workstream \u2014 not necessarily its handoff or current top task. The context below is background so you're oriented; wait for the user to describe the specific ad-hoc task before acting.` : `Starting a session on \`${slug}\` (${brief.title}).`
@@ -1975,7 +2216,7 @@ ${briefExcerpt}`);
     const sessionExcerpt = truncateLines(
       narrativeSession.body,
       SESSION_BODY_MAX_LINES,
-      path10.join(initiativeDir, "sessions", `${narrativeSession.sessionFile}.md`)
+      path11.join(initiativeDir, "sessions", `${narrativeSession.sessionFile}.md`)
     ) || "_(empty session body)_";
     const ended = endedDate(narrativeSession.frontmatter.ended);
     const trackLabel = usedFallbackTrack ? ` (${narrativeSession.frontmatter.track})` : "";
@@ -2002,10 +2243,12 @@ ${recentlyDoneBody}`);
 Moved ${archivedTaskIds.length} stale done task(s) to tasks/archive/: ${archivedTaskIds.join(", ")}`
     );
   }
-  const notesBody = renderDurableNotes(notes, slug);
+  const notesBody = renderDurableNotes(notes, noteRanking, slug);
   if (notesBody) sections.push(notesBody);
+  const foreignBody = renderForeignNotes(noteRanking);
+  if (foreignBody) sections.push(foreignBody);
   if (artifactsError) {
-    const artifactsPath = path10.join(initiativeDir, "artifacts.yml");
+    const artifactsPath = path11.join(initiativeDir, "artifacts.yml");
     sections.push(
       `# Open artifacts
 _${artifactsPath} exists but could not be read (${artifactsError}). Branch and stash context is MISSING from this bootstrap \u2014 do not treat the working tree as clean. Run \`active-work doctor\`._`
@@ -2073,22 +2316,22 @@ async function resolveSlug(activeRoot, input) {
   throw new NotFoundError(`No initiative matches '${input}'. Known: ${slugs.join(", ")}`);
 }
 function resolveLaunchCwd(activeRoot, slug) {
-  return path11.join(activeRoot, slug);
+  return path12.join(activeRoot, slug);
 }
 async function resolveCwdHint(activeRoot, slug) {
-  const registered = await readRegisteredWorktrees(path11.join(activeRoot, slug));
+  const registered = await readRegisteredWorktrees(path12.join(activeRoot, slug));
   const preferred = defaultWorktreePath(registered);
-  return preferred === null ? path11.join(activeRoot, slug) : expandTilde(preferred);
+  return preferred === null ? path12.join(activeRoot, slug) : expandTilde(preferred);
 }
 function isInside(child, parent) {
-  const rel = path11.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path11.isAbsolute(rel);
+  const rel = path12.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path12.isAbsolute(rel);
 }
 async function canonicalize(p) {
   try {
     return await fs11.realpath(p);
   } catch {
-    return path11.resolve(p);
+    return path12.resolve(p);
   }
 }
 async function resolveSlugFromCwd(activeRoot, cwd) {
@@ -2097,16 +2340,16 @@ async function resolveSlugFromCwd(activeRoot, cwd) {
   let best = null;
   let tiedAtBest = false;
   for (const slug of slugs) {
-    const briefPath = path11.join(activeRoot, slug, "brief.md");
+    const briefPath = path12.join(activeRoot, slug, "brief.md");
     try {
       await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
     } catch {
       continue;
     }
-    const registered = await readRegisteredWorktrees(path11.join(activeRoot, slug));
+    const registered = await readRegisteredWorktrees(path12.join(activeRoot, slug));
     for (const entry of registered) {
       const displayPath = expandTilde(entry.path);
-      if (!path11.isAbsolute(displayPath)) continue;
+      if (!path12.isAbsolute(displayPath)) continue;
       const canonical = await canonicalize(displayPath);
       if (!isInside(resolvedCwd, canonical)) continue;
       const depth = canonical.length;
@@ -2123,16 +2366,16 @@ async function resolveSlugFromCwd(activeRoot, cwd) {
 }
 
 // src/commands/open.ts
-import path14 from "path";
+import path15 from "path";
 import { z as z9 } from "zod";
 
 // src/bootstrap/archive-tasks.ts
 import { promises as fsp } from "fs";
-import path12 from "path";
+import path13 from "path";
 var MS_PER_DAY3 = 864e5;
 async function archiveStaleTasks(initiativeDir, opts) {
   if (!(opts.retentionDays > 0)) return [];
-  const tasksDir = path12.join(initiativeDir, "tasks");
+  const tasksDir = path13.join(initiativeDir, "tasks");
   let entries;
   try {
     entries = await fsp.readdir(tasksDir);
@@ -2141,10 +2384,10 @@ async function archiveStaleTasks(initiativeDir, opts) {
   }
   const ymlFiles = entries.filter((n) => n.endsWith(".yml") || n.endsWith(".yaml"));
   const cutoffMs = opts.now.getTime() - opts.retentionDays * MS_PER_DAY3;
-  const archiveDir = path12.join(tasksDir, "archive");
+  const archiveDir = path13.join(tasksDir, "archive");
   const archived = [];
   for (const filename of ymlFiles) {
-    const fullPath = path12.join(tasksDir, filename);
+    const fullPath = path13.join(tasksDir, filename);
     let doneAt;
     let id;
     try {
@@ -2159,7 +2402,7 @@ async function archiveStaleTasks(initiativeDir, opts) {
     if (Number.isNaN(doneMs) || doneMs > cutoffMs) continue;
     try {
       await fsp.mkdir(archiveDir, { recursive: true });
-      await fsp.rename(fullPath, path12.join(archiveDir, filename));
+      await fsp.rename(fullPath, path13.join(archiveDir, filename));
       archived.push(id);
     } catch {
     }
@@ -2169,7 +2412,7 @@ async function archiveStaleTasks(initiativeDir, opts) {
 
 // src/utils/global-config.ts
 import { promises as fs12 } from "fs";
-import path13 from "path";
+import path14 from "path";
 import { z as z8 } from "zod";
 var GlobalConfigSchema = z8.object({
   channels: z8.array(channelTarget).optional()
@@ -2178,7 +2421,7 @@ var FALLBACK_DEFAULT_CHANNELS = ["plugin:agent-chat@agent-chat-local"];
 async function readGlobalConfig(configRoot = getConfigRoot()) {
   let raw;
   try {
-    raw = await fs12.readFile(path13.join(configRoot, "config.json"), "utf8");
+    raw = await fs12.readFile(path14.join(configRoot, "config.json"), "utf8");
   } catch {
     return {};
   }
@@ -2210,6 +2453,7 @@ var ArgsSchema2 = z9.object({
   // Frame the bootstrap prompt as ad-hoc work related to the workstream rather
   // than a continuation of its handoff / top task.
   adhoc: z9.boolean().optional(),
+  about: z9.string().min(1).optional(),
   // Skip the sibling-session probe (and the lease write that goes with it).
   no_sibling_check: z9.boolean().optional(),
   // Internal: `aw` calls this command in-process and holds a `launcher` lease
@@ -2254,7 +2498,7 @@ var STATE_ORDER = {
   done: 3
 };
 async function loadInitiativeSummary(activeRoot, slug) {
-  const briefPath = path14.join(activeRoot, slug, "brief.md");
+  const briefPath = path15.join(activeRoot, slug, "brief.md");
   try {
     const { frontmatter } = await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
     return {
@@ -2294,10 +2538,10 @@ async function claimOneshotLease(activeRoot, slug, cwd) {
   }
 }
 async function bootstrapInitiative(activeRoot, slug, opts) {
-  const briefPath = path14.join(activeRoot, slug, "brief.md");
+  const briefPath = path15.join(activeRoot, slug, "brief.md");
   const { frontmatter: brief } = await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
   const cwdHint = opts.cwdHintOverride ?? await resolveCwdHint(activeRoot, slug);
-  const archivedTaskIds = await archiveStaleTasks(path14.join(activeRoot, slug), {
+  const archivedTaskIds = await archiveStaleTasks(path15.join(activeRoot, slug), {
     retentionDays: ARCHIVE_DONE_AFTER_DAYS,
     now: /* @__PURE__ */ new Date()
   });
@@ -2308,6 +2552,7 @@ async function bootstrapInitiative(activeRoot, slug, opts) {
     includeLiveStatus: !opts.offline,
     archivedTaskIds,
     adhoc: opts.adhoc,
+    ...opts.about !== void 0 ? { about: opts.about } : {},
     detectSiblings,
     ...process.env.AW_LEASE_ID ? { ownLeaseId: process.env.AW_LEASE_ID } : {}
   });
@@ -2344,6 +2589,10 @@ var openCommand = defineCommand({
         long: "--pick",
         description: "Always return the picker list; skip resolving the initiative from the current directory."
       },
+      about: {
+        long: "--about",
+        description: "What this session is about, ranking the notes against it instead of the top task and brief titles."
+      },
       adhoc: {
         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."
@@ -2353,7 +2602,7 @@ var openCommand = defineCommand({
         description: "Skip the check for another session already live on this initiative, and do not record a lease for this one."
       }
     },
-    usage: "active-work open [slug] [--offline] [--cwd <dir>] [--pick] [--adhoc] [--no-sibling-check]"
+    usage: "active-work open [slug] [--offline] [--cwd <dir>] [--pick] [--adhoc] [--about <text>] [--no-sibling-check]"
   },
   async run(args, ctx) {
     const activeRoot = ctx.activeRoot ?? getActiveRoot();
@@ -2365,6 +2614,7 @@ var openCommand = defineCommand({
         offline: args.offline,
         resolvedFrom: "slug",
         adhoc: args.adhoc,
+        ...args.about !== void 0 ? { about: args.about } : {},
         detectSiblings,
         deferLease
       });
@@ -2378,6 +2628,7 @@ var openCommand = defineCommand({
           resolvedFrom: "cwd",
           cwdHintOverride: matched.worktreePath,
           adhoc: args.adhoc,
+          ...args.about !== void 0 ? { about: args.about } : {},
           detectSiblings,
           deferLease
         });
@@ -2395,11 +2646,11 @@ import { z as z10 } from "zod";
 // src/sessions/resolve-session-location.ts
 import { promises as fs13 } from "fs";
 import os2 from "os";
-import path15 from "path";
+import path16 from "path";
 import matter2 from "gray-matter";
 async function findInActiveWork(activeRoot, sessionId) {
   for (const slug of await listInitiativeSlugs(activeRoot)) {
-    const sessionsDir = path15.join(activeRoot, slug, "sessions");
+    const sessionsDir = path16.join(activeRoot, slug, "sessions");
     let filenames;
     try {
       filenames = await fs13.readdir(sessionsDir);
@@ -2410,7 +2661,7 @@ async function findInActiveWork(activeRoot, sessionId) {
       if (!filename.endsWith(".md") || !filename.includes(sessionId)) continue;
       let raw;
       try {
-        raw = await fs13.readFile(path15.join(sessionsDir, filename), "utf8");
+        raw = await fs13.readFile(path16.join(sessionsDir, filename), "utf8");
       } catch {
         continue;
       }
@@ -2423,7 +2674,7 @@ async function findInActiveWork(activeRoot, sessionId) {
   return null;
 }
 function transcriptsRoot() {
-  return process.env.CLAUDE_PROJECTS_ROOT ?? path15.join(os2.homedir(), ".claude", "projects");
+  return process.env.CLAUDE_PROJECTS_ROOT ?? path16.join(os2.homedir(), ".claude", "projects");
 }
 async function extractCwd(filePath) {
   const raw = await fs13.readFile(filePath, "utf8");
@@ -2452,7 +2703,7 @@ async function findInClaudeProjects(sessionId) {
   }
   const targetName = `${sessionId}.jsonl`;
   for (const dir of projectDirs) {
-    const candidate = path15.join(root, dir, targetName);
+    const candidate = path16.join(root, dir, targetName);
     try {
       await fs13.access(candidate);
     } catch {
@@ -2574,6 +2825,11 @@ export {
   source_add_default,
   loadNotesFromDir,
   writeNoteFile,
+  WORKSPACE_SPAN_SOURCE_BASE,
+  SCHEMA_VERSION,
+  defaultGraphPath,
+  openGraph,
+  openGraphReadOnly,
   readPidFile,
   removePidFile,
   resolveDaemonPort,
@@ -2604,4 +2860,4 @@ export {
   resume_default,
   color
 };
-//# sourceMappingURL=chunk-RLSQSE7I.js.map
+//# sourceMappingURL=chunk-KAR6NOS2.js.map