@dotdotgod/claude-code 0.3.10 → 0.3.12

package/mcp/cli.mjs

@@ -1345,12 +1345,18 @@ Checks or writes generated Markdown traceability link sections from canonical fe
     case "graph":
       return `Usage:
   dotdotgod graph impact <root> --changed <path> [--changed <path> ...] [--compact|--json|--yml|--yaml]
+  dotdotgod graph serve <root> --changed <path> [--changed <path> ...] [--host HOST] [--port PORT]
   dotdotgod graph communities <root> [--json]`;
     case "graph impact":
       return `Usage:
   dotdotgod graph impact <root> --changed <path> [--changed <path> ...] [--compact|--json|--yml|--yaml]
 
 Ranks nodes related to one or more changed files. <root> is the project root; repeat --changed with project-relative file paths. Results include a combined ranking and the top five related nodes for each changed file. Use --compact for a short text summary or --yml/--yaml for structured agent-facing output.`;
+    case "graph serve":
+      return `Usage:
+  dotdotgod graph serve <root> --changed <path> [--changed <path> ...] [--host HOST] [--port PORT]
+
+Starts a local-only impact graph explorer. Changed files are rendered as root nodes and are excluded from related-result lists.`;
     case "graph communities":
       return `Usage:
   dotdotgod graph communities <root> [--json]`;
@@ -1374,6 +1380,7 @@ Commands:
   status                Show local index status.
   traceability links    Check or write generated traceability links.
   graph impact          Find files related to changed files.
+  graph serve           Open a local impact graph explorer.
   graph communities     Find groups of related project-memory nodes.
 
 Options:
@@ -1711,7 +1718,7 @@ import { spawnSync } from "node:child_process";
 import { basename as basename3, extname as extname2, join as join5 } from "node:path";
 
 // packages/cli/src/index/constants.mjs
-var CACHE_VERSION = 13;
+var CACHE_VERSION = 15;
 var CACHE_DIR = ".dotdotgod";
 var MANIFEST_FILE = "manifest.json";
 
@@ -2087,8 +2094,16 @@ function addPackageResource(graph, fileId, packagePath, name, target, kind) {
   addNode(graph, id, "package_resource", { name, target, kind, path: packagePath });
   addEdge(graph, fileId, id, "includes_resource", { kind, confidence: "EXTRACTED" });
 }
