threadnote 1.5.0 → 1.6.1

package/dist/threadnote.cjs

@@ -3394,7 +3394,7 @@ var program = new Command();
 // src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
-var DEFAULT_OPENVIKING_VERSION = "0.4.5";
+var DEFAULT_OPENVIKING_VERSION = "0.4.7";
 var OPENVIKING_TOOL_PYTHON = "3.12";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
@@ -3447,7 +3447,7 @@ var DEFAULT_SEED_PATTERNS = [
 ];
 
 // src/hooks.ts
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
 var import_node_path11 = require("node:path");
 
 // src/mcp.ts
@@ -3663,7 +3663,7 @@ function hasGlob(path2) {
   return path2.includes("*") || path2.includes("?");
 }
 function escapeRegExp(value) {
-  return value.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function requiredOpenVikingCli() {
   const command2 = await findOpenVikingCli();
@@ -7548,6 +7548,35 @@ async function inferProjectFromQuery(manifestPath, query) {
     return void 0;
   }
 }
+function resolveWorksetProjects(manifest, workset) {
+  const byName = new Map(manifest.projects.map((project) => [project.name.toLowerCase(), project]));
+  const projects = workset.projects.map((name) => byName.get(name.toLowerCase())).filter((project) => project !== void 0);
+  return { name: workset.name, projects };
+}
+async function requireWorkset(manifestPath, worksetName) {
+  const manifest = await readSeedManifest(manifestPath);
+  const workset = manifest.worksets?.find((entry) => entry.name.toLowerCase() === worksetName.toLowerCase());
+  if (!workset) {
+    throw new Error(`No workset named "${worksetName}" in ${manifestPath}.`);
+  }
+  return resolveWorksetProjects(manifest, workset);
+}
+async function inferWorksetFromQuery(manifestPath, query) {
+  try {
+    const manifest = await readSeedManifest(manifestPath);
+    if (!manifest.worksets || manifest.worksets.length === 0) {
+      return void 0;
+    }
+    const workset = manifest.worksets.find((entry) => containsNameToken(query, entry.name));
+    return workset ? resolveWorksetProjects(manifest, workset) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function containsNameToken(query, name) {
+  const escaped = escapeRegExp(name.toLowerCase());
+  return new RegExp(`(^|[^a-z0-9])${escaped}($|[^a-z0-9])`).test(query.toLowerCase());
+}
 async function readSeedManifest(path2) {
   const raw = await (0, import_promises3.readFile)(path2, "utf8");
   const loaded = index_vite_proxy_tmp_default.load(raw);
@@ -7579,7 +7608,33 @@ async function readSeedManifest(path2) {
       uri: readString(loaded.future_monorepo, "uri")
     };
   }
-  return { futureMonorepo, projects, version };
+  let worksets;
+  if (loaded.worksets !== void 0) {
+    if (!Array.isArray(loaded.worksets)) {
+      throw new Error(`Manifest worksets must be an array: ${path2}`);
+    }
+    worksets = loaded.worksets.map((worksetValue) => {
+      if (!isJsonObject(worksetValue)) {
+        throw new Error(`Manifest workset must be an object: ${path2}`);
+      }
+      return {
+        description: readOptionalString(worksetValue, "description"),
+        name: readString(worksetValue, "name"),
+        projects: readStringArray(worksetValue, "projects")
+      };
+    });
+  }
+  return { futureMonorepo, projects, version, worksets };
+}
+function readOptionalString(object, key) {
+  const value = object[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Expected string for ${key}`);
+  }
+  return value;
 }
 function readString(object, key) {
   const value = object[key];
@@ -7960,6 +8015,7 @@ function parseMemoryDocument(uri, content) {
       archivedFrom: headerValue(header, "archived_from"),
       kind,
       project: normalizeOptionalMetadata(headerValue(header, "project") ?? headerValue(header, "repo")),
+      references: headerValues(header, "references"),
       sourceAgentClient: headerValue(header, "source_agent_client") ?? "unknown",
       status,
       supersedes: headerValue(header, "supersedes"),
@@ -8161,6 +8217,24 @@ function recallHygieneNudges(text, options) {
   }
   return [...new Set(nudges)];
 }
+function referencedUrisFromRecords(records, recallOutput) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const record of records) {
+    for (const uri of record.metadata.references ?? []) {
+      if (seen.has(uri) || recallOutput.includes(uri)) {
+        continue;
+      }
+      seen.add(uri);
+      result.push(uri);
+    }
+  }
+  return result;
+}
+function referencedContextExcerpt(body, maxLines) {
+  const lines = body.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(0, maxLines);
+  return lines.map((line) => `  ${line}`).join("\n");
+}
 function activePersonalMemoryUrisFromText(text, user) {
   const userSegment = uriSegment(user);
   const matches = text.matchAll(/viking:\/\/[^\s)]+/g);
@@ -8311,7 +8385,8 @@ function formatMemoryDocument(title, metadata, body) {
     `source_agent_client: ${metadata.sourceAgentClient}`,
     `timestamp: ${metadata.timestamp}`,
     metadata.supersedes ? `supersedes: ${metadata.supersedes}` : void 0,
-    metadata.archivedFrom ? `archived_from: ${metadata.archivedFrom}` : void 0
+    metadata.archivedFrom ? `archived_from: ${metadata.archivedFrom}` : void 0,
+    ...(metadata.references ?? []).map((uri) => `references: ${uri}`)
   ].filter((line) => line !== void 0);
   return [...header, "", body.trim()].join("\n");
 }
@@ -8319,6 +8394,11 @@ function headerValue(header, key) {
   const prefix = `${key}:`;
   return header.split("\n").find((line) => line.startsWith(prefix))?.slice(prefix.length).trim();
 }
+function headerValues(header, key) {
+  const prefix = `${key}:`;
+  const values = header.split("\n").filter((line) => line.startsWith(prefix)).map((line) => line.slice(prefix.length).trim()).filter((value) => value.length > 0);
+  return values.length > 0 ? values : void 0;
+}
 function parseOptionalMemoryKind(value) {
   if (!value) {
     return void 0;
@@ -10303,8 +10383,8 @@ function vikingUriToWorktreeRelative(config, uri, team) {
 }
 async function isRegularFileNoSymlink(path2) {
   try {
-    const stat5 = await (0, import_promises5.lstat)(path2);
-    return stat5.isFile();
+    const stat6 = await (0, import_promises5.lstat)(path2);
+    return stat6.isFile();
   } catch (_err) {
     return false;
   }
@@ -10863,7 +10943,7 @@ function stripPersonalProvenance(content) {
   }
   const cleaned = [];
   for (let index = 0; index < headerEnd; index += 1) {
-    if (/^(?:supersedes|archived_from):\s/.test(lines[index])) {
+    if (/^(?:supersedes|archived_from|references):\s/.test(lines[index])) {
       continue;
     }
     cleaned.push(lines[index]);
@@ -11377,6 +11457,7 @@ async function runRecall(config, options) {
   const inferredUri = options.uri ?? (options.inferScope === false ? void 0 : await inferRecallUri(config, projectQuery));
   const project = await inferProjectFromQuery(config.manifestPath, options.project ?? projectQuery);
   const nodeLimit = options.nodeLimit ? parsePositiveInteger(options.nodeLimit, "node limit") : void 0;
+  const explicitWorkset = options.workset ? await requireWorkset(config.manifestPath, options.workset) : void 0;
   const searchArgs = (scopeUri) => [
     "search",
     query,
@@ -11402,6 +11483,15 @@ async function runRecall(config, options) {
   if (seededUri?.startsWith("viking://") && seededUri !== inferredUri && !options.uri && options.inferScope !== false) {
     passes.push(await recallSearchHits(config, ov, searchArgs(seededUri), { dryRun, includeArchived }));
   }
+  const workset = !options.uri && explicitWorkset ? explicitWorkset : !options.uri && options.inferScope !== false ? await inferWorksetFromQuery(config.manifestPath, projectQuery) : void 0;
+  if (workset && workset.projects.length > 0) {
+    console.log(`Workset scope: ${workset.name} (${workset.projects.map((member) => member.name).join(", ")})`);
+    const alreadyScoped = new Set([inferredUri, seededUri].filter((uri) => uri !== void 0));
+    const worksetScopes = worksetScopeUris(config, workset).filter((uri) => !alreadyScoped.has(uri)).slice(0, MAX_WORKSET_PASSES);
+    for (const scope of worksetScopes) {
+      passes.push(await recallSearchHits(config, ov, searchArgs(scope), { dryRun, includeArchived }));
+    }
+  }
   const recallOutputs = [];
   const exactMatches = await collectExactMemoryMatches(config, ov, query, { dryRun, includeArchived, project });
   const { semanticSection, exactTail } = buildRecallSections(passes, exactMatches, nodeLimit ?? 12);
@@ -11415,8 +11505,45 @@ ${semanticSection}`);
 ${exactTail}`);
     recallOutputs.push(exactTail);
   }
+  const referencedSection = await referencedContextSection(config, recallOutputs.join("\n"));
+  if (referencedSection) {
+    console.log(`
+${referencedSection}`);
+    recallOutputs.push(referencedSection);
+  }
   await printRecallHygieneNudges(config, recallOutputs.join("\n"));
 }
+var MAX_REFERENCED_CONTEXT = 5;
+var REFERENCED_EXCERPT_LINES = 12;
+async function referencedContextSection(config, recallOutput) {
+  const surfacedUris = activePersonalMemoryUrisFromText(recallOutput, config.user);
+  if (surfacedUris.length === 0) {
+    return void 0;
+  }
+  const surfaced = await readMemoryRecordsByUri(config, surfacedUris);
+  const referenced = referencedUrisFromRecords(surfaced, recallOutput);
+  if (referenced.length === 0) {
+    return void 0;
+  }
+  const capped = referenced.slice(0, MAX_REFERENCED_CONTEXT);
+  const records = await readMemoryRecordsByUri(config, capped);
+  const byUri = new Map(records.map((record) => [record.uri, record]));
+  const lines = ["Referenced read-only context (one-way pointers from surfaced memories):"];
+  for (const uri of capped) {
+    const record = byUri.get(uri);
+    if (record) {
+      lines.push(`- ${uri}`, referencedContextExcerpt(record.body, REFERENCED_EXCERPT_LINES));
+    } else {
+      lines.push(`- ${uri} [reference unavailable locally]`);
+    }
+  }
+  if (referenced.length > capped.length) {
+    lines.push(
+      `- \u2026 ${referenced.length - capped.length} more referenced ${referenced.length - capped.length === 1 ? "memory" : "memories"} omitted`
+    );
+  }
+  return lines.join("\n");
+}
 async function recallSearchHits(config, ov, args, options) {
   const jsonArgs = withIdentity(config, [...args, "--output", "json"]);
   console.log(`${options.dryRun ? "Would run" : "Running"}: ${formatShellCommand(ov, jsonArgs)}`);
@@ -11932,8 +12059,8 @@ async function removeVikingResourceWithRetry(ov, config, uri) {
   return false;
 }
 async function vikingResourceExists2(ov, config, uri) {
-  const stat5 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
-  return stat5.exitCode === 0;
+  const stat6 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+  return stat6.exitCode === 0;
 }
 async function ensureDurableMemoryDirectory(ov, config) {
   await ensureMemoryDirectory(ov, config, durableMemoryDirectoryUri(config));
@@ -12000,6 +12127,18 @@ async function legacyLifecycleHandoffCandidates(config, limit) {
 function lifecycleMigrationUri(config, metadata, hash) {
   return `${memoryDirectoryUri(config, metadata)}/legacy-${hash.slice(0, 16)}.md`;
 }
+var MAX_WORKSET_PASSES = 12;
+function worksetScopeUris(config, workset) {
+  const scopes = [];
+  for (const member of workset.projects) {
+    scopes.push(`viking://user/${uriSegment(config.user)}/memories/durable/projects/${uriSegment(member.name)}`);
+    const seeded = trimTrailingSlash(member.uri);
+    if (seeded.startsWith("viking://")) {
+      scopes.push(seeded);
+    }
+  }
+  return [...new Set(scopes)];
+}
 function exactMemoryScopes(config, includeArchived, query, project) {
   return exactMemoryScopeUris({
     agentMemoriesUri: `viking://agent/${uriSegment(config.agentId)}/memories`,
@@ -12062,7 +12201,8 @@ function formatMemoryDocument2(title, metadata, body) {
     `source_agent_client: ${metadata.sourceAgentClient}`,
     `timestamp: ${metadata.timestamp}`,
     metadata.supersedes ? `supersedes: ${metadata.supersedes}` : void 0,
-    metadata.archivedFrom ? `archived_from: ${metadata.archivedFrom}` : void 0
+    metadata.archivedFrom ? `archived_from: ${metadata.archivedFrom}` : void 0,
+    ...(metadata.references ?? []).map((uri) => `references: ${uri}`)
   ].filter((line) => line !== void 0);
   return [...header, "", body.trim()].join("\n");
 }
@@ -12297,9 +12437,25 @@ function isResourceBusy(stderr, stdout2) {
 ${stdout2}`.toLowerCase();
   return output2.includes("resource is busy") || output2.includes("resource is being processed");
 }
+function normalizeReferenceUris(references) {
+  if (!references || references.length === 0) {
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of references) {
+    const uri = raw.trim();
+    if (!uri || seen.has(uri)) {
+      continue;
+    }
+    assertVikingUri(uri);
+    seen.add(uri);
+  }
+  return seen.size > 0 ? [...seen] : void 0;
+}
 async function buildHandoff(options) {
   const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]) ?? getInvocationCwd();
   const branch = await gitValue(["branch", "--show-current"], repoRoot) ?? "unknown";
+  const commit = await gitValue(["rev-parse", "HEAD"], repoRoot) ?? "unknown";
   const status = await gitValue(["status", "--short"], repoRoot) ?? "";
   const diffStat = await gitValue(["diff", "--stat", "HEAD"], repoRoot) ?? "";
   const touchedFiles = await gitTouchedFiles(repoRoot);
@@ -12308,16 +12464,24 @@ async function buildHandoff(options) {
   const metadata = {
     kind: "handoff",
     project: normalizeOptionalMetadata2(options.project) ?? repoName,
+    references: normalizeReferenceUris(options.references),
     sourceAgentClient: options.sourceAgentClient ?? "codex",
     status: "active",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     topic: handoffTopicForBranch(topicBranch, { timestamped: options.timestamped, topic: options.topic })
   };
+  const reviewState = [
+    options.pr ? `pr: ${options.pr}` : void 0,
+    options.issue ? `issue: ${options.issue}` : void 0,
+    options.ci ? `ci: ${options.ci}` : void 0
+  ].filter((line) => line !== void 0);
   const bodyText = [
     `repo: ${repoName}`,
     `repo_path: ${repoRoot}`,
     `branch: ${branch || "unknown"}`,
+    `commit: ${commit}`,
     `task: ${options.task ?? "unspecified"}`,
+    ...reviewState,
     "",
     "files_touched:",
     formatBlock(touchedFiles, "- none"),
@@ -12335,7 +12499,9 @@ async function buildHandoff(options) {
     options.blockers ?? "- none recorded",
     "",
     "next_step:",
-    options.nextStep ?? "- inspect the current repo state and continue from this handoff"
+    options.nextStep ?? "- inspect the current repo state and continue from this handoff",
+    ...options.sessionId ? ["", `session_id: ${options.sessionId}`] : [],
+    ...options.trace ? ["", "trace (auto-captured, heuristic):", options.trace] : []
   ].join("\n");
   return { bodyText, metadata };
 }
@@ -12361,9 +12527,134 @@ function formatBlock(value, emptyValue) {
   return trimmed.split("\n").map((line) => `- ${line}`).join("\n");
 }
 
+// src/trace.ts
+var import_promises7 = require("node:fs/promises");
+var MAX_TRANSCRIPT_BYTES = 4 * 1024 * 1024;
+var MAX_INTENTS = 5;
+var MAX_INTENT_CHARS = 160;
+var MAX_TOOLS = 12;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractText(content) {
+  if (typeof content === "string") {
+    return content.trim() || void 0;
+  }
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const parts = [];
+  for (const part of content) {
+    if (typeof part === "string") {
+      parts.push(part);
+    } else if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+      parts.push(part.text);
+    }
+  }
+  const joined = parts.join(" ").trim();
+  return joined || void 0;
+}
+function extractToolNames(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const names = [];
+  for (const part of content) {
+    if (isRecord(part) && part.type === "tool_use" && typeof part.name === "string") {
+      names.push(part.name);
+    }
+  }
+  return names;
+}
+function truncate(value, max) {
+  const oneLine = value.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}\u2026` : oneLine;
+}
+async function distillTrace(transcriptPath) {
+  const raw = await readTranscriptTail(transcriptPath);
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!raw.trim()) {
+    return void 0;
+  }
+  let events = 0;
+  const tools = /* @__PURE__ */ new Set();
+  const intents = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) {
+      continue;
+    }
+    events += 1;
+    const message = isRecord(parsed.message) ? parsed.message : parsed;
+    const role = typeof message.role === "string" ? message.role : typeof parsed.type === "string" ? parsed.type : void 0;
+    if (role === "user") {
+      const text = extractText(message.content);
+      if (text) {
+        const scrubbed = applyScrubber(text, { redact: true });
+        if (scrubbed.blocker) {
+          return void 0;
+        }
+        intents.push(truncate(scrubbed.cleaned, MAX_INTENT_CHARS));
+      }
+    } else if (role === "assistant") {
+      for (const name of extractToolNames(message.content)) {
+        tools.add(name);
+      }
+    }
+  }
+  if (events === 0) {
+    return void 0;
+  }
+  const lines = [`- ${events} transcript events`];
+  if (tools.size > 0) {
+    lines.push(`- tools used: ${[...tools].slice(0, MAX_TOOLS).join(", ")}`);
+  }
+  const recentIntents = intents.slice(-MAX_INTENTS);
+  if (recentIntents.length > 0) {
+    lines.push("- recent intents:");
+    for (const intent of recentIntents) {
+      lines.push(`  - ${intent}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function readTranscriptTail(transcriptPath) {
+  try {
+    const { size } = await (0, import_promises7.stat)(transcriptPath);
+    if (size === 0) {
+      return void 0;
+    }
+    if (size <= MAX_TRANSCRIPT_BYTES) {
+      return await (0, import_promises7.readFile)(transcriptPath, "utf8");
+    }
+    const start = size - MAX_TRANSCRIPT_BYTES;
+    const buffer = Buffer.alloc(MAX_TRANSCRIPT_BYTES);
+    const file = await (0, import_promises7.open)(transcriptPath, "r");
+    try {
+      const { bytesRead } = await file.read(buffer, 0, MAX_TRANSCRIPT_BYTES, start);
+      return buffer.subarray(0, bytesRead).toString("utf8").replace(/^[^\n]*(?:\n|$)/, "");
+    } finally {
+      await file.close();
+    }
+  } catch {
+    return void 0;
+  }
+}
+
 // src/update-check.ts
 var import_node_child_process3 = require("node:child_process");
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_path9 = require("node:path");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var NPM_LATEST_URL = "https://registry.npmjs.org/threadnote/latest";
@@ -12417,7 +12708,7 @@ function isCacheFresh(cache) {
 }
 async function readUpdateCache(cachePath) {
   try {
-    const raw = await (0, import_promises7.readFile)(cachePath, "utf8");
+    const raw = await (0, import_promises8.readFile)(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
       return void 0;
@@ -12429,8 +12720,8 @@ async function readUpdateCache(cachePath) {
 }
 async function writeUpdateCache(cachePath, contents) {
   try {
-    await (0, import_promises7.mkdir)((0, import_node_path9.dirname)(cachePath), { recursive: true });
-    await (0, import_promises7.writeFile)(cachePath, `${JSON.stringify(contents)}
+    await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(cachePath), { recursive: true });
+    await (0, import_promises8.writeFile)(cachePath, `${JSON.stringify(contents)}
 `, { encoding: "utf8", mode: 384 });
   } catch {
   }
@@ -12502,7 +12793,7 @@ async function runHooksInstall(config, agent, options) {
 }
 async function runClaudeHooksInstall(options) {
   const path2 = expandPath(CLAUDE_SETTINGS_PATH);
-  const existingRaw = await exists(path2) ? await (0, import_promises8.readFile)(path2, "utf8") : "{}";
+  const existingRaw = await exists(path2) ? await (0, import_promises9.readFile)(path2, "utf8") : "{}";
   const parsed = parseJsonConfigObject(existingRaw) ?? {};
   const next = options.remove ? withoutThreadnoteHooks(parsed) : withThreadnoteHooks(parsed);
   const before = JSON.stringify(parsed);
@@ -12519,11 +12810,11 @@ async function runClaudeHooksInstall(options) {
     console.log("\nRe-run with --apply to actually modify the file.");
     return;
   }
-  await (0, import_promises8.mkdir)((0, import_node_path11.dirname)(path2), { recursive: true });
+  await (0, import_promises9.mkdir)((0, import_node_path11.dirname)(path2), { recursive: true });
   const serialized = `${JSON.stringify(next, void 0, 2)}
 `;
-  await (0, import_promises8.writeFile)(path2, serialized, { encoding: "utf8", mode: 384 });
-  await (0, import_promises8.chmod)(path2, 384);
+  await (0, import_promises9.writeFile)(path2, serialized, { encoding: "utf8", mode: 384 });
+  await (0, import_promises9.chmod)(path2, 384);
   console.log(`${options.remove ? "Removed" : "Installed"} threadnote-managed Claude hooks.`);
 }
 function withThreadnoteHooks(input2) {
@@ -12601,7 +12892,7 @@ async function hasManagedClaudeHooks() {
   if (!await exists(path2)) {
     return false;
   }
-  const raw = await (0, import_promises8.readFile)(path2, "utf8");
+  const raw = await (0, import_promises9.readFile)(path2, "utf8");
   const parsed = parseJsonConfigObject(raw);
   if (!parsed || !isJsonObject(parsed.hooks)) {
     return false;
@@ -12619,15 +12910,18 @@ async function hasManagedClaudeHooks() {
 async function runPreCompactHook(config, options = {}) {
   try {
     const project = await resolveRepoName() ?? "general";
+    const { sessionId, trace } = await captureTraceContext();
     await runHandoff(config, {
       blockers: "- none recorded",
       dryRun: options.dryRun === true,
       nextStep: "Continue from this auto-snapshot. A manual `threadnote handoff` will produce a richer write-up if you have more context.",
       project,
+      sessionId,
       sourceAgentClient: "claude",
       task: "Auto-snapshot captured at Claude PreCompact (deterministic safety net before context compaction).",
       tests: "- not recorded (auto-snapshot)",
-      topic: HOOK_AUTO_PRECOMPACT_TOPIC
+      topic: HOOK_AUTO_PRECOMPACT_TOPIC,
+      trace
     });
   } catch (err) {
     process.stderr.write(
@@ -12660,6 +12954,76 @@ async function runSessionStartHook(config, options = {}) {
     );
   }
 }
+async function captureTraceContext() {
+  try {
+    const payload = await readHookPayload();
+    if (!payload) {
+      return {};
+    }
+    const rawTrace = payload.transcriptPath ? await distillTrace(payload.transcriptPath) : void 0;
+    return { sessionId: payload.sessionId, trace: rawTrace ? scrubTrace(rawTrace) : void 0 };
+  } catch {
+    return {};
+  }
+}
+function scrubTrace(trace) {
+  const result = applyScrubber(trace, { redact: true });
+  return result.blocker ? void 0 : result.cleaned;
+}
+async function readHookPayload() {
+  if (process.stdin.isTTY) {
+    return void 0;
+  }
+  const raw = await readStdinWithTimeout(1500, 512 * 1024);
+  if (!raw.trim()) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isJsonObject(parsed)) {
+    return void 0;
+  }
+  return {
+    sessionId: typeof parsed.session_id === "string" ? parsed.session_id : void 0,
+    transcriptPath: typeof parsed.transcript_path === "string" ? parsed.transcript_path : void 0
+  };
+}
+function readStdinWithTimeout(timeoutMs, maxBytes) {
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    let data = "";
+    let settled = false;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      stdin.off("data", onData);
+      stdin.off("end", finish);
+      stdin.off("error", finish);
+      clearTimeout(timer);
+      stdin.pause();
+      resolve2(data);
+    };
+    const onData = (chunk) => {
+      data += chunk;
+      if (data.length >= maxBytes) {
+        data = data.slice(0, maxBytes);
+        finish();
+      }
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    stdin.on("end", finish);
+    stdin.on("error", finish);
+    stdin.resume();
+  });
+}
 async function emitUpdateBannerIfOutdated(config) {
   try {
     const result = await checkForThreadnoteUpdate({
@@ -12688,8 +13052,144 @@ async function emitUpdateBannerIfOutdated(config) {
 }
 
 // src/seeding.ts
-var import_promises9 = require("node:fs/promises");
+var import_promises11 = require("node:fs/promises");
+var import_node_path13 = require("node:path");
+
+// src/graph.ts
+var import_promises10 = require("node:fs/promises");
 var import_node_path12 = require("node:path");
+async function readIfExists(path2) {
+  try {
+    return await (0, import_promises10.readFile)(path2, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function parsePackageJson(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const object = parsed;
+  const dependencies = /* @__PURE__ */ new Set();
+  for (const key of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+    const section = object[key];
+    if (section && typeof section === "object" && !Array.isArray(section)) {
+      for (const name of Object.keys(section)) {
+        dependencies.add(name);
+      }
+    }
+  }
+  return { dependencies: [...dependencies], publishedName: typeof object.name === "string" ? object.name : void 0 };
+}
+function parseGoMod(content) {
+  const dependencies = /* @__PURE__ */ new Set();
+  let publishedName;
+  let inRequireBlock = false;
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.replace(/\/\/.*$/, "").trim();
+    if (!line) {
+      continue;
+    }
+    const moduleMatch = /^module\s+(\S+)/.exec(line);
+    if (moduleMatch) {
+      publishedName = moduleMatch[1];
+      continue;
+    }
+    if (/^require\s*\($/.test(line)) {
+      inRequireBlock = true;
+      continue;
+    }
+    if (inRequireBlock) {
+      if (line === ")") {
+        inRequireBlock = false;
+        continue;
+      }
+      const blockMatch = /^(\S+)\s+v\S+/.exec(line);
+      if (blockMatch) {
+        dependencies.add(blockMatch[1]);
+      }
+      continue;
+    }
+    const singleMatch = /^require\s+(\S+)\s+v\S+/.exec(line);
+    if (singleMatch) {
+      dependencies.add(singleMatch[1]);
+    }
+  }
+  return { dependencies: [...dependencies], publishedName };
+}
+async function extractDependencyFacts(projectRoot) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const ecosystems = [];
+  const manifestFiles = [];
+  let publishedName;
+  const packageJson = await readIfExists((0, import_node_path12.join)(projectRoot, "package.json"));
+  if (packageJson !== void 0) {
+    const parsed = parsePackageJson(packageJson);
+    if (parsed) {
+      manifestFiles.push("package.json");
+      ecosystems.push("npm");
+      publishedName = publishedName ?? parsed.publishedName;
+      for (const dependency of parsed.dependencies) {
+        dependencies.add(dependency);
+      }
+    }
+  }
+  const goMod = await readIfExists((0, import_node_path12.join)(projectRoot, "go.mod"));
+  if (goMod !== void 0) {
+    const parsed = parseGoMod(goMod);
+    manifestFiles.push("go.mod");
+    ecosystems.push("go");
+    publishedName = publishedName ?? parsed.publishedName;
+    for (const dependency of parsed.dependencies) {
+      dependencies.add(dependency);
+    }
+  }
+  return { dependencies: [...dependencies].sort(), ecosystems, manifestFiles, publishedName };
+}
+function buildGraphDocument(params) {
+  const { externalCount, facts, internalEdges, projectName } = params;
+  const lines = [
+    `# ${projectName} \u2014 dependency facts`,
+    "",
+    "Auto-generated by `threadnote seed --graph` from declarative manifest files. A static snapshot of package metadata, not a live dependency graph.",
+    "",
+    `provides: ${facts.publishedName ?? "(none declared)"}`,
+    `ecosystems: ${facts.ecosystems.length > 0 ? facts.ecosystems.join(", ") : "(none detected)"}`,
+    "",
+    "manifests:",
+    ...facts.manifestFiles.length > 0 ? facts.manifestFiles.map((file) => `- ${file}`) : ["- (none)"],
+    "",
+    "depends_on (within this workspace):",
+    ...internalEdges.length > 0 ? internalEdges.map((edge) => `- [[${edge.project}]] (via ${edge.dependency})`) : ["- (no in-workspace dependencies detected)"],
+    "",
+    `external dependencies: ${externalCount} declared`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function resolveGraphEdges(projectName, dependencies, projectByPublishedName) {
+  const internalEdges = [];
+  const seenTargets = /* @__PURE__ */ new Set();
+  let externalCount = 0;
+  for (const dependency of dependencies) {
+    const target = projectByPublishedName.get(dependency.toLowerCase());
+    if (target && target !== projectName && !seenTargets.has(target)) {
+      seenTargets.add(target);
+      internalEdges.push({ dependency, project: target });
+    } else if (!target) {
+      externalCount += 1;
+    }
+  }
+  return { externalCount, internalEdges };
+}
+
+// src/seeding.ts
 function parseSeedWatchIntervalMinutes(rawValue) {
   if (rawValue === void 0) {
     return void 0;
@@ -12708,7 +13208,7 @@ async function runSeed(config, options) {
   const ignorePatterns = await loadIgnorePatterns();
   const ov = await openVikingCliForMode(options.dryRun === true);
   const watchIntervalMinutes = parseSeedWatchIntervalMinutes(process.env[SEED_WATCH_INTERVAL_ENV]);
-  const statePath = (0, import_node_path12.join)(config.agentContextHome, SEED_STATE_FILE);
+  const statePath = (0, import_node_path13.join)(config.agentContextHome, SEED_STATE_FILE);
   const state = options.force === true ? { files: {}, version: 1 } : await readSeedState(statePath);
   const projects = filterProjects(manifest.projects, options.only);
   let importedCount = 0;
@@ -12738,8 +13238,6 @@ async function runSeed(config, options) {
         importPath,
         "--to",
         candidate.destinationUri,
-        "--reason",
-        seedResourceReason(candidate),
         ...seedWatchArgs({
           watchIntervalMinutes,
           importedOriginal: importPath === candidate.filePath,
@@ -12760,6 +13258,58 @@ async function runSeed(config, options) {
   console.log(
     `Seed complete: ${importedCount} candidate(s), ${unchangedCount} unchanged, ${skippedCount} skipped for safety.`
   );
+  if (options.graph === true) {
+    await seedDependencyGraphs(config, ov, manifest, projects, options.dryRun === true);
+  }
+}
+async function seedDependencyGraphs(config, ov, manifest, targetProjects, dryRun) {
+  const factsByProject = /* @__PURE__ */ new Map();
+  for (const project of manifest.projects) {
+    const projectRoot = expandPath(project.path);
+    if (!await exists(projectRoot)) {
+      continue;
+    }
+    factsByProject.set(project.name, await extractDependencyFacts(projectRoot));
+  }
+  const projectByPublishedName = /* @__PURE__ */ new Map();
+  for (const [name, facts] of factsByProject) {
+    if (facts.publishedName) {
+      projectByPublishedName.set(facts.publishedName.toLowerCase(), name);
+    }
+  }
+  let written = 0;
+  let skipped = 0;
+  for (const project of targetProjects) {
+    const facts = factsByProject.get(project.name);
+    if (!facts || facts.manifestFiles.length === 0) {
+      continue;
+    }
+    const { externalCount, internalEdges } = resolveGraphEdges(project.name, facts.dependencies, projectByPublishedName);
+    const document = buildGraphDocument({ externalCount, facts, internalEdges, projectName: project.name });
+    const secretMatches = detectSecretMatches(document);
+    if (secretMatches.length > 0) {
+      skipped += 1;
+      console.log(
+        `SKIP ${project.name}/.graph.md: possible secret (${secretMatches.slice(0, MAX_SECRET_MATCHES_TO_PRINT).join(", ")})`
+      );
+      continue;
+    }
+    const destinationUri = `${trimTrailingSlash(project.uri)}/.graph.md`;
+    if (dryRun) {
+      console.log(`Would seed dependency facts: ${destinationUri} (${internalEdges.length} in-workspace edge(s))`);
+      written += 1;
+      continue;
+    }
+    const graphPath = (0, import_node_path13.join)(config.agentContextHome, "graph", graphCacheFileName(project.name));
+    await ensureDirectory((0, import_node_path13.dirname)(graphPath), false);
+    await (0, import_promises11.writeFile)(graphPath, document, { encoding: "utf8", mode: 384 });
+    await (0, import_promises11.chmod)(graphPath, 384);
+    await maybeRun(false, ov, withIdentity(config, ["add-resource", graphPath, "--to", destinationUri, "--wait"]));
+    written += 1;
+  }
+  console.log(
+    `Dependency graph seed complete: ${written} .graph.md resource(s)${skipped > 0 ? `, ${skipped} skipped for safety` : ""}.`
+  );
 }
 function filterProjects(projects, only) {
   if (!only || only.length === 0) {
@@ -12776,7 +13326,7 @@ function filterProjects(projects, only) {
 }
 async function statSeedFile(path2) {
   try {
-    const result = await (0, import_promises9.stat)(path2);
+    const result = await (0, import_promises11.stat)(path2);
     return { mtimeMs: result.mtimeMs, size: result.size };
   } catch (_err) {
     return void 0;
@@ -12784,7 +13334,7 @@ async function statSeedFile(path2) {
 }
 async function readSeedState(path2) {
   try {
-    const raw = await (0, import_promises9.readFile)(path2, "utf8");
+    const raw = await (0, import_promises11.readFile)(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || !isJsonObject(parsed.files)) {
       return { files: {}, version: 1 };
@@ -12801,13 +13351,13 @@ async function readSeedState(path2) {
   }
 }
 async function writeSeedState(path2, state) {
-  await ensureDirectory((0, import_node_path12.dirname)(path2), false);
-  await (0, import_promises9.writeFile)(path2, `${JSON.stringify(state, void 0, 2)}
+  await ensureDirectory((0, import_node_path13.dirname)(path2), false);
+  await (0, import_promises11.writeFile)(path2, `${JSON.stringify(state, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function runInitManifest(config, options) {
   const manifestPath = expandPath(
-    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path12.join)(config.agentContextHome, USER_MANIFEST_NAME)
+    options.path ?? process.env.THREADNOTE_MANIFEST ?? (0, import_node_path13.join)(config.agentContextHome, USER_MANIFEST_NAME)
   );
   const repoInputs = options.repo && options.repo.length > 0 ? options.repo : [getInvocationCwd()];
   const existingManifest = options.replace === true || !await exists(manifestPath) ? void 0 : await readSeedManifest(manifestPath);
@@ -12844,20 +13394,58 @@ async function runInitManifest(config, options) {
       uri: existingManifest.futureMonorepo.uri
     };
   }
+  if (existingManifest?.worksets) {
+    outputManifest.worksets = existingManifest.worksets.map((workset) => ({
+      name: workset.name,
+      ...workset.description !== void 0 ? { description: workset.description } : {},
+      projects: [...workset.projects]
+    }));
+  }
   const output2 = index_vite_proxy_tmp_default.dump(outputManifest, { lineWidth: 120, noRefs: true });
   if (options.dryRun === true) {
     console.log(`# Would write ${manifestPath}`);
     console.log(output2.trimEnd());
     return;
   }
-  await ensureDirectory((0, import_node_path12.dirname)(manifestPath), false);
-  await (0, import_promises9.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
-  await (0, import_promises9.chmod)(manifestPath, 384);
+  await ensureDirectory((0, import_node_path13.dirname)(manifestPath), false);
+  await (0, import_promises11.writeFile)(manifestPath, output2, { encoding: "utf8", mode: 384 });
+  await (0, import_promises11.chmod)(manifestPath, 384);
   console.log(`Wrote manifest: ${manifestPath}`);
   console.log("Seed with:");
   console.log("  threadnote seed --dry-run");
   console.log("  threadnote seed");
 }
+async function runWorksetList(config) {
+  const manifest = await readSeedManifest(config.manifestPath);
+  const worksets = manifest.worksets ?? [];
+  if (worksets.length === 0) {
+    console.log(
+      "No worksets defined. Add a top-level `worksets:` list to the seed manifest to group related projects."
+    );
+    return;
+  }
+  console.log(`Worksets (${worksets.length}):`);
+  for (const workset of worksets) {
+    const summary = workset.description ? ` \u2014 ${workset.description}` : "";
+    console.log(`- ${workset.name} (${workset.projects.length} project(s))${summary}`);
+  }
+}
+async function runWorksetShow(config, name) {
+  const manifest = await readSeedManifest(config.manifestPath);
+  const workset = manifest.worksets?.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
+  if (!workset) {
+    throw new Error(`No workset named "${name}" in ${config.manifestPath}.`);
+  }
+  console.log(`Workset: ${workset.name}`);
+  if (workset.description) {
+    console.log(workset.description);
+  }
+  console.log("Projects:");
+  for (const memberName of workset.projects) {
+    const project = manifest.projects.find((entry) => entry.name.toLowerCase() === memberName.toLowerCase());
+    console.log(project ? `- ${project.name} (${project.uri})` : `- ${memberName} [not found in manifest projects]`);
+  }
+}
 async function runSeedSkills(config, options) {
   const ov = await openVikingCliForMode(options.dryRun === true);
   const catalogItems = await collectSkillCandidates(config);
@@ -12873,15 +13461,7 @@ async function runSeedSkills(config, options) {
       console.log(`SKIP command in native skill mode: ${skill.filePath}`);
       continue;
     }
-    const args = nativeMode ? ["add-skill", skill.filePath, "--wait"] : [
-      "add-resource",
-      skill.filePath,
-      "--to",
-      skillResourceUri(skill),
-      "--reason",
-      skillResourceReason(skill),
-      "--wait"
-    ];
+    const args = nativeMode ? ["add-skill", skill.filePath, "--wait"] : ["add-resource", skill.filePath, "--to", skillResourceUri(skill), "--wait"];
     await maybeRun(options.dryRun === true, ov, withIdentity(config, args));
   }
   console.log(
@@ -12898,13 +13478,13 @@ async function resolveRepoRoot(repoInput) {
 async function projectIdentity(path2) {
   const expanded = expandPath(path2);
   try {
-    return await (0, import_promises9.realpath)(expanded);
+    return await (0, import_promises11.realpath)(expanded);
   } catch (_err) {
     return expanded;
   }
 }
 function projectManifestForRepo(repoRoot, existingProjects) {
-  const baseName = uriSegment((0, import_node_path12.basename)(repoRoot));
+  const baseName = uriSegment((0, import_node_path13.basename)(repoRoot));
   const usedNames = new Set(existingProjects.map((project) => project.name));
   const usedUris = new Set(existingProjects.map((project) => project.uri));
   let name = baseName;
@@ -12926,7 +13506,7 @@ async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
   for (const pattern of project.seed) {
     const files = await resolveProjectPattern(projectRoot, pattern);
     for (const filePath of files) {
-      const relativePath = toPosixPath((0, import_node_path12.relative)(projectRoot, filePath));
+      const relativePath = toPosixPath((0, import_node_path13.relative)(projectRoot, filePath));
       if (seen.has(relativePath) || matchesIgnore(relativePath, ignorePatterns)) {
         continue;
       }
@@ -12944,20 +13524,20 @@ async function collectSeedCandidates(project, projectRoot, ignorePatterns) {
 async function resolveProjectPattern(projectRoot, pattern) {
   const normalizedPattern = toPosixPath(pattern);
   if (!hasGlob(normalizedPattern)) {
-    const filePath = (0, import_node_path12.join)(projectRoot, normalizedPattern);
+    const filePath = (0, import_node_path13.join)(projectRoot, normalizedPattern);
     return await isFile(filePath) ? [filePath] : [];
   }
   const globBase = getGlobBase(normalizedPattern);
-  const basePath = (0, import_node_path12.join)(projectRoot, globBase);
+  const basePath = (0, import_node_path13.join)(projectRoot, globBase);
   if (!await exists(basePath)) {
     return [];
   }
   const regex = globToRegExp(normalizedPattern);
   const files = await walkFiles(basePath);
-  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path12.relative)(projectRoot, filePath))));
+  return files.filter((filePath) => regex.test(toPosixPath((0, import_node_path13.relative)(projectRoot, filePath))));
 }
 async function prepareSeedFile(config, candidate, dryRun) {
-  const content = await (0, import_promises9.readFile)(candidate.filePath, "utf8");
+  const content = await (0, import_promises11.readFile)(candidate.filePath, "utf8");
   const redactedContent = shouldRedactPath(candidate.relativePath) ? redactContent(candidate.relativePath, content) : content;
   const secretMatches = detectSecretMatches(redactedContent);
   if (secretMatches.length > 0) {
@@ -12969,23 +13549,18 @@ async function prepareSeedFile(config, candidate, dryRun) {
   if (redactedContent === content) {
     return candidate.filePath;
   }
-  const redactedPath = (0, import_node_path12.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
+  const redactedPath = (0, import_node_path13.join)(config.agentContextHome, "redacted", candidate.projectName, candidate.relativePath);
   if (dryRun) {
     console.log(`Would write redacted copy: ${redactedPath}`);
     return redactedPath;
   }
-  await ensureDirectory((0, import_node_path12.dirname)(redactedPath), false);
-  await (0, import_promises9.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
-  await (0, import_promises9.chmod)(redactedPath, 384);
+  await ensureDirectory((0, import_node_path13.dirname)(redactedPath), false);
+  await (0, import_promises11.writeFile)(redactedPath, redactedContent, { encoding: "utf8", mode: 384 });
+  await (0, import_promises11.chmod)(redactedPath, 384);
   return redactedPath;
 }
-function seedResourceReason(candidate) {
-  return `Project guidance for ${candidate.projectName}: ${candidate.relativePath}`;
-}
-function skillResourceReason(skill) {
-  return `${skill.kind === "command" ? "Agent command" : "Agent skill"} catalog item from ${skill.source}: ${(0, import_node_path12.basename)(
-    skill.filePath
-  )}`;
+function graphCacheFileName(projectName) {
+  return `${uriSegment(projectName)}-${sha256(projectName).slice(0, 8)}.graph.md`;
 }
 async function collectSkillCandidates(config) {
   const sources = [
@@ -13016,7 +13591,7 @@ async function collectSkillCandidates(config) {
   for (const source of sources) {
     const files = await resolveAbsolutePattern(expandPath(source.pattern));
     for (const filePath of files) {
-      const content = await (0, import_promises9.readFile)(filePath, "utf8");
+      const content = await (0, import_promises11.readFile)(filePath, "utf8");
       const matches = detectSecretMatches(content);
       if (matches.length > 0) {
         console.log(`SKIP skill with possible secret: ${filePath}`);
@@ -13050,16 +13625,16 @@ function skillResourceUri(skill) {
   return `viking://resources/agent-skills/${uriSegment(skill.source)}/${skillResourceName(skill)}-${skill.hash.slice(0, 12)}.md`;
 }
 function skillResourceName(skill) {
-  const fileName = (0, import_node_path12.basename)(skill.filePath);
+  const fileName = (0, import_node_path13.basename)(skill.filePath);
   if (fileName.toLowerCase() === "skill.md") {
-    return uriSegment((0, import_node_path12.basename)((0, import_node_path12.dirname)(skill.filePath)));
+    return uriSegment((0, import_node_path13.basename)((0, import_node_path13.dirname)(skill.filePath)));
   }
   const extensionIndex = fileName.lastIndexOf(".");
   const stem = extensionIndex > 0 ? fileName.slice(0, extensionIndex) : fileName;
   return uriSegment(stem);
 }
 async function loadIgnorePatterns() {
-  const raw = await (0, import_promises9.readFile)((0, import_node_path12.join)(toolRoot(), ".threadnoteignore"), "utf8");
+  const raw = await (0, import_promises11.readFile)((0, import_node_path13.join)(toolRoot(), ".threadnoteignore"), "utf8");
   return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function matchesIgnore(relativePath, patterns) {
@@ -13132,18 +13707,18 @@ function detectSecretMatches(content) {
 // src/lifecycle.ts
 var import_node_child_process4 = require("node:child_process");
 var import_node_fs7 = require("node:fs");
-var import_promises12 = require("node:fs/promises");
+var import_promises14 = require("node:fs/promises");
 var import_node_os6 = require("node:os");
-var import_node_path14 = require("node:path");
+var import_node_path15 = require("node:path");
 var import_node_process4 = require("node:process");
-var import_promises13 = require("node:readline/promises");
+var import_promises15 = require("node:readline/promises");
 
 // src/update.ts
 var import_node_fs6 = require("node:fs");
-var import_promises10 = require("node:fs/promises");
+var import_promises12 = require("node:fs/promises");
 var import_node_os5 = require("node:os");
-var import_node_path13 = require("node:path");
-var import_promises11 = require("node:readline/promises");
+var import_node_path14 = require("node:path");
+var import_promises13 = require("node:readline/promises");
 var import_node_process3 = require("node:process");
 
 // src/release_notes.ts
@@ -13497,14 +14072,14 @@ async function waitForOpenVikingPortClosed(config, timeoutMs) {
   return false;
 }
 function launchAgentPlistPath() {
-  return (0, import_node_path13.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", "io.threadnote.openviking.plist");
+  return (0, import_node_path14.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", "io.threadnote.openviking.plist");
 }
 async function isLaunchAgentInstalled() {
   if (process.platform !== "darwin") {
     return false;
   }
   try {
-    await (0, import_promises10.access)(launchAgentPlistPath(), import_node_fs6.constants.F_OK);
+    await (0, import_promises12.access)(launchAgentPlistPath(), import_node_fs6.constants.F_OK);
     return true;
   } catch (_err) {
     return false;
@@ -13575,11 +14150,11 @@ async function readFreshCache(config, registry) {
 }
 async function writeUpdateCache2(config, cache) {
   await ensureDirectory(config.agentContextHome, false);
-  await (0, import_promises10.writeFile)(updateCachePath(config), `${JSON.stringify(cache, null, 2)}
+  await (0, import_promises12.writeFile)(updateCachePath(config), `${JSON.stringify(cache, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function updateCachePath(config) {
-  return (0, import_node_path13.join)(config.agentContextHome, "update-check.json");
+  return (0, import_node_path14.join)(config.agentContextHome, "update-check.json");
 }
 async function runApplicablePostUpdateMigrations(config, options) {
   const state = await readPostUpdateState(config);
@@ -13643,7 +14218,7 @@ async function applicablePostUpdateMigrations(config, options) {
   return applicable;
 }
 async function readPostUpdateMigrations() {
-  const raw = await readFileIfExists((0, import_node_path13.join)(toolRoot(), "config", POST_UPDATE_MIGRATIONS_FILE));
+  const raw = await readFileIfExists((0, import_node_path14.join)(toolRoot(), "config", POST_UPDATE_MIGRATIONS_FILE));
   if (!raw) {
     return [];
   }
@@ -13682,7 +14257,7 @@ function printPostUpdateMigration(migration) {
   }
 }
 async function confirmPostUpdateMigration(prompt, defaultYes = false) {
-  const readline = (0, import_promises11.createInterface)({ input: import_node_process3.stdin, output: import_node_process3.stdout });
+  const readline = (0, import_promises13.createInterface)({ input: import_node_process3.stdin, output: import_node_process3.stdout });
   try {
     const answer = (await readline.question(prompt)).trim().toLowerCase();
     if (answer === "") {
@@ -13717,11 +14292,11 @@ async function readPostUpdateState(config) {
 }
 async function writePostUpdateState(config, state) {
   await ensureDirectory(config.agentContextHome, false);
-  await (0, import_promises10.writeFile)(postUpdateStatePath(config), `${JSON.stringify(state, null, 2)}
+  await (0, import_promises12.writeFile)(postUpdateStatePath(config), `${JSON.stringify(state, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function postUpdateStatePath(config) {
-  return (0, import_node_path13.join)(config.agentContextHome, POST_UPDATE_STATE_FILE);
+  return (0, import_node_path14.join)(config.agentContextHome, POST_UPDATE_STATE_FILE);
 }
 async function resolveUpdateRuntime(runtime) {
   if (runtime !== "auto") {
@@ -13751,14 +14326,14 @@ async function runtimeThreadnoteBin(runtime) {
   if (runtime === "npm") {
     const result = await runCommand("npm", ["prefix", "--global"], { allowFailure: true });
     const prefix = result.stdout.trim();
-    return prefix ? (0, import_node_path13.join)(prefix, "bin", NPM_PACKAGE_NAME) : void 0;
+    return prefix ? (0, import_node_path14.join)(prefix, "bin", NPM_PACKAGE_NAME) : void 0;
   }
   if (runtime === "bun") {
     const result = await runCommand("bun", ["pm", "bin", "-g"], { allowFailure: true });
     const binDir = result.stdout.trim();
-    return binDir ? (0, import_node_path13.join)(binDir, NPM_PACKAGE_NAME) : void 0;
+    return binDir ? (0, import_node_path14.join)(binDir, NPM_PACKAGE_NAME) : void 0;
   }
-  return (0, import_node_path13.join)(process.env.DENO_INSTALL ?? (0, import_node_path13.join)((0, import_node_os5.homedir)(), ".deno"), "bin", NPM_PACKAGE_NAME);
+  return (0, import_node_path14.join)(process.env.DENO_INSTALL ?? (0, import_node_path14.join)((0, import_node_os5.homedir)(), ".deno"), "bin", NPM_PACKAGE_NAME);
 }
 function updatePackageCommand(runtime, registry) {
   if (runtime === "npm") {
@@ -13831,9 +14406,9 @@ async function collectDoctorChecks(config, options = {}) {
   checks.push(await manifestCheck(config.manifestPath));
   checks.push(await recallIndexFreshnessCheck(config));
   checks.push(await memoryProjectConsistencyCheck(config));
-  checks.push(await fileCheck((0, import_node_path14.join)(toolRoot(), ".threadnoteignore"), "ignore file"));
-  checks.push(await fileCheck((0, import_node_path14.join)(toolRoot(), "config", "ov.conf.template.json"), "server config template"));
-  checks.push(await fileCheck((0, import_node_path14.join)(toolRoot(), "config", "ovcli.conf.template.json"), "cli config template"));
+  checks.push(await fileCheck((0, import_node_path15.join)(toolRoot(), ".threadnoteignore"), "ignore file"));
+  checks.push(await fileCheck((0, import_node_path15.join)(toolRoot(), "config", "ov.conf.template.json"), "server config template"));
+  checks.push(await fileCheck((0, import_node_path15.join)(toolRoot(), "config", "ovcli.conf.template.json"), "cli config template"));
   checks.push(await healthCheck(config));
   return checks;
 }
@@ -13841,9 +14416,9 @@ async function runInstall(config, options) {
   const repairInvalidConfigs = options.repairInvalidConfigs === true;
   const dryRun = options.dryRun === true;
   await ensureDirectory(config.agentContextHome, dryRun);
-  await ensureDirectory((0, import_node_path14.join)(config.agentContextHome, "logs"), dryRun);
-  await ensureDirectory((0, import_node_path14.join)(config.agentContextHome, "redacted"), dryRun);
-  await ensureDirectory((0, import_node_path14.join)(config.agentContextHome, "mcp"), dryRun);
+  await ensureDirectory((0, import_node_path15.join)(config.agentContextHome, "logs"), dryRun);
+  await ensureDirectory((0, import_node_path15.join)(config.agentContextHome, "redacted"), dryRun);
+  await ensureDirectory((0, import_node_path15.join)(config.agentContextHome, "mcp"), dryRun);
   await installCommandShim(dryRun);
   await installUserAgentInstructions(dryRun);
   const serverPath = await findOpenVikingServer();
@@ -13888,17 +14463,17 @@ async function runInstall(config, options) {
   }
   await writeTemplateIfMissing({
     config,
-    destinationPath: (0, import_node_path14.join)(config.agentContextHome, "ov.conf"),
+    destinationPath: (0, import_node_path15.join)(config.agentContextHome, "ov.conf"),
     dryRun,
     shouldRepair: (content) => shouldRepairOpenVikingConfig(content, config) || repairInvalidConfigs && parseJsonConfigObject(content) === void 0,
-    templatePath: (0, import_node_path14.join)(toolRoot(), "config", "ov.conf.template.json")
+    templatePath: (0, import_node_path15.join)(toolRoot(), "config", "ov.conf.template.json")
   });
   await writeTemplateIfMissing({
     config,
-    destinationPath: (0, import_node_path14.join)(config.agentContextHome, "ovcli.conf"),
+    destinationPath: (0, import_node_path15.join)(config.agentContextHome, "ovcli.conf"),
     dryRun,
     shouldRepair: (content) => shouldRepairLegacyOvCliConfig(content) || repairInvalidConfigs && parseJsonConfigObject(content) === void 0,
-    templatePath: (0, import_node_path14.join)(toolRoot(), "config", "ovcli.conf.template.json")
+    templatePath: (0, import_node_path15.join)(toolRoot(), "config", "ovcli.conf.template.json")
   });
   await configureOpenVikingCliLanguage(config, dryRun);
   if (options.start !== false) {
@@ -13955,7 +14530,7 @@ async function runUninstall(config, options) {
   }
   console.log("Uninstalling local Threadnote setup.");
   await runStop(config, { dryRun });
-  await removePathIfExists((0, import_node_path14.join)(config.agentContextHome, "openviking-server.pid"), "pid file", dryRun);
+  await removePathIfExists((0, import_node_path15.join)(config.agentContextHome, "openviking-server.pid"), "pid file", dryRun);
   await removeLaunchAgent(dryRun);
   await removeMcpConfigs(options.mcp ?? "available", dryRun);
   await removeMcpSnippets(config, dryRun);
@@ -14012,16 +14587,16 @@ async function repairManifest(config, dryRun) {
     console.log(output2.trimEnd());
     return;
   }
-  await ensureDirectory((0, import_node_path14.dirname)(config.manifestPath), false);
+  await ensureDirectory((0, import_node_path15.dirname)(config.manifestPath), false);
   const currentContent = await readFileIfExists(config.manifestPath);
   if (currentContent !== void 0) {
     const backupPath = `${config.manifestPath}.legacy-${safeTimestamp()}`;
-    await (0, import_promises12.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
-    await (0, import_promises12.chmod)(backupPath, 384);
+    await (0, import_promises14.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
+    await (0, import_promises14.chmod)(backupPath, 384);
     console.log(`Backup: ${backupPath}`);
   }
-  await (0, import_promises12.writeFile)(config.manifestPath, output2, { encoding: "utf8", mode: 384 });
-  await (0, import_promises12.chmod)(config.manifestPath, 384);
+  await (0, import_promises14.writeFile)(config.manifestPath, output2, { encoding: "utf8", mode: 384 });
+  await (0, import_promises14.chmod)(config.manifestPath, 384);
   console.log(`Wrote replacement manifest: ${config.manifestPath}`);
 }
 async function repairRecallIndex(config, dryRun) {
@@ -14096,7 +14671,7 @@ async function findOpenVikingServer() {
     return onPath;
   }
   for (const candidateDir of await openVikingServerCandidateDirs()) {
-    const candidate = (0, import_node_path14.join)(candidateDir, OPENVIKING_SERVER_COMMAND);
+    const candidate = (0, import_node_path15.join)(candidateDir, OPENVIKING_SERVER_COMMAND);
     if (await isExecutable(candidate)) {
       return candidate;
     }
@@ -14142,7 +14717,7 @@ async function maybePrintOpenVikingPathHint(serverPath) {
   if (onPath) {
     return;
   }
-  const binDir = (0, import_node_path14.dirname)(serverPath);
+  const binDir = (0, import_node_path15.dirname)(serverPath);
   const rcHint = suggestedShellRc(process.env.SHELL, (0, import_node_os6.platform)());
   console.log(
     `Note: ${serverPath} is installed but ${binDir} is not on this shell's PATH. Add \`export PATH="${binDir}:$PATH"\` to ${rcHint} so other tools can find openviking-server.`
@@ -14186,7 +14761,7 @@ async function runStart(config, options) {
     );
   }
   const logPath = openVikingLogPath(config);
-  await ensureDirectory((0, import_node_path14.dirname)(logPath), false);
+  await ensureDirectory((0, import_node_path15.dirname)(logPath), false);
   if (options.foreground === true) {
     const result = await runInteractive(server, args);
     process.exitCode = result;
@@ -14195,7 +14770,7 @@ async function runStart(config, options) {
   const logFd = (0, import_node_fs7.openSync)(logPath, "a");
   const child = spawnDetachedServerWithLog(server, args, logFd);
   child.unref();
-  await (0, import_promises12.writeFile)((0, import_node_path14.join)(config.agentContextHome, "openviking-server.pid"), `${child.pid}
+  await (0, import_promises14.writeFile)((0, import_node_path15.join)(config.agentContextHome, "openviking-server.pid"), `${child.pid}
 `, "utf8");
   const health = await waitForOpenVikingHealth(
     config,
@@ -14232,7 +14807,7 @@ async function runStop(config, options) {
       console.log(`No LaunchAgent found: ${launchAgentPath}`);
     }
   }
-  const pidPath = (0, import_node_path14.join)(config.agentContextHome, "openviking-server.pid");
+  const pidPath = (0, import_node_path15.join)(config.agentContextHome, "openviking-server.pid");
   const pidText = await readFileIfExists(pidPath);
   if (!pidText) {
     console.log("No pid file found for detached OpenViking server.");
@@ -14278,7 +14853,7 @@ async function openVikingServerCheck() {
   }
   const result = await runCommand(executable, ["--help"], { allowFailure: true });
   const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
-  const detail = onPath ? executable : `${executable} (found outside PATH; add ${(0, import_node_path14.dirname)(executable)} to PATH)`;
+  const detail = onPath ? executable : `${executable} (found outside PATH; add ${(0, import_node_path15.dirname)(executable)} to PATH)`;
   return {
     name,
     status: result.exitCode === 0 ? "ok" : "warn",
@@ -14319,7 +14894,7 @@ async function openVikingCliCheck() {
   }
   const result = await runCommand(executable, ["--help"], { allowFailure: true });
   const onPath = await findExecutable(["ov", "openviking"]);
-  const detail = onPath ? executable : `${executable} (found outside PATH; add ${(0, import_node_path14.dirname)(executable)} to PATH)`;
+  const detail = onPath ? executable : `${executable} (found outside PATH; add ${(0, import_node_path15.dirname)(executable)} to PATH)`;
   return {
     name: "openviking cli",
     status: result.exitCode === 0 ? "ok" : "warn",
@@ -14412,7 +14987,7 @@ async function pythonSystemCertificatesCheck() {
   };
 }
 async function commandShimCheck() {
-  const shimPath = (0, import_node_path14.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
+  const shimPath = (0, import_node_path15.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
   const content = await readFileIfExists(shimPath);
   if (content === void 0) {
     return { name: "threadnote shim", status: "warn", detail: `${shimPath} missing; repair will create it` };
@@ -14478,11 +15053,11 @@ async function hasPythonModule(serverPath, moduleName) {
 async function siblingPythonForExecutable(executablePath) {
   let resolvedPath;
   try {
-    resolvedPath = await (0, import_promises12.realpath)(executablePath);
+    resolvedPath = await (0, import_promises14.realpath)(executablePath);
   } catch (_err) {
     return void 0;
   }
-  const pythonPath = (0, import_node_path14.join)((0, import_node_path14.dirname)(resolvedPath), "python");
+  const pythonPath = (0, import_node_path15.join)((0, import_node_path15.dirname)(resolvedPath), "python");
   return await exists(pythonPath) ? pythonPath : void 0;
 }
 async function manifestCheck(path2) {
@@ -14525,7 +15100,7 @@ async function recallIndexFreshnessCheck(config) {
 }
 async function memoryProjectConsistencyCheck(config) {
   const name = "memory project consistency";
-  const memoriesRoot = (0, import_node_path14.join)(
+  const memoriesRoot = (0, import_node_path15.join)(
     config.agentContextHome,
     "data",
     "viking",
@@ -14537,7 +15112,7 @@ async function memoryProjectConsistencyCheck(config) {
   try {
     let entries;
     try {
-      entries = await (0, import_promises12.readdir)(memoriesRoot, { recursive: true });
+      entries = await (0, import_promises14.readdir)(memoriesRoot, { recursive: true });
     } catch {
       return { name, status: "ok", detail: "no memories directory yet" };
     }
@@ -14547,14 +15122,14 @@ async function memoryProjectConsistencyCheck(config) {
       if (!entry.endsWith(".md") || isSummarySidecarUri(entry)) {
         continue;
       }
-      const uri = `viking://user/${uriSegment(config.user)}/memories/${entry.split(import_node_path14.sep).join("/")}`;
+      const uri = `viking://user/${uriSegment(config.user)}/memories/${entry.split(import_node_path15.sep).join("/")}`;
       const pathProject = memoryUriProjectSegment(uri);
       if (!pathProject) {
         continue;
       }
       let content;
       try {
-        content = await (0, import_promises12.readFile)((0, import_node_path14.join)(memoriesRoot, entry), "utf8");
+        content = await (0, import_promises14.readFile)((0, import_node_path15.join)(memoriesRoot, entry), "utf8");
       } catch {
         continue;
       }
@@ -14809,7 +15384,7 @@ async function offerToInstallUv() {
     );
     return false;
   }
-  const readline = (0, import_promises13.createInterface)({ input: import_node_process4.stdin, output: import_node_process4.stdout });
+  const readline = (0, import_promises15.createInterface)({ input: import_node_process4.stdin, output: import_node_process4.stdout });
   let answer;
   try {
     answer = (await readline.question(
@@ -14967,38 +15542,38 @@ function printInstallNextSteps(options) {
 }
 async function writeTemplateIfMissing(options) {
   if (await exists(options.destinationPath)) {
-    const currentContent = await (0, import_promises12.readFile)(options.destinationPath, "utf8");
+    const currentContent = await (0, import_promises14.readFile)(options.destinationPath, "utf8");
     if (options.shouldRepair?.(currentContent) !== true) {
       console.log(`Already exists: ${options.destinationPath}`);
       return;
     }
-    const rendered2 = renderTemplate(await (0, import_promises12.readFile)(options.templatePath, "utf8"), options.config);
+    const rendered2 = renderTemplate(await (0, import_promises14.readFile)(options.templatePath, "utf8"), options.config);
     if (options.dryRun) {
       console.log(`Would repair generated config: ${options.destinationPath}`);
       return;
     }
     const backupPath = `${options.destinationPath}.legacy-${safeTimestamp()}`;
-    await (0, import_promises12.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
-    await (0, import_promises12.chmod)(backupPath, 384);
-    await (0, import_promises12.writeFile)(options.destinationPath, rendered2, { encoding: "utf8", mode: 384 });
-    await (0, import_promises12.chmod)(options.destinationPath, 384);
+    await (0, import_promises14.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
+    await (0, import_promises14.chmod)(backupPath, 384);
+    await (0, import_promises14.writeFile)(options.destinationPath, rendered2, { encoding: "utf8", mode: 384 });
+    await (0, import_promises14.chmod)(options.destinationPath, 384);
     console.log(`Repaired generated config: ${options.destinationPath}`);
     console.log(`Backup: ${backupPath}`);
     return;
   }
-  const rendered = renderTemplate(await (0, import_promises12.readFile)(options.templatePath, "utf8"), options.config);
+  const rendered = renderTemplate(await (0, import_promises14.readFile)(options.templatePath, "utf8"), options.config);
   if (options.dryRun) {
     console.log(`Would write ${options.destinationPath}`);
     return;
   }
-  await ensureDirectory((0, import_node_path14.dirname)(options.destinationPath), false);
-  await (0, import_promises12.writeFile)(options.destinationPath, rendered, { encoding: "utf8", mode: 384 });
-  await (0, import_promises12.chmod)(options.destinationPath, 384);
+  await ensureDirectory((0, import_node_path15.dirname)(options.destinationPath), false);
+  await (0, import_promises14.writeFile)(options.destinationPath, rendered, { encoding: "utf8", mode: 384 });
+  await (0, import_promises14.chmod)(options.destinationPath, 384);
   console.log(`Wrote ${options.destinationPath}`);
 }
 async function installCommandShim(dryRun) {
   const binDir = expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin");
-  const shimPath = (0, import_node_path14.join)(binDir, "threadnote");
+  const shimPath = (0, import_node_path15.join)(binDir, "threadnote");
   const existingContent = await readFileIfExists(shimPath);
   if (existingContent && !isManagedCommandShim(existingContent)) {
     console.log(`WARN not overwriting existing command shim: ${shimPath}`);
@@ -15014,12 +15589,12 @@ async function installCommandShim(dryRun) {
     return;
   }
   await ensureDirectory(binDir, false);
-  await (0, import_promises12.writeFile)(shimPath, content, { encoding: "utf8", mode: 493 });
-  await (0, import_promises12.chmod)(shimPath, 493);
+  await (0, import_promises14.writeFile)(shimPath, content, { encoding: "utf8", mode: 493 });
+  await (0, import_promises14.chmod)(shimPath, 493);
   console.log(`Wrote command shim: ${shimPath}`);
 }
 async function removeCommandShim(dryRun) {
-  const shimPath = (0, import_node_path14.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
+  const shimPath = (0, import_node_path15.join)(expandPath(process.env.THREADNOTE_BIN_DIR ?? "~/.local/bin"), "threadnote");
   const content = await readFileIfExists(shimPath);
   if (content === void 0) {
     console.log(`Already absent: ${shimPath}`);
@@ -15053,8 +15628,8 @@ async function installUserAgentInstructions(dryRun) {
       console.log(currentContent === void 0 ? `Would write ${targetPath}` : `Would update ${targetPath}`);
       continue;
     }
-    await ensureDirectory((0, import_node_path14.dirname)(targetPath), false);
-    await (0, import_promises12.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
+    await ensureDirectory((0, import_node_path15.dirname)(targetPath), false);
+    await (0, import_promises14.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
     console.log(currentContent === void 0 ? `Wrote ${targetPath}` : `Updated ${targetPath}`);
   }
 }
@@ -15091,7 +15666,7 @@ async function removeUserAgentInstructions(dryRun) {
       console.log(`Would update ${targetPath}`);
       continue;
     }
-    await (0, import_promises12.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
+    await (0, import_promises14.writeFile)(targetPath, nextContent, { encoding: "utf8", mode: 420 });
     console.log(`Updated ${targetPath}`);
   }
 }
@@ -15111,7 +15686,7 @@ async function renderUserAgentInstructions(target) {
   ].join("\n");
 }
 async function renderUserAgentInstructionsBlock() {
-  const instructions = (await (0, import_promises12.readFile)((0, import_node_path14.join)(toolRoot(), "docs", "agent-instructions.md"), "utf8")).trim();
+  const instructions = (await (0, import_promises14.readFile)((0, import_node_path15.join)(toolRoot(), "docs", "agent-instructions.md"), "utf8")).trim();
   return `${USER_INSTRUCTIONS_START_MARKER}
 ${instructions}
 ${USER_INSTRUCTIONS_END_MARKER}`;
@@ -15195,9 +15770,9 @@ async function installLaunchAgent(config, dryRun) {
       `Cannot install LaunchAgent: ${OPENVIKING_SERVER_COMMAND} was not found in PATH, uv tool bin dir, $UV_TOOL_BIN_DIR, or ~/.local/bin. Run \`threadnote install\` first.`
     );
   }
-  const source = (0, import_node_path14.join)(toolRoot(), "config", "launchd", `${LAUNCHD_LABEL}.plist.template`);
+  const source = (0, import_node_path15.join)(toolRoot(), "config", "launchd", `${LAUNCHD_LABEL}.plist.template`);
   const destination = expandPath(`~/Library/LaunchAgents/${LAUNCHD_LABEL}.plist`);
-  const rendered = renderTemplate(await (0, import_promises12.readFile)(source, "utf8"), config, {
+  const rendered = renderTemplate(await (0, import_promises14.readFile)(source, "utf8"), config, {
     OPENVIKING_SERVER_PATH: resolvedServer ?? OPENVIKING_SERVER_COMMAND
   });
   if (dryRun) {
@@ -15209,9 +15784,9 @@ async function installLaunchAgent(config, dryRun) {
     console.log(`Would run: launchctl start ${LAUNCHD_LABEL}`);
     return;
   }
-  await ensureDirectory((0, import_node_path14.dirname)(destination), false);
-  await ensureDirectory((0, import_node_path14.dirname)(openVikingLogPath(config)), false);
-  await (0, import_promises12.writeFile)(destination, rendered, "utf8");
+  await ensureDirectory((0, import_node_path15.dirname)(destination), false);
+  await ensureDirectory((0, import_node_path15.dirname)(openVikingLogPath(config)), false);
+  await (0, import_promises14.writeFile)(destination, rendered, "utf8");
   await maybeRun(false, "launchctl", ["unload", destination], { allowFailure: true });
   await maybeRun(false, "launchctl", ["load", destination]);
   await maybeRun(false, "launchctl", ["start", LAUNCHD_LABEL]);
@@ -15278,7 +15853,7 @@ function isGeneratedLocalPilotConfig(parsed, config) {
   if (typeof parsed.default_user !== "string") {
     return false;
   }
-  if (!isJsonObject(parsed.storage) || parsed.storage.workspace !== (0, import_node_path14.join)(config.agentContextHome, "data")) {
+  if (!isJsonObject(parsed.storage) || parsed.storage.workspace !== (0, import_node_path15.join)(config.agentContextHome, "data")) {
     return false;
   }
   return isJsonObject(parsed.server) && parsed.server.host === config.host && String(parsed.server.port) === String(config.port);
@@ -15340,9 +15915,9 @@ function printWhatsNew(whatsNew) {
 // src/manager.ts
 var import_node_http2 = require("node:http");
 var import_node_crypto2 = require("node:crypto");
-var import_promises14 = require("node:fs/promises");
+var import_promises16 = require("node:fs/promises");
 var import_node_os7 = require("node:os");
-var import_node_path15 = require("node:path");
+var import_node_path16 = require("node:path");
 var STATIC_FILES = {
   "/": { contentType: "text/html; charset=utf-8", path: "index.html" },
   "/index.html": { contentType: "text/html; charset=utf-8", path: "index.html" },
@@ -15413,18 +15988,18 @@ async function readManagedMemory(config, uri) {
   if (!path2) {
     throw new Error(`Manager can only read current-user memory URIs: ${uri}`);
   }
-  const [content, pathStat] = await Promise.all([(0, import_promises14.readFile)(path2, "utf8"), (0, import_promises14.stat)(path2)]);
-  const relativePath = (0, import_node_path15.relative)(localMemoriesRoot(config), path2).split(import_node_path15.sep).join("/");
+  const [content, pathStat] = await Promise.all([(0, import_promises16.readFile)(path2, "utf8"), (0, import_promises16.stat)(path2)]);
+  const relativePath = (0, import_node_path16.relative)(localMemoriesRoot(config), path2).split(import_node_path16.sep).join("/");
   const record = parseMemoryDocument(uri, content);
   return {
     content,
     node: {
       isDir: false,
       isShared: isInSharedNamespace(config, uri),
-      isSystem: isSystemMemoryName(path2.split(import_node_path15.sep).at(-1) ?? ""),
+      isSystem: isSystemMemoryName(path2.split(import_node_path16.sep).at(-1) ?? ""),
       metadata: record?.metadata,
       modTime: pathStat.mtime.toISOString(),
-      name: path2.split(import_node_path15.sep).at(-1) ?? uri,
+      name: path2.split(import_node_path16.sep).at(-1) ?? uri,
       relativePath,
       sharedTeam: sharedTeamNameForUri(config, uri),
       size: pathStat.size,
@@ -15712,7 +16287,7 @@ async function handleRequest(context, request, response) {
 }
 async function serveStatic(context, url, response) {
   const file = STATIC_FILES[url.pathname] ?? STATIC_FILES["/"];
-  const content = await (0, import_promises14.readFile)((0, import_node_path15.join)(toolRoot(), file.root ?? "manager", file.path));
+  const content = await (0, import_promises16.readFile)((0, import_node_path16.join)(toolRoot(), file.root ?? "manager", file.path));
   const headers = { "content-type": file.contentType };
   if (file.root !== "docs") {
     headers["cache-control"] = "no-store";
@@ -15721,11 +16296,11 @@ async function serveStatic(context, url, response) {
   response.end(content);
 }
 async function readTree(config, path2, uri, relativePath, options = {}) {
-  const pathStat = await (0, import_promises14.stat)(path2);
+  const pathStat = await (0, import_promises16.stat)(path2);
   const name = relativePath ? relativePath.split("/").at(-1) ?? relativePath : options.rootName ?? "memories";
   const isDir = pathStat.isDirectory();
   if (!isDir) {
-    const record = options.parseMemoryDocuments === false ? void 0 : parseMemoryDocument(uri, await (0, import_promises14.readFile)(path2, "utf8").catch(() => ""));
+    const record = options.parseMemoryDocuments === false ? void 0 : parseMemoryDocument(uri, await (0, import_promises16.readFile)(path2, "utf8").catch(() => ""));
     return {
       isDir: false,
       isShared: isInSharedNamespace(config, uri),
@@ -15739,13 +16314,13 @@ async function readTree(config, path2, uri, relativePath, options = {}) {
       uri
     };
   }
-  const entries = await (0, import_promises14.readdir)(path2, { withFileTypes: true });
+  const entries = await (0, import_promises16.readdir)(path2, { withFileTypes: true });
   const children = await Promise.all(
     entries.sort(
       (left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) || left.name.localeCompare(right.name)
     ).map((entry) => {
       const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-      return readTree(config, (0, import_node_path15.join)(path2, entry.name), `${uri}/${entry.name}`, childRelative, options);
+      return readTree(config, (0, import_node_path16.join)(path2, entry.name), `${uri}/${entry.name}`, childRelative, options);
     })
   );
   return {
@@ -15919,27 +16494,27 @@ async function removeManagedFolder(config, uri) {
   if (!path2) {
     throw new Error(`Manager can only remove current-user memory folders: ${uri}`);
   }
-  const pathStat = await (0, import_promises14.stat)(path2);
+  const pathStat = await (0, import_promises16.stat)(path2);
   if (!pathStat.isDirectory()) {
     throw new Error(`Not a folder: ${uri}`);
   }
-  const relativePath = (0, import_node_path15.relative)(localMemoriesRoot(config), path2);
-  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path15.sep).includes("..")) {
+  const relativePath = (0, import_node_path16.relative)(localMemoriesRoot(config), path2);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path16.sep).includes("..")) {
     throw new Error("Refusing to remove a folder outside the memories tree.");
   }
   const fileUris = await fileUrisUnderFolder(config, path2);
   for (const fileUri of fileUris) {
     await runForget(config, fileUri, {});
   }
-  await (0, import_promises14.rm)(path2, { force: true, recursive: true });
+  await (0, import_promises16.rm)(path2, { force: true, recursive: true });
   console.log(`Removed folder: ${uri}`);
   console.log(`Forgot ${fileUris.length} file${fileUris.length === 1 ? "" : "s"}.`);
 }
 async function fileUrisUnderFolder(config, folderPath) {
-  const entries = await (0, import_promises14.readdir)(folderPath, { withFileTypes: true });
+  const entries = await (0, import_promises16.readdir)(folderPath, { withFileTypes: true });
   const uris = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const path2 = (0, import_node_path15.join)(folderPath, entry.name);
+    const path2 = (0, import_node_path16.join)(folderPath, entry.name);
     if (entry.isDirectory()) {
       uris.push(...await fileUrisUnderFolder(config, path2));
     } else if (entry.isFile()) {
@@ -16037,11 +16612,11 @@ async function runConsolidationAgent(agent, sources) {
     throw new Error(`${agent} executable was not found.`);
   }
   const prompt = consolidationPrompt(sources);
-  const stagingDir = await (0, import_promises14.mkdtemp)((0, import_node_path15.join)((0, import_node_os7.tmpdir)(), "threadnote-consolidate-"));
-  const promptPath = (0, import_node_path15.join)(stagingDir, "prompt.txt");
+  const stagingDir = await (0, import_promises16.mkdtemp)((0, import_node_path16.join)((0, import_node_os7.tmpdir)(), "threadnote-consolidate-"));
+  const promptPath = (0, import_node_path16.join)(stagingDir, "prompt.txt");
   try {
-    await (0, import_promises14.writeFile)(promptPath, prompt, { encoding: "utf8", mode: 384 });
-    await (0, import_promises14.chmod)(promptPath, 384);
+    await (0, import_promises16.writeFile)(promptPath, prompt, { encoding: "utf8", mode: 384 });
+    await (0, import_promises16.chmod)(promptPath, 384);
     const script = consolidationAgentScript(agent, executable);
     const result = await runCommand("sh", ["-lc", script, "threadnote-consolidate", promptPath], {
       allowFailure: true,
@@ -16057,7 +16632,7 @@ async function runConsolidationAgent(agent, sources) {
     }
     return draft;
   } finally {
-    await (0, import_promises14.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises16.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 function consolidationAgentScript(agent, executable) {
@@ -16195,10 +16770,10 @@ function memoryDirectoryUri2(config, kind, status, projectSegment) {
   }
 }
 function localMemoriesRoot(config) {
-  return (0, import_node_path15.join)(config.agentContextHome, "data", "viking", config.account, "user", uriSegment(config.user), "memories");
+  return (0, import_node_path16.join)(config.agentContextHome, "data", "viking", config.account, "user", uriSegment(config.user), "memories");
 }
 function localResourcesRoot(config) {
-  return (0, import_node_path15.join)(config.agentContextHome, "data", "viking", config.account, "resources");
+  return (0, import_node_path16.join)(config.agentContextHome, "data", "viking", config.account, "resources");
 }
 function localPathForMemoryUri(config, uri) {
   const prefix = `viking://user/${uriSegment(config.user)}/memories`;
@@ -16210,17 +16785,17 @@ function localPathForMemoryUri(config, uri) {
   if (segments.some((segment) => segment === "." || segment === "..")) {
     return void 0;
   }
-  return (0, import_node_path15.join)(localMemoriesRoot(config), ...segments);
+  return (0, import_node_path16.join)(localMemoriesRoot(config), ...segments);
 }
 function isMissingPathError(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 function localPathToMemoryUri(config, path2) {
-  const relativePath = (0, import_node_path15.relative)(localMemoriesRoot(config), path2);
-  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path15.sep).includes("..")) {
+  const relativePath = (0, import_node_path16.relative)(localMemoriesRoot(config), path2);
+  if (!relativePath || relativePath.startsWith("..") || relativePath.split(import_node_path16.sep).includes("..")) {
     throw new Error(`Path is outside the memories tree: ${path2}`);
   }
-  return `viking://user/${uriSegment(config.user)}/memories/${relativePath.split(import_node_path15.sep).join("/")}`;
+  return `viking://user/${uriSegment(config.user)}/memories/${relativePath.split(import_node_path16.sep).join("/")}`;
 }
 async function ensurePersonalDirectoryChain2(config, ov, directoryUri) {
   const prefix = "viking://";
@@ -16414,7 +16989,10 @@ async function main() {
   ).option("--preserve-memories", "Preserve THREADNOTE_HOME and OpenViking memories (default)").option("--erase-memories", "Delete THREADNOTE_HOME, including all OpenViking memories").action(async (options) => {
     await runUninstall(getRuntimeConfig(program2), options);
   });
-  program2.command("seed").description("Seed curated context from the manifest; never indexes whole repos by default").option("--dry-run", "Print files and ov commands without importing").option("--force", "Re-upload every candidate even if mtime+size match the recorded state").option("--manifest <path>", "Manifest path for this seed run").option(
+  program2.command("seed").description("Seed curated context from the manifest; never indexes whole repos by default").option("--dry-run", "Print files and ov commands without importing").option("--force", "Re-upload every candidate even if mtime+size match the recorded state").option(
+    "--graph",
+    "Also seed a per-project .graph.md dependency-facts resource (package.json/go.mod), with [[project]] cross-repo edges"
+  ).option("--manifest <path>", "Manifest path for this seed run").option(
     "--only <project>",
     "Restrict seeding to one or more manifest projects by name; repeat for multiple",
     collectOption,
@@ -16460,9 +17038,19 @@ async function main() {
   program2.command("migrate-lifecycle").description("Move clear legacy handoff memories into lifecycle-aware archive paths").option("--apply", "Perform the migration; without this, prints a dry run").option("--dry-run", "Print migration actions without writing or removing memories").option("--limit <count>", "Maximum number of legacy handoffs to migrate").action(async (options) => {
     await runMigrateLifecycle(getRuntimeConfig(program2), options);
   });
-  program2.command("recall").description("Search shared OpenViking context").requiredOption("--query <query>", "Search query").option("--dry-run", "Print ov command without searching").option("--include-archived", "Include archived memories in recall results").option("-n, --node-limit <count>", "Maximum number of search results").option("--no-infer-scope", "Disable query-based scope inference").option("--project <name>", "Prioritize a project: add a scoped pass over its memories alongside the global search").option("--threshold <score>", "Minimum relevance score 0-1 (default 0.45); lower to broaden when recall is empty").option("--uri <uri>", "Restrict search to a viking:// URI").action(async (options) => {
+  program2.command("recall").description("Search shared OpenViking context").requiredOption("--query <query>", "Search query").option("--dry-run", "Print ov command without searching").option("--include-archived", "Include archived memories in recall results").option("-n, --node-limit <count>", "Maximum number of search results").option("--no-infer-scope", "Disable query-based scope inference").option("--project <name>", "Prioritize a project: add a scoped pass over its memories alongside the global search").option("--threshold <score>", "Minimum relevance score 0-1 (default 0.45); lower to broaden when recall is empty").option("--uri <uri>", "Restrict search to a viking:// URI").option(
+    "--workset <name>",
+    "Recall across a named seed-manifest workset (a set of related repos) as one working set"
+  ).action(async (options) => {
     await runRecall(getRuntimeConfig(program2), options);
   });
+  const workset = program2.command("workset").description("Inspect seed-manifest worksets (named sets of related repos recalled as one working set)");
+  workset.command("list").description("List worksets defined in the seed manifest").action(async () => {
+    await runWorksetList(getRuntimeConfig(program2));
+  });
+  workset.command("show").description("Show the member projects of a workset").argument("<name>", "Workset name").action(async (name) => {
+    await runWorksetShow(getRuntimeConfig(program2), name);
+  });
   program2.command("compact").description("Plan or apply scoped memory hygiene for active personal memories").requiredOption("--project <name>", "Project/repo namespace to inspect").option("--apply", "Apply the compact plan; without this, prints a dry run").option("--dry-run", "Print the compact plan without changing anything").option("--kind <kind>", "durable, handoff, or incident", parseCompactKind).option("--topic <name>", "Stable topic name to inspect").action(async (options) => {
     await runCompact(getRuntimeConfig(program2), options);
   });
@@ -16472,8 +17060,13 @@ async function main() {
   program2.command("list").alias("ls").description("List a viking:// directory").argument("[uri]", "viking:// URI to list", "viking://").option("-a, --all", "Show hidden files such as .abstract.md and .overview.md").option("--dry-run", "Print ov command without listing").option("-n, --node-limit <count>", "Maximum number of nodes to list").option("-r, --recursive", "List subdirectories recursively").option("-s, --simple", "Print only paths").action(async (uri, options) => {
     await runList(getRuntimeConfig(program2), uri, options);
   });
-  program2.command("handoff").description("Capture current repo state as a durable cross-agent handoff memory").option("--blockers <text>", "Known blockers").option("--dry-run", "Print handoff without storing").option("--next-step <text>", "Suggested next step").option("--project <name>", "Project/repo namespace; defaults to current repo basename").option("--replace <uri>", "Supersede an existing viking:// memory after the new handoff is stored").option("--source-agent-client <name>", "codex, claude, cursor, copilot, or another client name", "codex").option("--task <text>", "Current task summary").option("--tests <text>", "Tests or checks run").option("--timestamped", "Store a historical timestamped handoff instead of updating the current branch handoff").option("--topic <name>", "Stable topic name; active handoffs with the same project/topic update one file").action(async (options) => {
-    await runHandoff(getRuntimeConfig(program2), options);
+  program2.command("handoff").description("Capture current repo state as a durable cross-agent handoff memory").option("--blockers <text>", "Known blockers").option("--ci <text>", "Captured CI status snapshot (free text; not a live status board)").option("--dry-run", "Print handoff without storing").option("--issue <text>", "Related issue reference (number or URL)").option("--next-step <text>", "Suggested next step").option("--pr <text>", "Related pull request reference (number or URL)").option("--project <name>", "Project/repo namespace; defaults to current repo basename").option(
+    "--reference <uri>",
+    "viking:// memory to record as one-way read-only prior context; repeat for multiple",
+    collectOption,
+    []
+  ).option("--replace <uri>", "Supersede an existing viking:// memory after the new handoff is stored").option("--source-agent-client <name>", "codex, claude, cursor, copilot, or another client name", "codex").option("--task <text>", "Current task summary").option("--tests <text>", "Tests or checks run").option("--timestamped", "Store a historical timestamped handoff instead of updating the current branch handoff").option("--topic <name>", "Stable topic name; active handoffs with the same project/topic update one file").action(async (options) => {
+    await runHandoff(getRuntimeConfig(program2), { ...options, references: options.reference });
   });
   program2.command("archive").description("Move a memory into the archived lifecycle tree, then remove the original after the archive is stored").argument("<uri>", "viking:// memory URI to archive").option("--dry-run", "Print archive content and ov commands without changing anything").option("--kind <kind>", "durable, handoff, incident, preference, or smoke", parseMemoryKind).option("--project <name>", "Override inferred project/repo namespace").option("--topic <name>", "Override inferred topic").action(async (uri, options) => {
     await runArchive(getRuntimeConfig(program2), uri, options);