threadnote 1.4.5 → 1.6.0

package/dist/threadnote.cjs

@@ -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();
@@ -4202,14 +4202,19 @@ function exactRecallTerms(query) {
     "after",
     "agent",
     "anything",
+    "been",
     "branch",
     "case",
     "current",
+    "does",
     "durable",
     "find",
     "feature",
     "features",
+    "from",
     "handoff",
+    "have",
+    "into",
     "issue",
     "issues",
     "knowledge",
@@ -4223,11 +4228,22 @@ function exactRecallTerms(query) {
     "related",
     "search",
     "stored",
+    "than",
+    "that",
+    "them",
+    "then",
+    "they",
     "this",
     "the",
+    "were",
+    "what",
+    "when",
+    "which",
+    "while",
     "with",
     "workspace",
-    "worktree"
+    "worktree",
+    "your"
   ]);
   const seen = /* @__PURE__ */ new Set();
   const terms = [];
@@ -4261,6 +4277,34 @@ function exactRecallScopeIntents(query) {
 function isSummarySidecarUri(uri) {
   return /\.(?:overview|abstract)\.md(?:#|$)/.test(uri);
 }
+function isAgentArtifactPackUri(uri) {
+  return /\/agent-artifacts\/packs\//.test(uri);
+}
+function isExcludedRecallUri(uri) {
+  return isSummarySidecarUri(uri) || isAgentArtifactPackUri(uri);
+}
+function memoryUriProjectSegment(uri) {
+  const marker = "/memories/";
+  const at = uri.indexOf(marker);
+  if (at < 0) {
+    return void 0;
+  }
+  let segments = stripAnchor(uri).slice(at + marker.length).split("/").filter(Boolean);
+  if (segments[0] === "shared") {
+    segments = segments.slice(2);
+  }
+  const [kind, , project, ...rest] = segments;
+  if ((kind === "durable" || kind === "handoffs" || kind === "incidents") && project && rest.length > 0) {
+    return project;
+  }
+  return void 0;
+}
+function memoryFrontmatterField(content, field) {
+  const blankLine = content.indexOf("\n\n");
+  const header = blankLine < 0 ? content : content.slice(0, blankLine);
+  const match = header.match(new RegExp(`^${escapeRegExp(field)}:[ \\t]*(.+)$`, "m"));
+  return match?.[1]?.trim() || void 0;
+}
 function grepUrisFromJson(output2) {
   const start = output2.search(/^\{/m);
   if (start < 0) {
@@ -4275,7 +4319,7 @@ function grepUrisFromJson(output2) {
     }
     const uris = [];
     for (const match of matches) {
-      if (isJsonObject(match) && typeof match.uri === "string" && !isSummarySidecarUri(match.uri)) {
+      if (isJsonObject(match) && typeof match.uri === "string" && !isExcludedRecallUri(match.uri)) {
         uris.push(match.uri);
       }
     }
@@ -4317,7 +4361,7 @@ function parseRecallHits(output2, options = {}) {
         continue;
       }
       for (const item of items) {
-        if (!isJsonObject(item) || typeof item.uri !== "string" || isSummarySidecarUri(item.uri)) {
+        if (!isJsonObject(item) || typeof item.uri !== "string" || isExcludedRecallUri(item.uri)) {
           continue;
         }
         if (options.includeArchived !== true && isArchivedMemoryUri(item.uri)) {
@@ -4376,6 +4420,9 @@ ${hit.snippet}`;
   return kept;
 }
 function categoryForUri(uri) {
+  if (uri.includes("/agent-artifacts/")) {
+    return "skills";
+  }
   if (uri.includes("/memories/")) {
     return "memories";
   }
@@ -4390,6 +4437,36 @@ function contextTypeForCategory(category) {
   }
   return category === "skills" ? "skill" : "resource";
 }
+var RECALL_EXACT_SLUG_BONUS = 4;
+function uriSlug(uri) {
+  const withoutExtension = stripAnchor(uri).replace(/\.[a-z0-9]+$/i, "");
+  return withoutExtension.slice(withoutExtension.lastIndexOf("/") + 1).toLowerCase();
+}
+function exactTermDocumentFrequency(matches) {
+  const frequency = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    for (const term of new Set(match.terms.map((term2) => term2.toLowerCase()))) {
+      frequency.set(term, (frequency.get(term) ?? 0) + 1);
+    }
+  }
+  return frequency;
+}
+function slugNamesTerm(slug, term) {
+  return new RegExp(`(^|[^a-z0-9])${escapeRegExp(term)}([^a-z0-9]|$)`).test(slug);
+}
+function exactMatchStrength(hit, documentFrequency) {
+  if (!hit.exactTerms?.length) {
+    return 0;
+  }
+  const slug = uriSlug(hit.uri);
+  let strength = 0;
+  for (const term of hit.exactTerms) {
+    const normalized = term.toLowerCase();
+    const rarity = 1 / (documentFrequency.get(normalized) ?? 1);
+    strength += rarity * (slugNamesTerm(slug, normalized) ? RECALL_EXACT_SLUG_BONUS : 1);
+  }
+  return strength;
+}
 function applyExactMatchBoost(hits, exactMatches) {
   if (exactMatches.length === 0) {
     return hits;
@@ -4411,24 +4488,33 @@ function applyExactMatchBoost(hits, exactMatches) {
       uri
     };
   });
-  return [...annotated, ...promoted].sort(
-    (left, right) => recallCategoryRank(left.category) - recallCategoryRank(right.category) || (right.exactTerms?.length ?? 0) - (left.exactTerms?.length ?? 0) || right.score - left.score
+  const documentFrequency = exactTermDocumentFrequency(exactMatches);
+  const merged = [...annotated, ...promoted];
+  const combinedRelevanceByUri = /* @__PURE__ */ new Map();
+  for (const hit of merged) {
+    combinedRelevanceByUri.set(stripAnchor(hit.uri), exactMatchStrength(hit, documentFrequency) + hit.score);
+  }
+  return merged.sort(
+    (left, right) => recallCategoryRank(left.category) - recallCategoryRank(right.category) || (combinedRelevanceByUri.get(stripAnchor(right.uri)) ?? 0) - (combinedRelevanceByUri.get(stripAnchor(left.uri)) ?? 0) || right.score - left.score
   );
 }
+var RECALL_LOW_CONFIDENCE_NOTE = "\u26A0 No semantically-relevant matches \u2014 the results below only contain the query words (the corpus may not cover this topic).";
 function renderRecallHits(shown, overflow) {
   if (shown.length === 0) {
     return void 0;
   }
   const lines = shown.flatMap((hit, index) => {
     const scorePart = hit.score > 0 ? `score ${hit.score.toFixed(2)}` : void 0;
-    const exactPart = hit.exactTerms?.length ? `exact: ${hit.exactTerms.join(", ")}` : void 0;
+    const exactLabel = hit.score > 0 ? "exact" : "keyword-only";
+    const exactPart = hit.exactTerms?.length ? `${exactLabel}: ${hit.exactTerms.join(", ")}` : void 0;
     const head = `${index + 1}. ${[hit.contextType, scorePart, exactPart].filter(Boolean).join(" \xB7 ")} \xB7 ${hit.uri}`;
     return hit.snippet ? [head, `   ${hit.snippet}`] : [head];
   });
   if (overflow > 0) {
     lines.push(`(+${overflow} more \u2014 refine the query or read a URI above)`);
   }
-  return lines.join("\n");
+  const noSemanticMatch = shown.every((hit) => hit.score === 0);
+  return (noSemanticMatch ? [RECALL_LOW_CONFIDENCE_NOTE, ...lines] : lines).join("\n");
 }
 var RECALL_CATEGORY_RESERVE = 2;
 function selectShownHits(ranked, limit, reserve) {
@@ -7462,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);
@@ -7493,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];
@@ -7874,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"),
@@ -8075,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);
@@ -8225,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");
 }
@@ -8233,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;
@@ -10217,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;
   }
@@ -10777,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]);
@@ -11291,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,
@@ -11316,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);
@@ -11329,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)}`);
@@ -11768,6 +11981,13 @@ async function storeMemory(config, options) {
     console.log(`Updated existing memory in place: ${memoryUri}`);
   }
 }
+function warnOnSharedProjectDrift(metadata, inferred) {
+  if (inferred?.project && metadata.project && uriSegment(metadata.project) !== inferred.project) {
+    console.log(
+      `WARN keeping shared memory project "${inferred.project}" from its storage path; ignoring requested "${metadata.project}". To change a shared memory's project, forget it and store a new one under the new project.`
+    );
+  }
+}
 async function storeSharedMemoryReplacement(config, ov, options, targetUri) {
   if (options.metadata.kind !== "durable") {
     throw new Error("Shared memory replacement only supports durable memories.");
@@ -11778,9 +11998,10 @@ async function storeSharedMemoryReplacement(config, ov, options, targetUri) {
   }
   const team = await resolveTeam(config, teamName);
   const inferred = sharedMemoryUriParts(config, targetUri);
+  warnOnSharedProjectDrift(options.metadata, inferred);
   const metadata = {
     ...options.metadata,
-    project: options.metadata.project ?? inferred?.project,
+    project: inferred?.project ?? options.metadata.project,
     topic: options.metadata.topic ?? inferred?.topic
   };
   const rawMemory = formatMemoryDocument2(options.title, metadata, options.bodyText);
@@ -11838,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));
@@ -11906,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`,
@@ -11968,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");
 }
@@ -12203,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);
@@ -12214,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"),
@@ -12241,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 };
 }
@@ -12267,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";
@@ -12323,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;
@@ -12335,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 {
   }
@@ -12408,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);
@@ -12425,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) {
@@ -12507,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;
@@ -12525,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(
@@ -12566,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({
@@ -12594,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;
@@ -12614,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;
@@ -12666,6 +13260,70 @@ 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,
+        "--reason",
+        `Dependency facts for ${project.name}`,
+        "--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) {
@@ -12682,7 +13340,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;
@@ -12690,7 +13348,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 };
@@ -12707,13 +13365,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);
@@ -12750,20 +13408,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);
@@ -12804,13 +13500,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;
@@ -12832,7 +13528,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;
       }
@@ -12850,20 +13546,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) {
@@ -12875,21 +13571,24 @@ 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 graphCacheFileName(projectName) {
+  return `${uriSegment(projectName)}-${sha256(projectName).slice(0, 8)}.graph.md`;
+}
 function skillResourceReason(skill) {
-  return `${skill.kind === "command" ? "Agent command" : "Agent skill"} catalog item from ${skill.source}: ${(0, import_node_path12.basename)(
+  return `${skill.kind === "command" ? "Agent command" : "Agent skill"} catalog item from ${skill.source}: ${(0, import_node_path13.basename)(
     skill.filePath
   )}`;
 }
@@ -12922,7 +13621,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}`);
@@ -12956,16 +13655,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) {
@@ -13038,18 +13737,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
@@ -13403,14 +14102,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;
@@ -13481,11 +14180,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);
@@ -13549,7 +14248,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 [];
   }
@@ -13588,7 +14287,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 === "") {
@@ -13623,11 +14322,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") {
@@ -13657,14 +14356,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") {
@@ -13736,9 +14435,10 @@ async function collectDoctorChecks(config, options = {}) {
   checks.push(...await userAgentInstructionsChecks());
   checks.push(await manifestCheck(config.manifestPath));
   checks.push(await recallIndexFreshnessCheck(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 memoryProjectConsistencyCheck(config));
+  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;
 }
@@ -13746,9 +14446,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();
@@ -13793,17 +14493,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) {
@@ -13860,7 +14560,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);
@@ -13917,16 +14617,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) {
@@ -14001,7 +14701,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;
     }
@@ -14047,7 +14747,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.`
@@ -14091,7 +14791,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;
@@ -14100,7 +14800,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,
@@ -14137,7 +14837,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.");
@@ -14183,7 +14883,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",
@@ -14224,7 +14924,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",
@@ -14317,7 +15017,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` };
@@ -14383,11 +15083,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) {
@@ -14428,6 +15128,61 @@ async function recallIndexFreshnessCheck(config) {
     return { name: "recall index freshness", status: "warn", detail: errorMessage(err) };
   }
 }
+async function memoryProjectConsistencyCheck(config) {
+  const name = "memory project consistency";
+  const memoriesRoot = (0, import_node_path15.join)(
+    config.agentContextHome,
+    "data",
+    "viking",
+    config.account,
+    "user",
+    uriSegment(config.user),
+    "memories"
+  );
+  try {
+    let entries;
+    try {
+      entries = await (0, import_promises14.readdir)(memoriesRoot, { recursive: true });
+    } catch {
+      return { name, status: "ok", detail: "no memories directory yet" };
+    }
+    const mismatches = [];
+    let checked = 0;
+    for (const entry of entries) {
+      if (!entry.endsWith(".md") || isSummarySidecarUri(entry)) {
+        continue;
+      }
+      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_promises14.readFile)((0, import_node_path15.join)(memoriesRoot, entry), "utf8");
+      } catch {
+        continue;
+      }
+      checked += 1;
+      const frontProject = memoryFrontmatterField(content, "project");
+      if (frontProject && uriSegment(frontProject) !== pathProject) {
+        mismatches.push(`${uri} (frontmatter "${frontProject}" vs path "${pathProject}")`);
+      }
+    }
+    if (mismatches.length === 0) {
+      return { name, status: "ok", detail: `${checked} project-scoped memories consistent` };
+    }
+    const sample = mismatches.slice(0, 3).join("; ");
+    const extra = Math.max(0, mismatches.length - 3);
+    return {
+      name,
+      status: "warn",
+      detail: `${mismatches.length} memory(ies) whose frontmatter project differs from their storage path; re-store under the correct project to fix: ${sample}${extra > 0 ? `, +${extra} more` : ""}`
+    };
+  } catch (err) {
+    return { name, status: "warn", detail: errorMessage(err) };
+  }
+}
 async function fileCheck(path2, label) {
   return await exists(path2) ? { name: label, status: "ok", detail: path2 } : { name: label, status: "fail", detail: `${path2} missing` };
 }
@@ -14659,7 +15414,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(
@@ -14817,38 +15572,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}`);
@@ -14864,12 +15619,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}`);
@@ -14903,8 +15658,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}`);
   }
 }
@@ -14941,7 +15696,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}`);
   }
 }
@@ -14961,7 +15716,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}`;
@@ -15045,9 +15800,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) {
@@ -15059,9 +15814,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]);
@@ -15128,7 +15883,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);
@@ -15190,9 +15945,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" },
@@ -15263,18 +16018,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,
@@ -15562,7 +16317,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";
@@ -15571,11 +16326,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),
@@ -15589,13 +16344,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 {
@@ -15769,27 +16524,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()) {
@@ -15887,11 +16642,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,
@@ -15907,7 +16662,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) {
@@ -16045,10 +16800,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`;
@@ -16060,17 +16815,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://";
@@ -16264,7 +17019,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,
@@ -16310,9 +17068,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);
   });
@@ -16322,8 +17090,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);