+function addReferenceEvidence(graph, sourceId, reference) {
+  const source = graph.nodes.find((node2) => node2.id === sourceId);
+  if (!source) return;
+  source.references ??= [];
+  source.references.push(reference);
+}
 function addTraceabilityTarget(graph, sourceId, root, relation, targetPath, data = {}, config = defaultMemoryConfig()) {
-  if (!isLocalRelativeTraceabilityPath(targetPath) || !existsSync8(resolve5(root, targetPath))) return;
+  if (!isLocalRelativeTraceabilityPath(targetPath)) return;
+  addReferenceEvidence(graph, sourceId, { targetPath, href: targetPath, relation, data: { confidence: "CURATED_TRACEABILITY", ...data } });
+  if (!existsSync8(resolve5(root, targetPath))) return;
   const targetId = `file:${targetPath}`;
   addNode(graph, targetId, "file", fileNodeMetadata(targetPath, null, config));
   addEdge(graph, sourceId, targetId, relation, { confidence: "CURATED_TRACEABILITY", ...data });
@@ -2151,9 +2166,14 @@ function extractMarkdownGraph(root, file, graph, config = defaultMemoryConfig())
     addEdge(graph, fileId, id, "contains_heading", { confidence: "EXTRACTED" });
   }
   for (const { href, line } of extractLinks(content)) {
-    const pathPart = href.split("#")[0];
+    const hashIndex = href.indexOf("#");
+    const pathPart = hashIndex < 0 ? href : href.slice(0, hashIndex);
+    const anchor = hashIndex < 0 ? "" : href.slice(hashIndex + 1);
+    const targetPath = pathPart ? rel(root, resolve6(dirname4(file), pathPart)) : path;
+    const data = { line, confidence: "EXTRACTED" };
+    addReferenceEvidence(graph, fileId, { targetPath, href, anchor, relation: "links_to", data });
+    if (pathPart && isReadmeIndexPath(path)) addReferenceEvidence(graph, fileId, { targetPath, href, anchor, relation: "routes_to", data: { line, confidence: "CURATED_INDEX", sourceRole: "readme-index" } });
     if (!pathPart) continue;
-    const targetPath = rel(root, resolve6(dirname4(file), pathPart));
     const targetId = `file:${targetPath}`;
     addNode(graph, targetId, "file", fileNodeMetadata(targetPath, null, config));
     addEdge(graph, fileId, targetId, "links_to", { line, confidence: "EXTRACTED" });
@@ -2225,7 +2245,7 @@ function mergeIncrementalGraph(previousGraph, changedGraph, changedPaths) {
   if (!previousGraph) return changedGraph;
   const changedSet = new Set(changedPaths);
   const changedNodeIds = new Set(previousGraph.nodes.filter((node2) => nodeOwnedByPath(node2, changedSet)).map((node2) => node2.id));
-  for (const node2 of changedGraph.nodes) changedNodeIds.add(node2.id);
+  for (const node2 of changedGraph.nodes) if (nodeOwnedByPath(node2, changedSet)) changedNodeIds.add(node2.id);
   const graph = { nodes: [], edges: [] };
   for (const node2 of previousGraph.nodes) if (!changedNodeIds.has(node2.id) && !nodeOwnedByPath(node2, changedSet)) addNode(graph, node2.id, node2.type, Object.fromEntries(Object.entries(node2).filter(([key]) => key !== "id" && key !== "type")));
   for (const edge of previousGraph.edges) if (!changedNodeIds.has(edge.source) && !changedNodeIds.has(edge.target)) addEdge(graph, edge.source, edge.target, edge.relation, Object.fromEntries(Object.entries(edge).filter(([key]) => key !== "source" && key !== "target" && key !== "relation")));
@@ -3204,15 +3224,15 @@ import { resolve as resolve11 } from "node:path";
 function parse(argv) {
   const [action2 = "status", ...rest] = argv;
   let root = ".";
-  let json = false;
+  let json2 = false;
   let confirm = false;
   for (const arg of rest) {
-    if (arg === "--json") json = true;
+    if (arg === "--json") json2 = true;
     else if (arg === "--confirm") confirm = true;
     else if (!arg.startsWith("-") && root === ".") root = arg;
     else usage(`Unknown embedding option: ${arg}`, `embedding ${action2}`);
   }
-  return { action: action2, root: resolve11(root), json, confirm };
+  return { action: action2, root: resolve11(root), json: json2, confirm };
 }
 function runEmbedding(argv, options = {}) {
   const parsed = parse(argv);
@@ -3339,8 +3359,8 @@ function buildDocumentationMap(projectRoot = ".", { depth = 5 } = {}) {
 }
 
 // packages/cli/src/commands/map.mjs
-function fail(json, code, message) {
-  if (json) console.log(JSON.stringify({ ok: false, error: { code, message } }, null, 2));
+function fail(json2, code, message) {
+  if (json2) console.log(JSON.stringify({ ok: false, error: { code, message } }, null, 2));
   else console.error(message);
   process.exit(2);
 }
@@ -3377,7 +3397,7 @@ function runMap(argv) {
 }
 
 // packages/cli/src/reference/resolve.mjs
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 
 // node_modules/.pnpm/leiden-ts@0.1.0/node_modules/leiden-ts/dist/index.js
 var GraphValidationError = class extends Error {
@@ -4747,16 +4767,94 @@ function compareImpactItems(seeds) {
   };
 }
 
+// packages/cli/src/impact/references.mjs
+import { readFileSync as readFileSync13, statSync as statSync8 } from "node:fs";
+import { extname as extname5, resolve as resolve14 } from "node:path";
+var WARNING_LIMIT = 20;
+var edgeKey = (source, target, relation) => `${source}\0${target}\0${relation}`;
+function prepareImpactReferences(index, root, changedPaths) {
+  const graph = index?.graph ?? { nodes: [], edges: [] };
+  if (!root) return { index, warnings: { items: [], total: 0, omitted: 0 } };
+  const seeds = new Set(changedPaths.map((path) => `file:${path}`));
+  const checks = /* @__PURE__ */ new Map();
+  const inspect = (path) => {
+    if (checks.has(path)) return checks.get(path);
+    let result;
+    try {
+      const absolute = resolve14(root, path);
+      const stat = statSync8(absolute);
+      result = { status: "exists" };
+      if (stat.isFile() && extname5(absolute) === ".md") result.anchors = extractAnchors(readFileSync13(absolute, "utf8"));
+    } catch (error) {
+      result = { status: ["ENOENT", "ENOTDIR"].includes(error.code) ? "missing" : "unavailable" };
+    }
+    checks.set(path, result);
+    return result;
+  };
+  const references = graph.nodes.flatMap((node2) => (node2.references ?? []).map((reference) => ({ ...reference, source: node2.id, sourcePath: node2.path })));
+  const managedEdges = new Set(references.map((ref) => edgeKey(ref.source, `file:${ref.targetPath}`, ref.relation)));
+  const adjacency = /* @__PURE__ */ new Map();
+  const connect = (source, target) => {
+    if (!adjacency.has(source)) adjacency.set(source, /* @__PURE__ */ new Set());
+    if (!adjacency.has(target)) adjacency.set(target, /* @__PURE__ */ new Set());
+    adjacency.get(source).add(target);
+    adjacency.get(target).add(source);
+  };
+  for (const edge of graph.edges) connect(edge.source, edge.target);
+  for (const ref of references) connect(ref.source, `file:${ref.targetPath}`);
+  const reachable = new Set(seeds);
+  const queue = [...seeds];
+  for (let i = 0; i < queue.length; i += 1) for (const id of adjacency.get(queue[i]) ?? []) {
+    if (!reachable.has(id)) {
+      reachable.add(id);
+      queue.push(id);
+    }
+  }
+  const missing = new Set(graph.nodes.filter((node2) => node2.path && inspect(node2.path).status === "missing" && !seeds.has(node2.id)).map((node2) => node2.id));
+  const nodes = new Map(graph.nodes.filter((node2) => !missing.has(node2.id)).map((node2) => [node2.id, node2]));
+  const edges = graph.edges.filter((edge) => !missing.has(edge.source) && !missing.has(edge.target) && !managedEdges.has(edgeKey(edge.source, edge.target, edge.relation)));
+  for (const path of changedPaths) {
+    const id = `file:${path}`;
+    if (!nodes.has(id)) nodes.set(id, { id, type: "file", ...fileNodeMetadata(path, null, index?.memoryConfig) });
+  }
+  const warnings = /* @__PURE__ */ new Map();
+  for (const ref of references) {
+    if (/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(ref.href)) continue;
+    const targetId = `file:${ref.targetPath}`;
+    const check = inspect(ref.targetPath);
+    let reason = check.status === "missing" ? "MISSING_FILE" : check.status === "unavailable" ? "REFERENCE_UNAVAILABLE" : void 0;
+    if (!reason && ref.anchor && check.anchors) {
+      try {
+        if (!check.anchors.has(decodeURIComponent(ref.anchor))) reason = "BROKEN_ANCHOR";
+      } catch {
+        reason = "BROKEN_ANCHOR";
+      }
+    }
+    if (reason) {
+      if (reachable.has(ref.source) && !missing.has(ref.source)) {
+        const key = `${ref.source}\0${ref.href}\0${ref.data?.line ?? ""}\0${reason}`;
+        if (!warnings.has(key)) warnings.set(key, { source: ref.sourcePath ?? ref.source, target: ref.href, targetPath: ref.targetPath, relation: ref.relation, reason, ...ref.data?.line ? { line: ref.data.line } : {} });
+      }
+      if (reason !== "REFERENCE_UNAVAILABLE" && !(reason === "MISSING_FILE" && seeds.has(targetId))) continue;
+    }
+    if (missing.has(ref.source)) continue;
+    if (!nodes.has(targetId)) nodes.set(targetId, { id: targetId, type: "file", ...fileNodeMetadata(ref.targetPath, null, index?.memoryConfig) });
+    edges.push({ source: ref.source, target: targetId, relation: ref.relation, ...ref.data });
+  }
+  const items = [...warnings.values()].sort((a, b) => a.source.localeCompare(b.source) || (a.line ?? 0) - (b.line ?? 0) || a.target.localeCompare(b.target) || a.reason.localeCompare(b.reason));
+  return { index: { ...index, graph: { nodes: [...nodes.values()], edges: edges.filter((edge) => nodes.has(edge.source) && nodes.has(edge.target)) } }, warnings: { items: items.slice(0, WARNING_LIMIT), total: items.length, omitted: Math.max(0, items.length - WARNING_LIMIT) } };
+}
+
 // packages/cli/src/impact/vector-profile.mjs
-import { lstatSync, readFileSync as readFileSync13, realpathSync } from "node:fs";
-import { extname as extname5, relative as relative5, resolve as resolve14, sep } from "node:path";
+import { lstatSync, readFileSync as readFileSync14, realpathSync } from "node:fs";
+import { extname as extname6, relative as relative5, resolve as resolve15, sep } from "node:path";
 var MAX_VECTOR_PROFILE_FILE_BYTES = 64 * 1024;
 var MAX_VECTOR_PROFILE_CHARS = 4e3;
 var MAX_VECTOR_PROFILE_METADATA_ITEMS = 20;
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".c", ".cc", ".cpp", ".css", ".go", ".h", ".hpp", ".html", ".java", ".js", ".json", ".jsx", ".md", ".mjs", ".py", ".rb", ".rs", ".sh", ".ts", ".tsx", ".txt", ".yaml", ".yml"]);
 var GENERATED_SEGMENTS = /* @__PURE__ */ new Set([".dotdotgod", "build", "coverage", "dist", "node_modules"]);
 function insideRoot(root, absolute) {
-  const normalizedRoot = resolve14(root);
+  const normalizedRoot = resolve15(root);
   return absolute === normalizedRoot || absolute.startsWith(`${normalizedRoot}${sep}`);
 }
 function normalizeChangedPath(path) {
@@ -4767,8 +4865,8 @@ function normalizeChangedPath(path) {
 function canonicalizeChangedPath(root, path) {
   const normalized = normalizeChangedPath(path);
   if (!normalized) return null;
-  const rootAbsolute = resolve14(root);
-  const absolute = resolve14(rootAbsolute, normalized);
+  const rootAbsolute = resolve15(root);
+  const absolute = resolve15(rootAbsolute, normalized);
   if (!insideRoot(rootAbsolute, absolute)) return normalized;
   try {
     const canonicalRoot = realpathSync(rootAbsolute);
@@ -4797,17 +4895,17 @@ function graphMetadata(graph, seedId) {
   return values;
 }
 function safeTextPrefix(root, path) {
-  if (unsafeProfilePath(path) || !TEXT_EXTENSIONS.has(extname5(path).toLowerCase())) return "";
+  if (unsafeProfilePath(path) || !TEXT_EXTENSIONS.has(extname6(path).toLowerCase())) return "";
   try {
-    const absolute = resolve14(root, path);
+    const absolute = resolve15(root, path);
     if (!insideRoot(root, absolute)) return "";
     const canonicalAbsolute = realpathSync(absolute);
     if (!insideRoot(realpathSync(root), canonicalAbsolute)) return "";
     const canonicalPath = relative5(realpathSync(root), canonicalAbsolute).replaceAll("\\", "/");
-    if (canonicalPath !== path || unsafeProfilePath(canonicalPath) || !TEXT_EXTENSIONS.has(extname5(canonicalPath).toLowerCase())) return "";
+    if (canonicalPath !== path || unsafeProfilePath(canonicalPath) || !TEXT_EXTENSIONS.has(extname6(canonicalPath).toLowerCase())) return "";
     const stats = lstatSync(canonicalAbsolute);
     if (!stats.isFile() || stats.isSymbolicLink() || stats.size > MAX_VECTOR_PROFILE_FILE_BYTES) return "";
-    const buffer = readFileSync13(canonicalAbsolute);
+    const buffer = readFileSync14(canonicalAbsolute);
     if (buffer.includes(0)) return "";
     const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
     return text.slice(0, MAX_VECTOR_PROFILE_CHARS);
@@ -4923,10 +5021,10 @@ function buildCombinedImpactReport(index, changedPaths, limits = {}) {
   const traceabilityWeights = traceabilityRelationWeights(config.traceability);
   policy.relationWeights = { ...policy.relationWeights, ...traceabilityWeights };
   const curatedRelations = new Set(Object.keys(traceabilityWeights));
-  const nodeById = new Map(graph.nodes.map((node2) => [node2.id, node2]));
+  const nodeById = new Map(graph.nodes.map(({ references, ...node2 }) => [node2.id, node2]));
   const seeds = changedPaths.map((path) => `file:${path}`);
   const seedSet = new Set(seeds);
-  const maxRelated = Math.max(limits.related ?? 25, seeds.length);
+  const maxRelated = Math.max(limits.related ?? 25, 0);
   const groups = { files: { items: [], omitted: 0 }, docs: { items: [], omitted: 0 }, contracts: { items: [], omitted: 0 }, tests: { items: [], omitted: 0 }, commands: { items: [], omitted: 0 }, events: { items: [], omitted: 0 }, packageResources: { items: [], omitted: 0 }, symbols: { items: [], omitted: 0 } };
   const relatedIds = new Set(seeds);
   const reasons = new Map(seeds.map((seed) => [seed, /* @__PURE__ */ new Set(["changed-file"])]));
@@ -4962,7 +5060,9 @@ function buildCombinedImpactReport(index, changedPaths, limits = {}) {
     const scored = scoreImpactItem({ ...node2, reasons: reasonList, retrieval }, seedSet, changedPaths, policy, pprScores, config);
     return { ...node2, reasons: reasonList, hasCuratedEvidence, ...vectorEvidence.has(id) ? { vectorEvidence: vectorEvidence.get(id) } : {}, retrieval: { ...retrieval, signals: [.../* @__PURE__ */ new Set([...retrieval.signals ?? [], ...reasonSignals])] }, ...scored };
   }).sort(compareImpactItems(seeds));
-  const related = selectImpactItems(relatedAll, maxRelated, seeds);
+  const excludedIds = new Set(limits.excludeRelatedIds ?? seeds);
+  const rankedRelated = relatedAll.filter((item) => !excludedIds.has(item.id));
+  const related = selectImpactItems(rankedRelated, maxRelated, []);
   for (const item of related) {
     if (item.type === "file") {
       const area2 = docsArea2(item.path, config);
@@ -4975,18 +5075,24 @@ function buildCombinedImpactReport(index, changedPaths, limits = {}) {
     else if (item.type === "event") addImpactItem(groups.events, item, limits.events ?? 10);
     else if (item.type === "package_resource") addImpactItem(groups.packageResources, item, limits.packageResources ?? 10);
   }
-  return { changed: changedPaths[0], changedFiles: changedPaths, semantic: { status: overlay.status ?? "disabled", ...limits.verboseSemantic ? { diagnostics: overlay.diagnostics } : {} }, ranking: { method: "weighted-personalized-pagerank+memory", configSource: index?.memoryConfig?.source ?? "default", connectionCap: policy.connectionCap, memoryCap: policy.memoryCap, pprReference: policy.ppr.reference }, related, groups, omittedRelated: Math.max(0, relatedAll.length - related.length) };
+  return { changed: changedPaths[0], changedFiles: changedPaths, semantic: { status: overlay.status ?? "disabled", ...limits.verboseSemantic ? { diagnostics: overlay.diagnostics } : {} }, ranking: { method: "weighted-personalized-pagerank+memory", configSource: index?.memoryConfig?.source ?? "default", connectionCap: policy.connectionCap, memoryCap: policy.memoryCap, pprReference: policy.ppr.reference }, related, groups, omittedRelated: Math.max(0, rankedRelated.length - related.length) };
 }
 function buildImpactReport(index, changedPaths, limits = {}) {
   const normalized = normalizeChangedPaths(changedPaths);
+  const prepared = prepareImpactReferences(index, limits.root, normalized);
+  index = prepared.index;
+  const validIds = new Set(index?.graph?.nodes.map((node2) => node2.id) ?? []);
+  if (limits.overlay) limits = { ...limits, overlay: { ...limits.overlay, edges: (limits.overlay.edges ?? []).filter((edge) => validIds.has(edge.target)) } };
   const aggregate2 = buildCombinedImpactReport(index, normalized, limits);
+  aggregate2.warnings = prepared.warnings;
+  Object.defineProperty(aggregate2, "structuralGraph", { value: index?.graph, enumerable: false });
   const perSeedLimit = limits.perSeed ?? 5;
   aggregate2.perSeed = normalized.map((changed) => {
     const seedId = `file:${changed}`;
     const seedOverlay = limits.overlay ? { ...limits.overlay, edges: (limits.overlay.edges ?? []).filter((edge) => edge.source === seedId) } : void 0;
-    const report = buildCombinedImpactReport(index, [changed], { ...limits, overlay: seedOverlay, related: Math.max(limits.related ?? 25, perSeedLimit + 1) });
-    const related = report.related.filter((item) => item.id !== `file:${changed}`).slice(0, perSeedLimit);
-    return { changed, related, omittedRelated: Math.max(0, report.related.length - 1 - related.length) + report.omittedRelated };
+    const report = buildCombinedImpactReport(index, [changed], { ...limits, excludeRelatedIds: normalized.map((path) => `file:${path}`), overlay: seedOverlay, related: Math.max(limits.related ?? 25, perSeedLimit) });
+    const related = report.related.slice(0, perSeedLimit);
+    return { changed, related, omittedRelated: Math.max(0, report.related.length - related.length) + report.omittedRelated };
   });
   return aggregate2;
 }
@@ -5006,7 +5112,7 @@ function compactImpactGroup(group = { items: [], omitted: 0 }, limit = 5) {
   return { items, omitted: (group.omitted ?? 0) + Math.max(0, (group.items?.length ?? 0) - items.length) };
 }
 function buildCompactImpactReport(impact, limits = {}) {
-  const relatedLimit = Math.max(limits.related ?? 10, impact.changedFiles?.length ?? 1);
+  const relatedLimit = limits.related ?? 10;
   const groupLimit = limits.groupItems ?? 5;
   const changedFiles = impact.changedFiles ?? [impact.changed];
   const seedIds = new Set(changedFiles.map((path) => `file:${path}`));
@@ -5015,11 +5121,11 @@ function buildCompactImpactReport(impact, limits = {}) {
   const groups = Object.fromEntries(groupNames.map((name) => [name, compactImpactGroup(impact.groups?.[name], groupLimit)]));
   const perSeed = (impact.perSeed ?? []).map((entry) => ({ changed: entry.changed, related: (entry.related ?? []).slice(0, limits.perSeed ?? 5).map(compactImpactItem), omittedRelated: entry.omittedRelated ?? 0 }));
   const top10 = (impact.related ?? []).filter((item) => !seedIds.has(item.id)).slice(0, 10);
-  return { changed: impact.changed, changedFiles, perSeed, semantic: impact.semantic, compact: true, ranking: { method: impact.ranking?.method, configSource: impact.ranking?.configSource, connectionCap: impact.ranking?.connectionCap, memoryCap: impact.ranking?.memoryCap, pprReference: impact.ranking?.pprReference }, related, groups, omittedRelated: (impact.omittedRelated ?? 0) + Math.max(0, (impact.related?.length ?? 0) - related.length), quality: { rawRelated: impact.related?.length ?? 0, compactRelated: related.length, semanticOnlyTop10: top10.filter((item) => isSemanticOnlyImpactItem(item)).length, curatedTop10: top10.filter((item) => hasCuratedImpactReason(item)).length, lowActionabilityTop10: top10.filter((item) => isLowActionabilityImpactItem(item)).length } };
+  return { changed: impact.changed, changedFiles, perSeed, warnings: impact.warnings, semantic: impact.semantic, compact: true, ranking: { method: impact.ranking?.method, configSource: impact.ranking?.configSource, connectionCap: impact.ranking?.connectionCap, memoryCap: impact.ranking?.memoryCap, pprReference: impact.ranking?.pprReference }, related, groups, omittedRelated: (impact.omittedRelated ?? 0) + Math.max(0, (impact.related?.length ?? 0) - related.length), quality: { rawRelated: impact.related?.length ?? 0, compactRelated: related.length, semanticOnlyTop10: top10.filter((item) => isSemanticOnlyImpactItem(item)).length, curatedTop10: top10.filter((item) => hasCuratedImpactReason(item)).length, lowActionabilityTop10: top10.filter((item) => isLowActionabilityImpactItem(item)).length } };
 }
 
 // packages/cli/src/reference/extract.mjs
-import { basename as basename8, dirname as dirname7, extname as extname6 } from "node:path";
+import { basename as basename8, dirname as dirname7, extname as extname7 } from "node:path";
 var DEFAULT_REFERENCE_LIMIT = 5;
 function extractBracketReferences(prompt = "") {
   const refs = [];
@@ -5064,7 +5170,7 @@ function isArchiveBodyPath(path = "", memoryConfig) {
 function aliasEntriesForPath(path = "") {
   const entries = [];
   const base = basename8(path);
-  const ext = extname6(base);
+  const ext = extname7(base);
   const stem = ext ? base.slice(0, -ext.length) : base;
   const withoutMd = path.replace(/\.md$/i, "");
   const parts = withoutMd.split("/").filter(Boolean);
@@ -5081,7 +5187,7 @@ function referenceCandidateAliases(node2) {
   const entries = [];
   if (node2.type === "file" && path) entries.push(...aliasEntriesForPath(path));
   if (node2.type === "heading") {
-    const fileStem = path ? basename8(path, extname6(path)) : "";
+    const fileStem = path ? basename8(path, extname7(path)) : "";
     const anchor = typeof node2.id === "string" && node2.id.includes("#") ? node2.id.split("#").pop() : "";
     for (const alias of [node2.title, anchor, fileStem && node2.title ? `${fileStem}#${node2.title}` : "", fileStem && anchor ? `${fileStem}#${anchor}` : "", path && node2.title ? `${path}#${node2.title}` : "", path && anchor ? `${path}#${anchor}` : ""]) entries.push({ alias, kind: "heading" });
   }
@@ -5200,7 +5306,7 @@ function parseReferenceOptions(argv, command) {
     else filtered.push(arg);
   }
   const operands = filtered.filter((arg) => !arg.startsWith("-"));
-  return { ...options, root: resolve15(operands[0] ?? "."), json: filtered.includes("--json"), rootArgv: operands.slice(1) };
+  return { ...options, root: resolve16(operands[0] ?? "."), json: filtered.includes("--json"), rootArgv: operands.slice(1) };
 }
 function formatReferenceOutput(payload) {
   const refreshNote = payload.metadata.cacheRefreshed ? ", refreshed" : "";
@@ -5240,8 +5346,8 @@ function runExpand(argv) {
   if (options.withImpact) refs = refs.map((item) => {
     const topPath = item.top?.path;
     if (!topPath) return item;
-    const impact = buildCompactImpactReport(buildImpactReport(index, topPath));
-    return { ...item, impact: { changed: topPath, related: impact.related, groups: impact.groups, omittedRelated: impact.omittedRelated, quality: impact.quality } };
+    const impact = buildCompactImpactReport(buildImpactReport(index, topPath, { root: options.root }));
+    return { ...item, impact: { changed: topPath, warnings: impact.warnings, related: impact.related, groups: impact.groups, omittedRelated: impact.omittedRelated, quality: impact.quality } };
   });
   const payload = { ok: status.ok, command: "expand", root: options.root, prompt, status, metadata, refs, omitted: refs.reduce((sum, item) => sum + item.omitted, 0) };
   if (options.json) console.log(JSON.stringify(payload, null, 2));
@@ -5249,8 +5355,8 @@ function runExpand(argv) {
 }
 
 // packages/cli/src/commands/traceability.mjs
-import { existsSync as existsSync15, readFileSync as readFileSync14, readdirSync as readdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join14, resolve as resolve16 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync15, readdirSync as readdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join14, resolve as resolve17 } from "node:path";
 function collectDocsMarkdownFiles(root) {
   const docs = join14(root, "docs");
   const files = [];
@@ -5282,7 +5388,7 @@ function parseTraceabilityOptions(argv) {
   }
   if (options.check && options.write) usage("Choose only one traceability links mode: --check or --write.", "traceability links");
   options.check = options.check || !options.write;
-  options.root = resolve16(options.root);
+  options.root = resolve17(options.root);
   return options;
 }
 function runTraceability(argv) {
@@ -5293,7 +5399,7 @@ function runTraceability(argv) {
   const errors = [...config.errors ?? []];
   for (const file of files) {
     if (options.write && errors.length > 0) break;
-    const content = readFileSync14(file, "utf8");
+    const content = readFileSync15(file, "utf8");
     for (const error of validateTraceabilityLinksRegion(content, options.root, file)) errors.push(error);
     const blocks = extractDotdotgodTraceabilityBlocks(content).filter((block) => !block.error);
     if (blocks.length === 0) continue;
@@ -5321,7 +5427,195 @@ function runTraceability(argv) {
   process.exit(ok ? 0 : 1);
 }
 
+// packages/cli/src/graph-view/server.mjs
+import { createServer } from "node:http";
+import { readFileSync as readFileSync16 } from "node:fs";
+import { dirname as dirname8, extname as extname8, join as join15 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/cli/src/graph-view/payload.mjs
+function edgeKey2(edge) {
+  return `${edge.source}\0${edge.target}\0${edge.relation}`;
+}
+function labelForNode(node2) {
+  if (node2.type === "contract") return node2.title ?? node2.contractId ?? node2.id;
+  return node2.path ?? node2.command ?? node2.name ?? node2.target ?? node2.id;
+}
+function adjacencyFor(nodes, edges) {
+  const adjacency = new Map(nodes.map((node2) => [node2.id, /* @__PURE__ */ new Set()]));
+  for (const edge of edges) {
+    adjacency.get(edge.source)?.add(edge.target);
+    adjacency.get(edge.target)?.add(edge.source);
+  }
+  return adjacency;
+}
+function rootReachability(nodes, edges, seedIds) {
+  const adjacency = adjacencyFor(nodes, edges);
+  const reachable = /* @__PURE__ */ new Set();
+  const depthByNode = /* @__PURE__ */ new Map();
+  const nearestRootByNode = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const node2 of nodes) {
+    if (!seedIds.has(node2.id)) continue;
+    reachable.add(node2.id);
+    depthByNode.set(node2.id, 0);
+    nearestRootByNode.set(node2.id, node2.id);
+    queue.push(node2.id);
+  }
+  for (let cursor = 0; cursor < queue.length; cursor += 1) {
+    const current = queue[cursor];
+    for (const neighbor of adjacency.get(current) ?? []) {
+      if (reachable.has(neighbor)) continue;
+      reachable.add(neighbor);
+      depthByNode.set(neighbor, (depthByNode.get(current) ?? 0) + 1);
+      nearestRootByNode.set(neighbor, nearestRootByNode.get(current));
+      queue.push(neighbor);
+    }
+  }
+  return { reachable, depthByNode, nearestRootByNode };
+}
+function buildImpactGraphPayload(index, impact) {
+  const graph = impact.structuralGraph ?? index?.graph ?? { nodes: [], edges: [] };
+  const config = index?.memoryConfig;
+  const seedIds = new Set((impact.changedFiles ?? [impact.changed]).map((path) => `file:${path}`));
+  const impactItems = new Map((impact.related ?? []).map((item) => [item.id, item]));
+  const isAllowedNode = (node2) => {
+    if (!node2) return false;
+    if (node2.path && resolveMemoryArea(node2.path, config)?.scope === "local") return false;
+    return true;
+  };
+  const sourceNodes = (graph.nodes ?? []).filter(isAllowedNode);
+  const indexedNodes = new Map(sourceNodes.map((node2) => [node2.id, node2]));
+  const seenEdges = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const edge of graph.edges ?? []) {
+    if (!indexedNodes.has(edge.source) || !indexedNodes.has(edge.target)) continue;
+    const key = edgeKey2(edge);
+    if (seenEdges.has(key)) continue;
+    seenEdges.add(key);
+    edges.push({ source: edge.source, target: edge.target, relation: edge.relation, confidence: edge.confidence, weight: edge.weight ?? edge.relationWeight, score: edge.score, traceabilityKey: edge.traceabilityKey });
+  }
+  const { reachable, depthByNode, nearestRootByNode } = rootReachability(sourceNodes, edges, seedIds);
+  const retainedNodes = sourceNodes.filter((node2) => reachable.has(node2.id));
+  const retainedEdges = edges.filter((edge) => reachable.has(edge.source) && reachable.has(edge.target));
+  const nodes = retainedNodes.map((source) => {
+    const item = impactItems.get(source.id);
+    const seed = seedIds.has(source.id);
+    return {
+      id: source.id,
+      type: source.type ?? item?.type ?? "file",
+      path: source.path ?? item?.path,
+      label: labelForNode({ ...source, ...item }),
+      seed,
+      ranked: Boolean(item),
+      depth: depthByNode.get(source.id) ?? 0,
+      nearestRoot: nearestRootByNode.get(source.id),
+      component: 0,
+      seededComponent: true,
+      impactScore: seed ? 100 : item?.impactScore ?? 0,
+      reasons: seed ? ["changed-file"] : item?.reasons ?? [],
+      scoreBreakdown: seed ? { seed: 100 } : item?.scoreBreakdown,
+      retrieval: item?.retrieval ?? source.retrieval,
+      contractId: item?.contractId ?? source.contractId,
+      title: item?.title ?? source.title,
+      sections: item?.sections ?? source.sections,
+      vectorEvidence: item?.vectorEvidence
+    };
+  });
+  return {
+    changed: impact.changed,
+    changedFiles: impact.changedFiles ?? [impact.changed],
+    ranking: impact.ranking,
+    semantic: impact.semantic,
+    complete: true,
+    nodes,
+    edges: retainedEdges,
+    components: retainedNodes.length > 0 ? [{ id: 0, size: retainedNodes.length, seeded: true }] : [],
+    diagnostics: {
+      rootNodes: retainedNodes.filter((node2) => seedIds.has(node2.id)).length,
+      connectedNodes: retainedNodes.length,
+      disconnectedNodesOmitted: sourceNodes.length - retainedNodes.length,
+      maximumDepth: Math.max(0, ...depthByNode.values())
+    },
+    omittedRelated: impact.omittedRelated ?? 0
+  };
+}
+
+// packages/cli/src/graph-view/server.mjs
+var ASSET_ROOT = join15(dirname8(fileURLToPath(import.meta.url)), "assets");
+var CONTENT_TYPES = { ".css": "text/css; charset=utf-8", ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8", ".map": "application/json; charset=utf-8" };
+var VENDOR_FILES = {
+  "/vendor/sigma.js": new URL("../../node_modules/sigma/dist/sigma.min.js", import.meta.url),
+  "/vendor/graphology.js": new URL("../../node_modules/graphology/dist/graphology.umd.min.js", import.meta.url),
+  "/vendor/d3.js": new URL("../../node_modules/d3/dist/d3.min.js", import.meta.url)
+};
+function json(response, status, value) {
+  response.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  response.end(JSON.stringify(value));
+}
+function asset(response, file) {
+  try {
+    const body = readFileSync16(file);
+    response.writeHead(200, { "content-type": CONTENT_TYPES[extname8(file)] ?? "application/octet-stream", "cache-control": "no-store" });
+    response.end(body);
+  } catch {
+    response.writeHead(404);
+    response.end("Not found");
+  }
+}
+async function buildServedImpact(root, changedPaths) {
+  const normalized = [...new Set(changedPaths.map((path) => canonicalizeChangedPath(root, path)).filter(Boolean))];
+  const { status, index, metadata } = readFreshIndex(root);
+  const overlay = await buildVectorImpactOverlay(root, index, normalized);
+  const impact = buildImpactReport(index, normalized, { root, overlay, verboseSemantic: false, related: 40 });
+  const graph = buildImpactGraphPayload(index, impact);
+  const graphIds = new Set(graph.nodes.map((node2) => node2.id));
+  const explorerImpact = {
+    ...impact,
+    related: impact.related.filter((item) => graphIds.has(item.id))
+  };
+  return { ok: status.ok, status, metadata, impact: explorerImpact, graph };
+}
+async function startImpactGraphServer({ root, changed, host = "127.0.0.1", port = 0 }) {
+  let payload = await buildServedImpact(root, changed);
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? host}`);
+    if (url.pathname === "/api/impact") return json(response, 200, payload);
+    if (url.pathname === "/api/reroot") {
+      const paths = url.searchParams.getAll("changed");
+      if (paths.length === 0) return json(response, 400, { ok: false, error: { code: "MISSING_CHANGED", message: "At least one changed path is required." } });
+      try {
+        payload = await buildServedImpact(root, paths);
+        return json(response, 200, payload);
+      } catch (error) {
+        return json(response, 500, { ok: false, error: { code: "GRAPH_SERVE_FAILED", message: error instanceof Error ? error.message : String(error) } });
+      }
+    }
+    if (VENDOR_FILES[url.pathname]) return asset(response, fileURLToPath(VENDOR_FILES[url.pathname]));
+    const relative6 = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
+    if (!["index.html", "app.css", "app.js"].includes(relative6)) {
+      response.writeHead(404);
+      return response.end("Not found");
+    }
+    return asset(response, join15(ASSET_ROOT, relative6));
+  });
+  await new Promise((resolve18, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, resolve18);
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  return { server, url: `http://${host}:${actualPort}`, payload };
+}
+
 // packages/cli/src/impact/format.mjs
+function formatImpactWarnings(warnings) {
+  if (!warnings?.total) return [];
+  return [
+    `Reference warnings: ${warnings.total} (${warnings.omitted} omitted); broken references excluded from impact.`,
+    ...warnings.items.map((item) => `- ${item.source}${item.line ? `:${item.line}` : ""} -> ${item.target} [${item.reason}]${item.reason === "REFERENCE_UNAVAILABLE" ? " (access uncertain; not excluded)" : ""}`)
+  ];
+}
 function formatCompactImpactGroup(name, group) {
   const items = group?.items ?? [];
   if (items.length === 0) return [];
@@ -5337,6 +5631,7 @@ function formatCompactImpactGroup(name, group) {
 function formatCompactImpactOutput(payload, impact) {
   const refreshNote = payload.metadata.cacheRefreshed ? ", refreshed" : "";
   const lines = [`graph impact compact: ${impact.related.length} related node(s), ${impact.omittedRelated ?? 0} omitted (${payload.status.status}${refreshNote} index)`, `changed files: ${(impact.changedFiles ?? [impact.changed]).join(", ")}`];
+  lines.push(...formatImpactWarnings(impact.warnings));
   for (const entry of impact.perSeed ?? []) lines.push(...formatCompactImpactGroup(`top for ${entry.changed}`, { items: entry.related }));
   for (const name of ["docs", "contracts", "tests", "files", "commands", "events", "packageResources", "symbols"]) lines.push(...formatCompactImpactGroup(name, impact.groups[name]));
   return lines.join("\n");
@@ -5400,6 +5695,13 @@ function formatYmlImpactOutput(payload, impact) {
   }
   lines.push("  groups:");
   for (const name of ["docs", "contracts", "tests", "files", "commands", "events", "packageResources", "symbols"]) lines.push(...formatYmlImpactGroup(name, impact.groups[name]));
+  lines.push("  warnings:");
+  lines.push(`    total: ${impact.warnings?.total ?? 0}`, `    omitted: ${impact.warnings?.omitted ?? 0}`, "    items:");
+  if (!impact.warnings?.items?.length) lines.push("      []");
+  else for (const item of impact.warnings.items) {
+    lines.push(`      - source: ${ymlScalar(item.source)}`, `        target: ${ymlScalar(item.target)}`, `        target_path: ${ymlScalar(item.targetPath)}`, `        relation: ${ymlScalar(item.relation)}`, `        reason: ${ymlScalar(item.reason)}`);
+    if (item.line) lines.push(`        line: ${item.line}`);
+  }
   lines.push("  recommended_actions:");
   lines.push('    - "review_related_docs"');
   lines.push('    - "run_related_tests"');
@@ -5428,6 +5730,8 @@ function parseGraphOptions(argv) {
   const changed = [];
   let compact = false;
   let yml = false;
+  let host = "127.0.0.1";
+  let port = 0;
   for (let i = 0; i < argv.length; i += 1) {
     if (argv[i] === "--changed") {
       const next = argv[i + 1];
@@ -5437,19 +5741,36 @@ function parseGraphOptions(argv) {
       }
     } else if (argv[i] === "--compact") compact = true;
     else if (argv[i] === "--yml" || argv[i] === "--yaml") yml = true;
-    else filtered.push(argv[i]);
+    else if (argv[i] === "--host" && argv[i + 1] && !argv[i + 1].startsWith("-")) {
+      host = argv[i + 1];
+      i += 1;
+    } else if (argv[i] === "--port" && argv[i + 1] && !argv[i + 1].startsWith("-")) {
+      port = Number(argv[i + 1]);
+      i += 1;
+    } else filtered.push(argv[i]);
   }
   const options = parseCommon(filtered);
   options.changed = [...new Set(changed)];
   options.compact = compact;
   options.yml = yml;
+  options.host = host;
+  options.port = Number.isInteger(port) && port >= 0 && port <= 65535 ? port : NaN;
   return options;
 }
 async function runGraph(argv) {
   const sub = argv[0];
   const isImpact = sub === "impact";
-  if (!["impact", "communities"].includes(sub)) usage(sub ? `Unknown graph command: ${sub}` : "Missing graph command.", "graph");
+  const isServe = sub === "serve";
+  if (!["impact", "communities", "serve"].includes(sub)) usage(sub ? `Unknown graph command: ${sub}` : "Missing graph command.", "graph");
   const options = parseGraphOptions(argv.slice(1));
+  if (isServe && options.changed.length === 0) usage("Missing required option: --changed <path>.", "graph serve");
+  if (isServe && !Number.isInteger(options.port)) usage("Invalid --port. Use an integer from 0 through 65535.", "graph serve");
+  if (isServe) {
+    options.changed = [...new Set(options.changed.map((path) => canonicalizeChangedPath(options.root, path)).filter(Boolean))];
+    const running = await startImpactGraphServer({ root: options.root, changed: options.changed, host: options.host, port: options.port });
+    console.log(`graph serve: ${running.url}`);
+    return;
+  }
   if (isImpact && [options.json, options.compact, options.yml].filter(Boolean).length > 1) {
     const message = "Choose only one graph impact output mode: --compact, --json, or --yml/--yaml.";
     if (options.json) console.log(JSON.stringify({ ok: false, command: "graph impact", compact: options.compact || void 0, yml: options.yml || void 0, root: options.root, error: { code: "OUTPUT_MODE_CONFLICT", message }, usage: commandUsage("graph impact") }, null, 2));
@@ -5484,14 +5805,14 @@ async function runGraph(argv) {
   if (isImpact) options.changed = [...new Set(options.changed.map((path) => canonicalizeChangedPath(options.root, path)).filter(Boolean))];
   const { status, index, metadata } = readFreshIndex(options.root);
   const overlay = isImpact ? await buildVectorImpactOverlay(options.root, index, options.changed) : void 0;
-  const rawImpact = isImpact ? buildImpactReport(index, options.changed, { overlay, verboseSemantic: options.json }) : void 0;
+  const rawImpact = isImpact ? buildImpactReport(index, options.changed, { root: options.root, overlay, verboseSemantic: options.json }) : void 0;
   const impact = isImpact && (options.compact || options.yml) ? buildCompactImpactReport(rawImpact) : rawImpact;
   const payload = isImpact ? { ok: status.ok, command: "graph impact", compact: options.compact || void 0, root: options.root, status, metadata, changed: options.changed[0], changedFiles: options.changed, related: impact.related, impact } : { ok: status.ok, command: "graph communities", root: options.root, status, metadata, graph: graphSummary(index), communities: buildCommunities(index) };
   const refreshNote = metadata.cacheRefreshed ? ", refreshed" : "";
   if (options.json) console.log(JSON.stringify(payload, null, 2));
   else if (isImpact && options.yml) console.log(formatYmlImpactOutput(payload, impact));
   else if (isImpact && options.compact) console.log(formatCompactImpactOutput(payload, impact));
-  else if (isImpact) console.log(`graph impact: ${payload.related.length} related node(s), ${impact.omittedRelated ?? 0} omitted (${status.status}${refreshNote} index)`);
+  else if (isImpact) console.log([`graph impact: ${payload.related.length} related node(s), ${impact.omittedRelated ?? 0} omitted (${status.status}${refreshNote} index)`, ...formatImpactWarnings(impact.warnings)].join("\n"));
   else console.log(`graph communities: ${payload.communities.communities.length}/${payload.communities.total} shown, ${payload.communities.omitted} omitted (${status.status}${refreshNote} index)`);
 }
 

package/mcp/server.mjs

@@ -21745,7 +21745,13 @@ var ContextStore = class {
     }
     const filterSql = filters.length ? ` AND ${filters.join(" AND ")}` : "";
     const select = "SELECT c.source_id, c.ordinal, c.body, s.label, s.kind, s.scope, s.metadata";
-    const porterRows = this.db.prepare(`
+    const wildcard = String(query ?? "").trim() === "*";
+    const porterRows = wildcard ? this.db.prepare(`
+      ${select}, 0 AS rank
+      FROM chunks c JOIN sources s ON s.id = c.source_id
+      WHERE 1 = 1${filterSql}
+      ORDER BY s.created_at DESC, s.id, c.ordinal LIMIT ?
+    `).all(...filterParams, candidateLimit) : this.db.prepare(`
       ${select}, bm25(chunks) AS rank
       FROM chunks c JOIN sources s ON s.id = c.source_id
       WHERE chunks MATCH ?${filterSql}
@@ -21764,7 +21770,7 @@ var ContextStore = class {
     `).all(...labelParams, ...filterParams, candidateLimit);
     const typoWindow = Math.min(500, candidateLimit * 5);
     const typoHalf = Math.max(1, Math.floor(typoWindow / 2));
-    const trigramRows = this.db.prepare(`
+    const trigramRows = wildcard ? [] : this.db.prepare(`
       SELECT * FROM (
         SELECT ${select.replace("SELECT ", "")}, 0 AS rank
         FROM chunks c JOIN sources s ON s.id = c.source_id
@@ -21788,7 +21794,7 @@ var ContextStore = class {
       return { sourceId: row.source_id, ordinal: Number(row.ordinal), body: row.body, label: row.label, kind: row.kind, scope: row.scope, rank: row.rank, metadata: readProvenanceMetadata(storedMetadata) };
     };
     const fused = reciprocalRankFusion([
-      { name: "porter-bm25", candidates: porterRows.map(toCandidate) },
+      { name: wildcard ? "bounded-browse" : "porter-bm25", candidates: porterRows.map(toCandidate) },
       { name: "label-path", candidates: labelRows.map(toCandidate) },
       { name: "trigram-v1", candidates: trigramRows.map(toCandidate) }
     ], { limit: candidateLimit });
@@ -21801,7 +21807,7 @@ var ContextStore = class {
         scope: row.scope,
         ordinal: row.ordinal,
         rank: row.rank,
-        text: excerpt(row.body, query),
+        text: excerpt(row.body, wildcard ? "" : query),
         metadata: row.metadata,
         trust: row.metadata.trust,
         sourceType: row.metadata.sourceType,
@@ -23426,7 +23432,7 @@ register("index", "Index a local text file or bounded directory into the project
   maxFiles: external_exports.number().int().nonnegative().optional(),
   maxAggregateBytes: external_exports.number().int().nonnegative().optional()
 }, (input, extra) => ({ ok: true, ...indexFile(getStore(), { ...input, root }, sessionId, extra.signal) }), { readOnlyHint: true });
-register("search", "Search indexed command, file, and fetched content and return bounded excerpts.", {
+register("search", "Search indexed content for bounded excerpts. For failure diagnostics try fail OR error OR reason. Query * browses bounded excerpts with the same source/scope/session filters and limit; neither no matches nor partial excerpts prove diagnostics are absent.", {
   query: external_exports.string().min(1),
   scope: scopeSchema,
   source: external_exports.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdotgod/claude-code",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Claude Code adapter for dotdotgod project memory workflows.",
   "type": "module",
   "license": "Elastic-2.0",
@@ -25,7 +25,7 @@
   },
   "devDependencies": {
     "esbuild": "0.27.3",
-    "@dotdotgod/context": "0.3.10"
+    "@dotdotgod/context": "0.3.12"
   },
   "files": [
     ".claude-plugin",