@inerrata-corporation/errata 2.0.0-dev.88 → 2.0.0-dev.90

package/errata.mjs

@@ -919,6 +919,20 @@ function normalizeToolName(raw2) {
 function operatingSystemCanonicalId(name2) {
   return genericCanonicalId("OperatingSystem", { name: name2.trim().toLowerCase() });
 }
+function osNameForPlatform(platform) {
+  switch (platform) {
+    case "win32":
+      return OS_NAME.windows;
+    case "darwin":
+      return OS_NAME.macos;
+    case "linux":
+      return OS_NAME.linux;
+    case "android":
+      return OS_NAME.android;
+    default:
+      return null;
+  }
+}
 function packageCanonicalId(p) {
   const eco = p.ecosystem.toLowerCase();
   const name2 = eco === "npm" ? p.name.toLowerCase() : p.name;
@@ -939,7 +953,7 @@ function parsePackageRef(ref) {
   const slug2 = (version2 ? `${name2}@${version2}` : name2).toLowerCase();
   return { name: name2, version: version2, slug: slug2 };
 }
-var DESIGN_PROBLEM_PREFIX, DESIGN_PROBLEM_ID_LENGTH, DIAGNOSTIC_PROBLEM_PREFIX, DIAGNOSTIC_HASH_LENGTH, TRIAGE_PREFIX, TRIAGE_ID_LENGTH, SAFE_TOOL_NAME;
+var DESIGN_PROBLEM_PREFIX, DESIGN_PROBLEM_ID_LENGTH, DIAGNOSTIC_PROBLEM_PREFIX, DIAGNOSTIC_HASH_LENGTH, TRIAGE_PREFIX, TRIAGE_ID_LENGTH, SAFE_TOOL_NAME, OS_NAME;
 var init_identity = __esm({
   "../../packages/shared/src/identity.ts"() {
     "use strict";
@@ -953,6 +967,12 @@ var init_identity = __esm({
     TRIAGE_PREFIX = "dtri_";
     TRIAGE_ID_LENGTH = 56;
     SAFE_TOOL_NAME = /^[a-z0-9][a-z0-9._+-]{0,63}$/;
+    OS_NAME = {
+      windows: "Windows",
+      macos: "macOS",
+      linux: "Linux",
+      android: "Android"
+    };
   }
 });
 
@@ -15894,6 +15914,7 @@ __export(src_exports, {
   MAX_NODES_PER_PAYLOAD: () => MAX_NODES_PER_PAYLOAD,
   MAX_SIDECAR_SYMBOLS: () => MAX_SIDECAR_SYMBOLS,
   MAX_SYMBOL_SUMMARY_CHARS: () => MAX_SYMBOL_SUMMARY_CHARS,
+  OS_NAME: () => OS_NAME,
   PAGERANK_EXCLUSIONS: () => PAGERANK_EXCLUSIONS,
   PROBLEM_RESOLUTION: () => PROBLEM_RESOLUTION,
   PROJECT_ONLY_EDGE_TYPES: () => PROJECT_ONLY_EDGE_TYPES,
@@ -15951,6 +15972,7 @@ __export(src_exports, {
   normalizeToolName: () => normalizeToolName,
   npmPurl: () => npmPurl,
   operatingSystemCanonicalId: () => operatingSystemCanonicalId,
+  osNameForPlatform: () => osNameForPlatform,
   packageCanonicalId: () => packageCanonicalId,
   pagerankEdgeTypes: () => pagerankEdgeTypes,
   parsePackageLockJson: () => parsePackageLockJson,
@@ -16002,7 +16024,7 @@ function writeManagedBlock(filePath, opts) {
   const newBody = opts.body.trim();
   const newHash = blockHash(newBody);
   const generated = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const startMarker = `<!-- ERRATA:START version=2 generated=${generated} hash=${newHash} -->`;
+  const startMarker = opts.stable ? `<!-- ERRATA:START version=2 hash=${newHash} -->` : `<!-- ERRATA:START version=2 generated=${generated} hash=${newHash} -->`;
   const endMarker = `<!-- ERRATA:END -->`;
   const blockText = `${startMarker}
 
@@ -16031,6 +16053,9 @@ ${blockText}`, "utf8");
   if (expectedHash && expectedHash !== actualHash && !opts.force) {
     return { kind: "collision", expectedHash, actualHash };
   }
+  if (opts.stable && existingBody === newBody && startM[0] === startMarker) {
+    return { kind: "written", previousHash: actualHash, newHash };
+  }
   const before = current.slice(0, startM.index);
   const after = current.slice(endM.index + endM[0].length).replace(/^\s*/, "");
   const written = after ? `${before}${blockText.trim()}
@@ -16040,21 +16065,6 @@ ${after}` : `${before}${blockText.trim()}
   writeFileSync(filePath, written, "utf8");
   return { kind: "written", previousHash: expectedHash ?? null, newHash };
 }
-function readManagedBlock(filePath) {
-  if (!existsSync(filePath)) return null;
-  const current = readFileSync(filePath, "utf8");
-  const startM = current.match(START_RE);
-  const endM = current.match(END_RE);
-  if (!startM || !endM || startM.index === void 0 || endM.index === void 0) {
-    return null;
-  }
-  return current.slice(startM.index + startM[0].length, endM.index).trim();
-}
-function readManagedBlockWithHash(filePath) {
-  const body2 = readManagedBlock(filePath);
-  if (body2 === null) return null;
-  return { body: body2, hash: sha256(body2).slice(0, 16) };
-}
 var START_RE, END_RE, blockHash;
 var init_agents_md = __esm({
   "../../packages/context-writer/src/agents-md.ts"() {
@@ -16066,9 +16076,57 @@ var init_agents_md = __esm({
   }
 });
 
-// ../../packages/context-writer/src/redirectors.ts
-import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+// ../../packages/context-writer/src/context-file.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname, join } from "node:path";
+function contextFilePath(root) {
+  return join(root, ".errata", "context.md");
+}
+function writeContextFile(root, body2) {
+  const path2 = contextFilePath(root);
+  mkdirSync(dirname(path2), { recursive: true });
+  const text = `${body2.trim()}
+`;
+  writeFileSync2(path2, text, "utf8");
+  return contextHash(text);
+}
+function contextHash(body2) {
+  return sha256(body2.replace(/\r\n?/g, "\n").trim()).slice(0, 16);
+}
+function readContextFileWithHash(root) {
+  const path2 = contextFilePath(root);
+  if (!existsSync2(path2)) return null;
+  try {
+    const raw2 = readFileSync2(path2, "utf8");
+    const body2 = raw2.trim();
+    if (!body2) return null;
+    return { body: body2, hash: contextHash(raw2) };
+  } catch {
+    return null;
+  }
+}
+var AGENTS_POINTER_BODY;
+var init_context_file = __esm({
+  "../../packages/context-writer/src/context-file.ts"() {
+    "use strict";
+    init_src();
+    AGENTS_POINTER_BODY = [
+      "## Errata context",
+      "",
+      "Live agent context for this checkout \u2014 priors, open problems, the capture",
+      "protocol \u2014 is maintained by the errata daemon at `.errata/context.md`.",
+      "",
+      "It is gitignored ON PURPOSE: it is this machine's runtime state, not repo",
+      "content. Committing it would prime your teammates with your graph.",
+      "",
+      "@.errata/context.md"
+    ].join("\n");
+  }
+});
+
+// ../../packages/context-writer/src/redirectors.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
 function defaultRedirectors() {
   return [
     {
@@ -16100,13 +16158,13 @@ function installRedirectors(workspaceRoot, redirectors = defaultRedirectors()) {
   const written = [];
   const skipped = [];
   for (const r of redirectors) {
-    const abs = join(workspaceRoot, r.relPath);
-    if (existsSync2(abs)) {
+    const abs = join2(workspaceRoot, r.relPath);
+    if (existsSync3(abs)) {
       skipped.push(r.relPath);
       continue;
     }
-    mkdirSync(dirname(abs), { recursive: true });
-    writeFileSync2(abs, r.content, "utf8");
+    mkdirSync2(dirname2(abs), { recursive: true });
+    writeFileSync3(abs, r.content, "utf8");
     written.push(r.relPath);
   }
   return { written, skipped };
@@ -20352,6 +20410,100 @@ var init_problem_dedup = __esm({
   }
 });
 
+// ../../packages/local-graph/src/tools.ts
+function toolNodeId(name2) {
+  return `tool:${name2}`;
+}
+function osNodeId(name2) {
+  return `os:${name2.toLowerCase()}`;
+}
+function resolveOsNode(store, osName, ts) {
+  const id = osNodeId(osName);
+  const existing = store.getNode(id);
+  if (existing) return existing;
+  const node2 = {
+    id,
+    label: "OperatingSystem",
+    description: osName,
+    extractionConfidence: 1,
+    extractionSource: "daemon-extracted",
+    embedding: [],
+    cumulativeSurprise: 0,
+    peakSurprise: 0,
+    cumulativeHits: 0,
+    lastUpdatedAt: ts,
+    createdAt: ts,
+    memoryTier: "short-term",
+    pageRank: 0,
+    isLandmark: false,
+    community: null,
+    stability: "stable",
+    attrs: { name: osName, canonicalId: operatingSystemCanonicalId(osName), public: true }
+  };
+  store.mergeNode(node2);
+  return node2;
+}
+function stampObservedOs(store, nodeId, osName, ts) {
+  if (!osName || !store.getNode(nodeId)) return false;
+  const os2 = resolveOsNode(store, osName, ts);
+  const already = store.outEdges(nodeId, ["OCCURS_ON"]).some((e) => e.to === os2.id);
+  if (already) return true;
+  store.mergeEdge({
+    id: `edge_${digest({ from: nodeId, type: "OCCURS_ON", to: os2.id })}`.slice(0, 24),
+    from: nodeId,
+    to: os2.id,
+    type: "OCCURS_ON",
+    confidence: 1,
+    // observed, not inferred — we ran on this platform
+    extractionSource: "daemon-extracted",
+    createdAt: ts,
+    lastSeenAt: ts,
+    navSuccesses: 0,
+    navFailures: 0,
+    attrs: { observed: true }
+  });
+  return true;
+}
+function rankToolsForHandles(store, limit = 5) {
+  const scored = store.findNodesByLabel("Tool").map((node2) => ({
+    node: node2,
+    concerns: store.inEdges(node2.id, ["CONCERNS"]).length,
+    hits: node2.cumulativeHits ?? 0
+  }));
+  scored.sort((a, b) => b.concerns - a.concerns || b.hits - a.hits);
+  return scored.slice(0, Math.max(0, limit)).map((s) => s.node);
+}
+function toolPriorsFor(store, toolName, ctx, limit = 4) {
+  const tool = store.getNode(toolNodeId(toolName));
+  if (!tool) return [];
+  const pkgs = ctx.workspacePackageIds ?? /* @__PURE__ */ new Set();
+  const fits = [];
+  for (const e of store.inEdges(tool.id, ["CONCERNS"])) {
+    const node2 = store.getNode(e.from);
+    if (!node2) continue;
+    if (node2.attrs["resolvedAs"] === "false_positive") continue;
+    const observedOn = store.outEdges(node2.id, ["OCCURS_ON"]).map((oe) => store.getNode(oe.to)?.description).filter((d) => !!d);
+    const osMismatch = observedOn.length > 0 && !!ctx.os && !observedOn.includes(ctx.os);
+    const deps = store.outEdges(node2.id, ["DEPENDS_ON"]).map((de) => de.to);
+    const stackHits = [];
+    const stackMisses = [];
+    for (const d of deps) {
+      const name2 = String(store.getNode(d)?.attrs["name"] ?? d);
+      (pkgs.has(d) ? stackHits : stackMisses).push(name2);
+    }
+    fits.push({ node: node2, observedOn, osMismatch, stackHits, stackMisses });
+  }
+  const rank = (f) => (f.osMismatch ? 0 : 2) + (f.stackHits.length > 0 ? 1 : 0);
+  fits.sort((a, b) => rank(b) - rank(a) || (b.node.cumulativeHits ?? 0) - (a.node.cumulativeHits ?? 0));
+  return fits.slice(0, Math.max(0, limit));
+}
+var init_tools = __esm({
+  "../../packages/local-graph/src/tools.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
 // ../../packages/local-graph/src/principle-sync.ts
 function asStrings(v) {
   return Array.isArray(v) ? v : [];
@@ -20514,6 +20666,7 @@ __export(src_exports2, {
   mergeDuplicateProblems: () => mergeDuplicateProblems,
   mintPatternNode: () => mintPatternNode,
   openGraphStore: () => openGraphStore,
+  osNodeId: () => osNodeId,
   parseAbstractionFences: () => parseAbstractionFences,
   parseSemver: () => parseSemver,
   parseTriageFences: () => parseTriageFences,
@@ -20522,6 +20675,7 @@ __export(src_exports2, {
   priorsForFile: () => priorsForFile,
   propagateFactChange: () => propagateFactChange,
   propagateVersionChange: () => propagateVersionChange,
+  rankToolsForHandles: () => rankToolsForHandles,
   recordAnchorHint: () => recordAnchorHint,
   recordClaim: () => recordClaim,
   recordMisreadPrior: () => recordMisreadPrior,
@@ -20531,13 +20685,17 @@ __export(src_exports2, {
   resolveDesignProblemById: () => resolveDesignProblemById,
   resolveDesignProblemByStatement: () => resolveDesignProblemByStatement,
   resolveDesignProblems: () => resolveDesignProblems,
+  resolveOsNode: () => resolveOsNode,
   retractDesignProblemById: () => retractDesignProblemById,
   retractDesignProblemByStatement: () => retractDesignProblemByStatement,
   revisitContradictedPrinciples: () => revisitContradictedPrinciples,
   revisitStaleRoutes: () => revisitStaleRoutes,
   solutionForProblem: () => solutionForProblem,
   splittingAxis: () => splittingAxis,
+  stampObservedOs: () => stampObservedOs,
   staticConductance: () => staticConductance,
+  toolNodeId: () => toolNodeId,
+  toolPriorsFor: () => toolPriorsFor,
   triageOf: () => triageOf,
   walk: () => walk
 });
@@ -20560,6 +20718,7 @@ var init_src4 = __esm({
     init_triage2();
     init_problem_dedup();
     init_problem_package_link();
+    init_tools();
     init_principle_sync();
   }
 });
@@ -20628,7 +20787,7 @@ function buildSnapshot(opts) {
   };
   const langNodes = opts.store.findNodesByLabel("Language");
   const pkgNodes = opts.store.findNodesByLabel("Package");
-  const toolNodes = opts.store.findNodesByLabel("Tool").sort((a, b) => (b.cumulativeHits ?? 0) - (a.cumulativeHits ?? 0)).slice(0, 5);
+  const toolNodes = rankToolsForHandles(opts.store, 5);
   const profileContext = {
     languages: opts.profile.languages.map((name2) => ({ name: name2, node: matchNode(langNodes, name2) })),
     packages: opts.profile.stack.map((name2) => ({ name: name2, node: matchNode(pkgNodes, pkgBase(name2)) })),
@@ -20995,8 +21154,8 @@ var init_bleed_memory = __esm({
 });
 
 // ../../packages/context-writer/src/bleed-rules.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join3 } from "node:path";
 function formatRuleFile(item) {
   const frontmatter = item.paths && item.paths.length > 0 ? `---
 paths:
@@ -21009,21 +21168,21 @@ ${item.body.trim()}
 `;
 }
 function bleedRules(rulesDir, items) {
-  if (!existsSync3(rulesDir)) mkdirSync2(rulesDir, { recursive: true });
+  if (!existsSync4(rulesDir)) mkdirSync3(rulesDir, { recursive: true });
   const wanted = new Map(items.map((i2) => [fileFor(i2.slug), i2]));
   let written = 0;
   let created = 0;
   for (const [file2, item] of wanted) {
-    const path2 = join2(rulesDir, file2);
-    if (!existsSync3(path2)) created++;
-    writeFileSync3(path2, formatRuleFile(item), "utf8");
+    const path2 = join3(rulesDir, file2);
+    if (!existsSync4(path2)) created++;
+    writeFileSync4(path2, formatRuleFile(item), "utf8");
     written++;
   }
   let pruned = 0;
   for (const f of readdirSync(rulesDir)) {
     if (!f.startsWith(PREFIX) || !f.endsWith(".md") || wanted.has(f)) continue;
-    if (readFileSync2(join2(rulesDir, f), "utf8").includes(MARKER)) {
-      rmSync(join2(rulesDir, f));
+    if (readFileSync3(join3(rulesDir, f), "utf8").includes(MARKER)) {
+      rmSync(join3(rulesDir, f));
       pruned++;
     }
   }
@@ -21110,6 +21269,7 @@ var init_src5 = __esm({
   "../../packages/context-writer/src/index.ts"() {
     "use strict";
     init_agents_md();
+    init_context_file();
     init_redirectors();
     init_render();
     init_bleed_memory();
@@ -22027,34 +22187,34 @@ __export(paths_exports, {
   workspaceDir: () => workspaceDir,
   workspacePaths: () => workspacePaths
 });
-import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname3, join as join4 } from "node:path";
 function globalDir() {
   const p = envPaths("errata", { suffix: "" });
   return p.config;
 }
 function globalConfigPath() {
-  return process.env["ERRATA_CONFIG_PATH"] ?? join3(globalDir(), "config.json");
+  return process.env["ERRATA_CONFIG_PATH"] ?? join4(globalDir(), "config.json");
 }
 function daemonLogPath() {
-  mkdirSync3(globalDir(), { recursive: true });
-  return join3(globalDir(), "daemon.log");
+  mkdirSync4(globalDir(), { recursive: true });
+  return join4(globalDir(), "daemon.log");
 }
 function globalDaemonLock() {
-  return process.env["ERRATA_DAEMON_LOCK"] ?? join3(globalDir(), "daemon.lock");
+  return process.env["ERRATA_DAEMON_LOCK"] ?? join4(globalDir(), "daemon.lock");
 }
 function sharedStorePath() {
-  return process.env["ERRATA_SHARED_DB"] ?? join3(globalDir(), "shared", "graph.db");
+  return process.env["ERRATA_SHARED_DB"] ?? join4(globalDir(), "shared", "graph.db");
 }
 function workspaceDir(workspaceRoot) {
-  return join3(workspaceRoot, ".errata");
+  return join4(workspaceRoot, ".errata");
 }
 function ensureDir(p) {
-  mkdirSync3(p, { recursive: true });
+  mkdirSync4(p, { recursive: true });
   return p;
 }
 function ensureParent(p) {
-  mkdirSync3(dirname2(p), { recursive: true });
+  mkdirSync4(dirname3(p), { recursive: true });
   return p;
 }
 function workspacePaths(root) {
@@ -22062,15 +22222,15 @@ function workspacePaths(root) {
   return {
     root,
     configDir: dir,
-    workspaceJson: join3(dir, "workspace.json"),
-    eventLog: join3(dir, "eventlog.sqlite"),
-    castalia: join3(dir, "castalia.db"),
-    reviewQueue: join3(dir, "review-queue.json"),
-    outbox: join3(dir, "outbox"),
-    daemonLock: join3(dir, "daemon.lock"),
-    identityAudit: join3(dir, "identity-audit.log"),
-    skillsDir: join3(dir, "skills"),
-    skillsManifest: join3(dir, "skills.json")
+    workspaceJson: join4(dir, "workspace.json"),
+    eventLog: join4(dir, "eventlog.sqlite"),
+    castalia: join4(dir, "castalia.db"),
+    reviewQueue: join4(dir, "review-queue.json"),
+    outbox: join4(dir, "outbox"),
+    daemonLock: join4(dir, "daemon.lock"),
+    identityAudit: join4(dir, "identity-audit.log"),
+    skillsDir: join4(dir, "skills"),
+    skillsManifest: join4(dir, "skills.json")
   };
 }
 var init_paths = __esm({
@@ -22081,7 +22241,7 @@ var init_paths = __esm({
 });
 
 // src/config.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function defaultConfig() {
   return {
@@ -22107,13 +22267,13 @@ function defaultConfig() {
 }
 function loadConfig() {
   const p = globalConfigPath();
-  if (!existsSync4(p)) {
+  if (!existsSync5(p)) {
     ensureDir(globalDir());
     const cfg = defaultConfig();
     saveConfig({ ...cfg, cloudUrl: DEFAULT_CLOUD_URL });
     return cfg;
   }
-  const raw2 = readFileSync3(p, "utf8").replace(/^\uFEFF/, "");
+  const raw2 = readFileSync4(p, "utf8").replace(/^\uFEFF/, "");
   const parsed = JSON.parse(raw2);
   const base = defaultConfig();
   const envCloudUrl = process.env["ERRATA_CLOUD_URL"];
@@ -22134,7 +22294,7 @@ function loadConfig() {
 }
 function saveConfig(cfg) {
   ensureDir(globalDir());
-  writeFileSync4(globalConfigPath(), JSON.stringify(cfg, null, 2), { encoding: "utf8", mode: 384 });
+  writeFileSync5(globalConfigPath(), JSON.stringify(cfg, null, 2), { encoding: "utf8", mode: 384 });
 }
 function machineId() {
   const fromEnv = process.env["ERRATA_MACHINE_ID"];
@@ -24766,17 +24926,17 @@ var init_agent_signals = __esm({
 });
 
 // src/review.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
 function loadReviewQueue(paths) {
-  if (!existsSync5(paths.reviewQueue)) return [];
+  if (!existsSync6(paths.reviewQueue)) return [];
   try {
-    return JSON.parse(readFileSync4(paths.reviewQueue, "utf8"));
+    return JSON.parse(readFileSync5(paths.reviewQueue, "utf8"));
   } catch {
     return [];
   }
 }
 function saveReviewQueue(paths, queue) {
-  writeFileSync5(paths.reviewQueue, JSON.stringify(queue, null, 2), "utf8");
+  writeFileSync6(paths.reviewQueue, JSON.stringify(queue, null, 2), "utf8");
 }
 function addProposal(paths, store, node2, reason, surprise) {
   const queue = loadReviewQueue(paths);
@@ -25374,9 +25534,9 @@ var init_dual_augment = __esm({
 });
 
 // ../../packages/embedding/src/model.ts
-import { mkdirSync as mkdirSync4, existsSync as existsSync6 } from "node:fs";
+import { mkdirSync as mkdirSync5, existsSync as existsSync7 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { dirname as dirname4, join as join5 } from "node:path";
 import { createRequire } from "node:module";
 function semanticFloorFor(version2) {
   if (version2 === EMBEDDING_VERSION || version2 === MODEL_EMBEDDING_VERSION) return 0.25;
@@ -25391,7 +25551,7 @@ function noteHashFallback() {
   );
 }
 function getCacheDir() {
-  return process.env["ERRATA_MODEL_CACHE"] ?? join4(homedir2(), ".errata", "models");
+  return process.env["ERRATA_MODEL_CACHE"] ?? join5(homedir2(), ".errata", "models");
 }
 async function loadTransformers() {
   try {
@@ -25400,9 +25560,9 @@ async function loadTransformers() {
     void err2;
   }
   try {
-    const seaResourceBase = join4(
+    const seaResourceBase = join5(
       // execPath dir is where errata.exe lives; resources/ rides alongside.
-      dirname3(process.execPath),
+      dirname4(process.execPath),
       "resources",
       "_resolve.js"
     );
@@ -25415,7 +25575,7 @@ async function loadTransformers() {
 }
 async function loadPipeline() {
   const cacheDir = getCacheDir();
-  if (!existsSync6(cacheDir)) mkdirSync4(cacheDir, { recursive: true });
+  if (!existsSync7(cacheDir)) mkdirSync5(cacheDir, { recursive: true });
   try {
     const tx = await loadTransformers();
     if (!tx) {
@@ -25705,7 +25865,7 @@ var init_diagnostic_matcher = __esm({
 });
 
 // ../../packages/generalizer/src/generalizer.ts
-import { isAbsolute, join as join5, relative } from "node:path";
+import { isAbsolute, join as join6, relative } from "node:path";
 async function runGeneralizer(opts) {
   const report = {
     eventsProcessed: 0,
@@ -25813,7 +25973,7 @@ function extractDiagnostics(ev) {
 function diagRelPath(file2, cwd, workspaceRoot) {
   const norm = (p) => p.replace(/\\/g, "/");
   if (!workspaceRoot) return norm(file2);
-  const abs = isAbsolute(file2) ? file2 : join5(cwd ?? workspaceRoot, file2);
+  const abs = isAbsolute(file2) ? file2 : join6(cwd ?? workspaceRoot, file2);
   return norm(relative(workspaceRoot, abs));
 }
 function extractErrorSignature(ev) {
@@ -27185,16 +27345,16 @@ var init_src10 = __esm({
 });
 
 // src/symbol-summaries.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join7 } from "node:path";
 function symbolSummariesPath(configDir) {
-  return join6(configDir, "symbol-summaries.json");
+  return join7(configDir, "symbol-summaries.json");
 }
 function loadSymbolSummaryCache(configDir) {
   const p = symbolSummariesPath(configDir);
-  if (existsSync7(p)) {
+  if (existsSync8(p)) {
     try {
-      const raw2 = JSON.parse(readFileSync5(p, "utf8"));
+      const raw2 = JSON.parse(readFileSync6(p, "utf8"));
       if (raw2 && raw2.version === 1 && raw2.entries && typeof raw2.entries === "object") {
         return { version: 1, entries: raw2.entries };
       }
@@ -27204,7 +27364,7 @@ function loadSymbolSummaryCache(configDir) {
   return { version: 1, entries: {} };
 }
 function saveSymbolSummaryCache(configDir, cache) {
-  writeFileSync6(symbolSummariesPath(configDir), JSON.stringify(cache, null, 2), "utf8");
+  writeFileSync7(symbolSummariesPath(configDir), JSON.stringify(cache, null, 2), "utf8");
 }
 function summariesByBodyHash(cache) {
   const m = /* @__PURE__ */ new Map();
@@ -27278,7 +27438,7 @@ function readSnippet(workspaceRoot, attrs) {
     return void 0;
   }
   try {
-    const buf = readFileSync5(join6(workspaceRoot, ...relPath.split("/")));
+    const buf = readFileSync6(join7(workspaceRoot, ...relPath.split("/")));
     const slice = buf.subarray(Math.max(0, startByte), Math.min(buf.length, endByte));
     const text = slice.toString("utf8");
     return text.length > MAX_SNIPPET_CHARS ? text.slice(0, MAX_SNIPPET_CHARS) : text;
@@ -27578,9 +27738,9 @@ var init_identity2 = __esm({
 });
 
 // ../../packages/indexer/src/pipeline.ts
-import { appendFileSync, readFileSync as readFileSync6, statSync } from "node:fs";
+import { appendFileSync, readFileSync as readFileSync7, statSync } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { extname, join as join7, relative as relative2, sep } from "node:path";
+import { extname, join as join8, relative as relative2, sep } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 import { execFileSync } from "node:child_process";
 function nowTs() {
@@ -27713,7 +27873,7 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   for (const rel of [...changedRelPaths]) {
     let h;
     try {
-      h = createHash3("sha256").update(readFileSync6(join7(rootPath, rel))).digest("hex");
+      h = createHash3("sha256").update(readFileSync7(join8(rootPath, rel))).digest("hex");
     } catch {
       continue;
     }
@@ -27760,13 +27920,13 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   let parsedFiles = 0;
   for (const rel of changedRelPaths) {
     if (parsedFiles++ > 0) await new Promise((r2) => setImmediate(r2));
-    const abs = join7(rootPath, ...rel.split("/"));
+    const abs = join8(rootPath, ...rel.split("/"));
     const ext = extname(abs).toLowerCase();
     const provider = providers.find((p) => p.fileExtensions.includes(ext));
     if (!provider) continue;
     let symbols;
     try {
-      symbols = provider.extractSymbols(readFileSync6(abs, "utf8"), abs);
+      symbols = provider.extractSymbols(readFileSync7(abs, "utf8"), abs);
     } catch {
       continue;
     }
@@ -28072,7 +28232,7 @@ async function runIndexer(store, opts) {
         report.filesSkipped++;
         continue;
       }
-      source = readFileSync6(f.absPath, "utf8");
+      source = readFileSync7(f.absPath, "utf8");
     } catch {
       report.filesSkipped++;
       continue;
@@ -28130,7 +28290,7 @@ async function runIndexer(store, opts) {
     const depth = fileNode.relPath.split("/").length;
     if (depth !== 3) continue;
     try {
-      const pkg = JSON.parse(readFileSync6(fileNode.absPath, "utf8"));
+      const pkg = JSON.parse(readFileSync7(fileNode.absPath, "utf8"));
       if (!pkg.name) continue;
       const pkgDir = fileNode.relPath.replace(/\/package\.json$/, "");
       const candidates = [
@@ -28512,7 +28672,7 @@ async function scan(root, current, ignores, providers, out2) {
   for (const ent of entries) {
     if (ignores.has(ent.name)) continue;
     if (ent.name.startsWith(".") && ent.name !== ".") continue;
-    const abs = join7(current, ent.name);
+    const abs = join8(current, ent.name);
     if (ent.isDirectory()) {
       await scan(root, abs, ignores, providers, out2);
     } else if (ent.isFile()) {
@@ -28558,7 +28718,7 @@ function gitListFiles(root, ignores, providers) {
     if (segs.some((s) => ignores.has(s) || s.startsWith(".") && s.length > 1)) {
       continue;
     }
-    const abs = join7(root, rel);
+    const abs = join8(root, rel);
     let size;
     try {
       size = statSync(abs).size;
@@ -28581,7 +28741,7 @@ function upsertFile(store, id, f, workspaceId2) {
   const now = nowTs();
   let contentHash;
   try {
-    contentHash = createHash3("sha256").update(readFileSync6(f.absPath)).digest("hex");
+    contentHash = createHash3("sha256").update(readFileSync7(f.absPath)).digest("hex");
   } catch {
   }
   const node2 = {
@@ -32944,42 +33104,42 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 
 // ../../packages/indexer/src/languages/tree-sitter-loader.ts
 import { fileURLToPath } from "node:url";
-import { dirname as dirname4, join as join8 } from "node:path";
-import { existsSync as existsSync8, readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname5, join as join9 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 function entryDir() {
   try {
     const url2 = import.meta?.url;
     if (typeof url2 === "string" && url2.length > 0) {
-      return dirname4(fileURLToPath(url2));
+      return dirname5(fileURLToPath(url2));
     }
   } catch {
   }
-  return dirname4(process.execPath);
+  return dirname5(process.execPath);
 }
 function findWasmDir() {
   const here = entryDir();
-  const seaWasm = join8(here, "resources", "wasm");
-  if (existsSync8(join8(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
+  const seaWasm = join9(here, "resources", "wasm");
+  if (existsSync9(join9(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join8(
+    const flat = join9(
       dir,
       "node_modules",
       "@vscode",
       "tree-sitter-wasm",
       "wasm"
     );
-    if (existsSync8(join8(flat, "tree-sitter-typescript.wasm"))) return flat;
-    dir = dirname4(dir);
+    if (existsSync9(join9(flat, "tree-sitter-typescript.wasm"))) return flat;
+    dir = dirname5(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join8(root, "node_modules", ".pnpm");
-    if (existsSync8(pnpmDir)) {
+    const pnpmDir = join9(root, "node_modules", ".pnpm");
+    if (existsSync9(pnpmDir)) {
       for (const entry of readdirSync2(pnpmDir)) {
         if (entry.startsWith("@vscode+tree-sitter-wasm@")) {
-          const candidate = join8(
+          const candidate = join9(
             pnpmDir,
             entry,
             "node_modules",
@@ -32987,13 +33147,13 @@ function findWasmDir() {
             "tree-sitter-wasm",
             "wasm"
           );
-          if (existsSync8(join8(candidate, "tree-sitter-typescript.wasm"))) {
+          if (existsSync9(join9(candidate, "tree-sitter-typescript.wasm"))) {
             return candidate;
           }
         }
       }
     }
-    root = dirname4(root);
+    root = dirname5(root);
   }
   throw new Error(
     "@vscode/tree-sitter-wasm grammar files not found \u2014 is the package installed?"
@@ -33001,33 +33161,33 @@ function findWasmDir() {
 }
 function findRuntimeDir() {
   const here = entryDir();
-  const seaRuntime = join8(here, "resources", "wasm");
-  if (existsSync8(join8(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
+  const seaRuntime = join9(here, "resources", "wasm");
+  if (existsSync9(join9(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join8(dir, "node_modules", "web-tree-sitter");
-    if (existsSync8(join8(flat, "web-tree-sitter.wasm"))) return flat;
-    dir = dirname4(dir);
+    const flat = join9(dir, "node_modules", "web-tree-sitter");
+    if (existsSync9(join9(flat, "web-tree-sitter.wasm"))) return flat;
+    dir = dirname5(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join8(root, "node_modules", ".pnpm");
-    if (existsSync8(pnpmDir)) {
+    const pnpmDir = join9(root, "node_modules", ".pnpm");
+    if (existsSync9(pnpmDir)) {
       for (const entry of readdirSync2(pnpmDir)) {
         if (entry.startsWith("web-tree-sitter@")) {
-          const candidate = join8(
+          const candidate = join9(
             pnpmDir,
             entry,
             "node_modules",
             "web-tree-sitter"
           );
-          if (existsSync8(join8(candidate, "web-tree-sitter.wasm"))) {
+          if (existsSync9(join9(candidate, "web-tree-sitter.wasm"))) {
             return candidate;
           }
         }
       }
     }
-    root = dirname4(root);
+    root = dirname5(root);
   }
   throw new Error("web-tree-sitter runtime WASM not found");
 }
@@ -33038,7 +33198,7 @@ async function loadWebTreeSitter() {
     void err2;
   }
   const here = entryDir();
-  const seaResourceBase = join8(here, "resources", "_resolve.js");
+  const seaResourceBase = join9(here, "resources", "_resolve.js");
   const resourceRequire = createRequire2(seaResourceBase);
   return resourceRequire("web-tree-sitter");
 }
@@ -33053,9 +33213,9 @@ async function ensureTreeSitterReady() {
     await Parser2.init({
       locateFile: (name2) => {
         if (name2 === "tree-sitter.wasm" || name2 === "web-tree-sitter.wasm") {
-          return join8(runtime, name2);
+          return join9(runtime, name2);
         }
-        return join8(grammars, name2);
+        return join9(grammars, name2);
       }
     });
   })();
@@ -33067,7 +33227,7 @@ async function loadGrammar(name2) {
   if (cached2) return cached2;
   if (!languageClass) throw new Error("tree-sitter not initialized");
   const grammars = findWasmDir();
-  const lang = await languageClass.load(join8(grammars, `${name2}.wasm`));
+  const lang = await languageClass.load(join9(grammars, `${name2}.wasm`));
   grammarCache.set(name2, lang);
   return lang;
 }
@@ -35969,7 +36129,7 @@ var init_src11 = __esm({
 // src/reconcile.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
-import { join as join9, relative as relative3, sep as sep2 } from "node:path";
+import { join as join10, relative as relative3, sep as sep2 } from "node:path";
 function gitSourceFiles(root) {
   let stdout;
   try {
@@ -35984,7 +36144,7 @@ function gitSourceFiles(root) {
   const out2 = [];
   for (const rel of stdout.split("\0")) {
     if (!rel || !SOURCE_RE.test(rel)) continue;
-    const abs = join9(root, rel);
+    const abs = join10(root, rel);
     if (IGNORED.test(abs)) continue;
     out2.push(abs);
   }
@@ -35999,7 +36159,7 @@ function* walkSource(dir) {
   }
   for (const e of entries) {
     const name2 = String(e.name);
-    const full = join9(dir, name2);
+    const full = join10(dir, name2);
     if (IGNORED.test(full)) continue;
     if (e.isDirectory()) yield* walkSource(full);
     else if (SOURCE_RE.test(name2)) yield full;
@@ -36077,7 +36237,7 @@ __export(mcp_exports, {
   runTool: () => runTool,
   searchGraph: () => searchGraph
 });
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
 import { resolve } from "node:path";
 function collectEnrichmentPulls(store, opts = {}) {
   const pending = store.findNodesByLabel("Solution").filter((s) => s.attrs["enrichmentPending"] === true).filter((s) => !opts.onlyUnsurfaced || s.attrs["enrichmentSurfaced"] !== true);
@@ -36190,10 +36350,10 @@ function showNode(store, node2, maxLines) {
   if (!relPath) return { found: false, reason: "no file owner for node" };
   const workspaceRoot = process.cwd();
   const absPath = resolve(workspaceRoot, relPath);
-  if (!existsSync9(absPath)) {
+  if (!existsSync10(absPath)) {
     return { found: false, reason: `file not found on disk: ${absPath}` };
   }
-  const source = readFileSync7(absPath, "utf8");
+  const source = readFileSync8(absPath, "utf8");
   const attrs = node2.attrs;
   let startByte = attrs["bodyStartByte"] ?? attrs["startByte"];
   let endByte = attrs["bodyEndByte"] ?? attrs["endByte"];
@@ -37426,7 +37586,7 @@ var init_mcp = __esm({
         inputSchema: { type: "object", properties: {} },
         handler: () => {
           const path2 = sharedStorePath();
-          if (!existsSync9(path2)) return { count: 0, pending: [] };
+          if (!existsSync10(path2)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const pending = pendingAbstractions(shared);
@@ -37457,7 +37617,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path2 = sharedStorePath();
-          if (!existsSync9(path2)) return { count: 0, routes: [] };
+          if (!existsSync10(path2)) return { count: 0, routes: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const result = triageOf(shared, {
@@ -37842,8 +38002,8 @@ __export(vfile_exports, {
   resolvePath: () => resolvePath,
   segmentsOf: () => segmentsOf
 });
-import { writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join10, resolve as resolve2, sep as sep3 } from "node:path";
+import { writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join11, resolve as resolve2, sep as sep3 } from "node:path";
 function segmentsOf(rawPath) {
   let p = rawPath.replace(/\\/g, "/");
   p = p.replace(/^.*\.errata\/g\//, "").replace(/^\/?g\//, "").replace(/^\/+/, "");
@@ -37917,14 +38077,14 @@ async function renderVFile(rawPath, store, ctx = {}) {
 }
 async function materializeVFile(rawPath, workspaceRoot, store, ctx = {}) {
   const segs = segmentsOf(rawPath);
-  const gRoot = join10(workspaceRoot, ".errata", "g");
+  const gRoot = join11(workspaceRoot, ".errata", "g");
   const abs = resolve2(gRoot, ...segs.length ? segs : ["index"]);
   if (abs !== gRoot && !abs.startsWith(gRoot + sep3)) {
     throw new Error(`refusing to materialize outside .errata/g: ${rawPath}`);
   }
   const text = await renderVFile(rawPath, store, ctx);
   ensureParent(abs);
-  writeFileSync7(abs, text, "utf8");
+  writeFileSync8(abs, text, "utf8");
   return abs;
 }
 async function materializeOverview(workspaceRoot, store, ctx = {}) {
@@ -45185,8 +45345,8 @@ var init_tldr_tools_generated = __esm({
 });
 
 // src/tool-index.ts
-function toolNodeId(name2) {
-  return `tool:${name2}`;
+function currentOsName() {
+  return osNameForPlatform(process.platform);
 }
 function extractExecutables(command) {
   const out2 = [];
@@ -45211,8 +45371,10 @@ function extractExecutables(command) {
 }
 function observeCommandTools(store, command, ts) {
   const result = { minted: [], reinforced: [] };
+  const osName = currentOsName();
   for (const name2 of extractExecutables(command)) {
     if (!PUBLIC_TOOLS.has(name2)) continue;
+    if (PLUMBING.has(name2)) continue;
     const id = toolNodeId(name2);
     const existing = store.getNode(id);
     if (existing) {
@@ -45245,17 +45407,60 @@ function observeCommandTools(store, command, ts) {
         attrs: { name: name2, canonicalId: toolCanonicalId(name2), public: true }
       });
       result.minted.push(name2);
+      if (osName) {
+        const os2 = resolveOsNode(store, osName, ts);
+        store.mergeEdge({
+          id: `edge_${digest({ from: id, type: "RUNS_ON", to: os2.id })}`.slice(0, 24),
+          from: id,
+          to: os2.id,
+          type: "RUNS_ON",
+          confidence: 1,
+          // observed
+          extractionSource: "daemon-extracted",
+          createdAt: ts,
+          lastSeenAt: ts,
+          navSuccesses: 0,
+          navFailures: 0,
+          attrs: { observed: true }
+        });
+      }
     }
   }
   return result;
 }
-var PUBLIC_TOOLS, PASSTHROUGH, SEGMENT_SPLIT;
+var PUBLIC_TOOLS, PLUMBING, PASSTHROUGH, SEGMENT_SPLIT;
 var init_tool_index = __esm({
   "src/tool-index.ts"() {
     "use strict";
     init_src();
+    init_src();
+    init_src4();
     init_tldr_tools_generated();
     PUBLIC_TOOLS = new Set(TLDR_TOOL_NAMES);
+    PLUMBING = /* @__PURE__ */ new Set([
+      "cd",
+      "pwd",
+      "ls",
+      "dir",
+      "echo",
+      "clear",
+      "cls",
+      "exit",
+      "true",
+      "false",
+      "which",
+      "where",
+      "alias",
+      "unalias",
+      "history",
+      "set",
+      "unset",
+      "export",
+      "source",
+      "sleep",
+      "time",
+      "type"
+    ]);
     PASSTHROUGH = /* @__PURE__ */ new Set(["sudo", "npx", "pnpx", "bunx", "uvx", "time", "nohup", "xargs", "watch"]);
     SEGMENT_SPLIT = /\|\|?|&&|;|\r?\n/;
   }
@@ -45263,25 +45468,25 @@ var init_tool_index = __esm({
 
 // src/outbox.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   renameSync,
   unlinkSync,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import { createHash as createHash11 } from "node:crypto";
 function enqueueOutbox(paths, payload) {
   ensureDir(paths.outbox);
   const id = createHash11("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 16);
-  const file2 = join11(paths.outbox, `${Date.now()}-${id}.json`);
-  writeFileSync8(file2, JSON.stringify(payload, null, 2), "utf8");
+  const file2 = join12(paths.outbox, `${Date.now()}-${id}.json`);
+  writeFileSync9(file2, JSON.stringify(payload, null, 2), "utf8");
   return file2;
 }
 async function flushOutbox(paths, client, store) {
   ensureDir(paths.outbox);
-  const entries = existsSync10(paths.outbox) ? readdirSync4(paths.outbox) : [];
+  const entries = existsSync11(paths.outbox) ? readdirSync4(paths.outbox) : [];
   let uploaded = 0;
   let failed = 0;
   const quarantine = (abs, reason) => {
@@ -45292,10 +45497,10 @@ async function flushOutbox(paths, client, store) {
     }
   };
   for (const f of entries.filter((e) => e.endsWith(".json")).sort()) {
-    const abs = join11(paths.outbox, f);
+    const abs = join12(paths.outbox, f);
     let payload;
     try {
-      payload = JSON.parse(readFileSync8(abs, "utf8"));
+      payload = JSON.parse(readFileSync9(abs, "utf8"));
     } catch {
       failed++;
       quarantine(abs, "unparseable JSON");
@@ -45340,7 +45545,7 @@ async function flushOutbox(paths, client, store) {
       }
     }
   }
-  const remainingFiles = existsSync10(paths.outbox) ? readdirSync4(paths.outbox).filter((e) => e.endsWith(".json")) : [];
+  const remainingFiles = existsSync11(paths.outbox) ? readdirSync4(paths.outbox).filter((e) => e.endsWith(".json")) : [];
   return { uploaded, failed, remaining: remainingFiles.length };
 }
 var init_outbox = __esm({
@@ -45357,9 +45562,9 @@ __export(webui_exports, {
   decideContextInject: () => decideContextInject,
   fileUriToFsPath: () => fileUriToFsPath,
   findFileByPath: () => findFileByPath,
-  recallForFile: () => recallForFile
+  recallForFile: () => recallForFile,
+  recallForTool: () => recallForTool
 });
-import { join as join12 } from "node:path";
 function fileUriToFsPath(raw2) {
   let p = raw2.replace(/^file:\/\//, "").replace(/\\/g, "/");
   if (/^\/[A-Za-z]:/.test(p)) p = p.slice(1);
@@ -45410,6 +45615,35 @@ function recallForFile(store, relPath) {
 ${lines.join("\n")}
 ` + buildFileRecallInstruction();
 }
+function workspacePackageIds(store) {
+  const hit = wsPackagesCache.get(store);
+  const now = Date.now();
+  if (hit && now - hit.at < WS_PACKAGES_TTL_MS) return hit.ids;
+  const ids = new Set(store.findNodesByLabel("Package").map((n) => n.id));
+  wsPackagesCache.set(store, { at: now, ids });
+  return ids;
+}
+function recallForTool(store, command, ctx) {
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name2 of extractExecutables(command)) {
+    if (seen.has(name2)) continue;
+    seen.add(name2);
+    for (const fit of toolPriorsFor(store, name2, ctx, 3)) {
+      const where = fit.osMismatch ? ` \`[${fit.observedOn.join("/")}]\`` : "";
+      const stack = fit.stackHits.length > 0 ? ` \`[${fit.stackHits.join(", ")}]\`` : "";
+      lines.push(
+        `- \`${name2}\`${where}${stack} ${recallLine(
+          fit.node,
+          fit.node.label === "Problem" ? `${TAG_EXAMPLE.fix(fit.node.id)} if you resolved it \xB7 ${TAG_EXAMPLE.prior(fit.node.id)} to cite` : `cite with ${TAG_EXAMPLE.prior(fit.node.id)}`
+        ).slice(2)}`
+      );
+    }
+  }
+  if (lines.length === 0) return null;
+  return `errata \u2014 ${lines.length} prior(s) about the tool(s) you're about to run (a \`[platform]\` tag means it was seen on a DIFFERENT OS than this one \u2014 judge it):
+${lines.join("\n")}`;
+}
 function decideContextInject(args2) {
   const { event, source, sessionId, block, lastInjectedHash } = args2;
   if (!block) return null;
@@ -45581,6 +45815,15 @@ function buildWebUi(deps) {
         }
         return c.json({ ok: true, materialized });
       }
+      if (tool === "Bash" && typeof input["command"] === "string") {
+        try {
+          recallCtx = recallForTool(deps.store, input["command"], {
+            os: currentOsName(),
+            workspacePackageIds: workspacePackageIds(deps.store)
+          });
+        } catch {
+        }
+      }
     }
     const filePath = extractWorkingFile(tool, input);
     let rel = null;
@@ -45672,6 +45915,11 @@ function buildWebUi(deps) {
       }
       return c.body(null, 204);
     }
+    if (event === "PreToolUse" && recallCtx) {
+      return c.json({
+        hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: recallCtx }
+      });
+    }
     return c.json({ ok: true, event, tool, recognizedFile: filePath ?? null });
   });
   app.post("/api/turn", async (c) => {
@@ -45728,7 +45976,7 @@ function buildWebUi(deps) {
     } catch {
       return c.json({});
     }
-    const block = readManagedBlockWithHash(join12(deps.paths.root, "AGENTS.md"));
+    const block = readContextFileWithHash(deps.paths.root);
     const decision = decideContextInject({
       event: String(body2["hook_event_name"] ?? "UserPromptSubmit"),
       source: String(body2["source"] ?? ""),
@@ -45918,7 +46166,7 @@ function proposalToIngest(p, profile, daemonVersion) {
     payloadDigest: p.id
   };
 }
-var META_LABELS;
+var wsPackagesCache, WS_PACKAGES_TTL_MS, META_LABELS;
 var init_webui = __esm({
   "src/webui.ts"() {
     "use strict";
@@ -45930,6 +46178,8 @@ var init_webui = __esm({
     init_vfile();
     init_tool_index();
     init_outbox();
+    wsPackagesCache = /* @__PURE__ */ new WeakMap();
+    WS_PACKAGES_TTL_MS = 6e4;
     META_LABELS = /* @__PURE__ */ new Set([
       "Pattern",
       "Technique",
@@ -46331,12 +46581,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src5();
-import { closeSync as closeSync2, existsSync as existsSync23, openSync as openSync2, readFileSync as readFileSync21, renameSync as renameSync3, statSync as statSync6 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync24, openSync as openSync2, readFileSync as readFileSync22, renameSync as renameSync3, statSync as statSync6 } from "node:fs";
 import { join as join26 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync18, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync19, writeFileSync as writeFileSync15 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.8/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -46916,7 +47166,7 @@ init_config();
 
 // src/engine.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync17, statSync as statSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync8, renameSync as renameSync2, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync18, statSync as statSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync8, renameSync as renameSync2, readFileSync as readFileSync17, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join22, relative as relative6, sep as sep4 } from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
@@ -47648,9 +47898,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname9 = sysPath.dirname(file2);
+    const dirname10 = sysPath.dirname(file2);
     const basename5 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname9);
+    const parent = this.fsw._getWatchedDir(dirname10);
     let prevStats = stats;
     if (parent.has(basename5))
       return;
@@ -47677,7 +47927,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname9, basename5);
+          this.fsw._remove(dirname10, basename5);
         }
       } else if (parent.has(basename5)) {
         const at = newStats.atimeMs;
@@ -48779,8 +49029,8 @@ init_src10();
 init_review2();
 
 // src/turn.ts
-import { closeSync, existsSync as existsSync11, fstatSync, openSync, readdirSync as readdirSync5, readSync, statSync as statSync3 } from "node:fs";
-import { basename as basename3, dirname as dirname7, join as join15 } from "node:path";
+import { closeSync, existsSync as existsSync12, fstatSync, openSync, readdirSync as readdirSync5, readSync, statSync as statSync3 } from "node:fs";
+import { basename as basename3, dirname as dirname8, join as join15 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function readTail(path2, maxBytes) {
   let fd;
@@ -48923,7 +49173,7 @@ function claudeProjectDir(cwd, home = homedir3()) {
 }
 function recentTranscripts(cwd, opts = {}) {
   const dir = claudeProjectDir(cwd, opts.home ?? homedir3());
-  if (!existsSync11(dir)) return [];
+  if (!existsSync12(dir)) return [];
   let names;
   try {
     names = readdirSync5(dir);
@@ -48949,8 +49199,8 @@ function recentTranscripts(cwd, opts = {}) {
 }
 function subagentTranscripts(mainTranscriptPath, sessionId) {
   if (!mainTranscriptPath || !sessionId) return [];
-  const dir = join15(dirname7(mainTranscriptPath), sessionId, "subagents");
-  if (!existsSync11(dir)) return [];
+  const dir = join15(dirname8(mainTranscriptPath), sessionId, "subagents");
+  if (!existsSync12(dir)) return [];
   let names;
   try {
     names = readdirSync5(dir);
@@ -48977,7 +49227,9 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
 init_src();
 init_src2();
 init_agent_signals();
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "node:fs";
+init_tool_index();
+init_src4();
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
 var NEG = /n['']t|\b(?:not|never|no|none|neither|nor|unrelated|irrelevant|would|might|could|if)\b/i;
 var CITE_GROUP_RE = /\(((?:[^()\n]|\([^()\n]*\)){1,200})\)/g;
 var HANDLE_RE = /\[([a-z0-9][\w-]{0,40})\]|((?:pat|sol|drc|dcause|dfix|dprob|prob|claim|err)_[0-9a-f]{6,})/gi;
@@ -49265,13 +49517,13 @@ function writePrimingHandles(path2, nodes, now = Date.now()) {
       entries.sort((a, b) => (b[1].seenAt ?? 0) - (a[1].seenAt ?? 0));
       entries.length = HANDLE_MAP_MAX;
     }
-    writeFileSync9(path2, JSON.stringify(Object.fromEntries(entries)));
+    writeFileSync10(path2, JSON.stringify(Object.fromEntries(entries)));
   } catch {
   }
 }
 function readPrimingHandles(path2) {
   try {
-    return JSON.parse(readFileSync9(path2, "utf8"));
+    return JSON.parse(readFileSync10(path2, "utf8"));
   } catch {
     return {};
   }
@@ -49304,6 +49556,7 @@ function mintPriorEdge(store, source, target, sentence, touched, ts) {
     navFailures: 0,
     attrs: { provisional: true, priorTag: true, primingProvenance: true, corroborated }
   });
+  if (type === "CONCERNS") stampObservedOs(store, source.id, currentOsName(), ts);
   return true;
 }
 function harvestInlineTags(store, text, opts) {
@@ -49754,11 +50007,11 @@ init_outbox();
 init_src8();
 init_src();
 init_src2();
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 import { join as join16 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync10(join16(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync11(join16(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -50062,11 +50315,11 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11, watch as fsWatch } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync12, watch as fsWatch } from "node:fs";
 import { join as join17 } from "node:path";
 function readFirstLine(path2) {
   try {
-    return readFileSync11(path2, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync12(path2, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
@@ -50085,13 +50338,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync12(join17(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync12(join17(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync13(join17(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync13(join17(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync11(join17(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync12(join17(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -50125,7 +50378,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync12(join17(gitDir, "index.lock"))) {
+      if (existsSync13(join17(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -50361,21 +50614,21 @@ var TelemetryRecorder = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync12,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync13,
   readdirSync as readdirSync6,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "node:fs";
 import { basename as basename4, join as join18 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync13(manifestPath)) return [];
+  if (!existsSync14(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync12(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync13(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -50389,7 +50642,7 @@ function readSkillManifest(manifestPath) {
 async function syncSkills(paths, client, seed, pins = []) {
   const res = await client.getSkills(void 0, seed);
   const staleDaemon = res.staleDaemon && res.latestDaemonVersion ? { latest: res.latestDaemonVersion } : void 0;
-  mkdirSync5(paths.skillsDir, { recursive: true });
+  mkdirSync6(paths.skillsDir, { recursive: true });
   if (res.skills.length === 0 && pins.length === 0) {
     const existing = readdirSync6(paths.skillsDir).filter((f) => f.endsWith(".md"));
     if (existing.length > 0) return { written: 0, pruned: 0, ...staleDaemon ? { staleDaemon } : {} };
@@ -50399,7 +50652,7 @@ async function syncSkills(paths, client, seed, pins = []) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync10(join18(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync11(join18(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -50412,7 +50665,7 @@ async function syncSkills(paths, client, seed, pins = []) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync10(join18(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync11(join18(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -50432,7 +50685,7 @@ async function syncSkills(paths, client, seed, pins = []) {
     }
   }
   rows.sort((a, b) => a.id.localeCompare(b.id));
-  writeFileSync10(
+  writeFileSync11(
     paths.skillsManifest,
     JSON.stringify({ generatedAt: Date.now(), skills: rows }, null, 2),
     "utf8"
@@ -50443,14 +50696,14 @@ async function syncSkills(paths, client, seed, pins = []) {
 // src/agent-skills.ts
 import {
   cpSync,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   lstatSync,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync13,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync14,
   readdirSync as readdirSync7,
   rmSync as rmSync2,
   symlinkSync,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { join as join19 } from "node:path";
 var SKILL_NS = "errata-";
@@ -50483,7 +50736,7 @@ ${body2.trimEnd()}
 `;
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync14(dir)) return 0;
+  if (!existsSync15(dir)) return 0;
   let pruned = 0;
   for (const name2 of readdirSync7(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
@@ -50497,7 +50750,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync14(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
+    if (existsSync15(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -50519,14 +50772,14 @@ function safeLstat(p) {
 }
 function emitAndProjectSkills(root, skills) {
   const agentsSkillsDir = join19(root, ".agents", "skills");
-  mkdirSync6(agentsSkillsDir, { recursive: true });
+  mkdirSync7(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
   let emitted = 0;
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync13(s.bodyPath, "utf8");
+      body2 = readFileSync14(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -50535,8 +50788,8 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync6(join19(agentsSkillsDir, slug2), { recursive: true });
-    writeFileSync11(
+    mkdirSync7(join19(agentsSkillsDir, slug2), { recursive: true });
+    writeFileSync12(
       join19(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2),
       "utf8"
@@ -50546,9 +50799,9 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync14(join19(root, h.configDir))) continue;
+    if (!existsSync15(join19(root, h.configDir))) continue;
     const dir = join19(root, h.skillsDir);
-    mkdirSync6(dir, { recursive: true });
+    mkdirSync7(dir, { recursive: true });
     for (const slug2 of slugs) {
       linkOrCopy(join19(dir, slug2), join19(agentsSkillsDir, slug2));
       projected++;
@@ -50559,9 +50812,9 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync14(manifestPath)) return [];
+  if (!existsSync15(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync13(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync14(manifestPath, "utf8"));
     return (parsed.skills ?? []).filter((s) => Boolean(s.id && s.file)).map((s) => ({
       id: s.id,
       title: s.title ?? s.id,
@@ -50584,14 +50837,14 @@ function ensureSkillGitignore(root) {
   const path2 = join19(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync14(path2) ? readFileSync13(path2, "utf8") : "";
+    current = existsSync15(path2) ? readFileSync14(path2, "utf8") : "";
   } catch {
     return;
   }
   if (current.includes(GITIGNORE_MARK)) return;
   const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
   try {
-    writeFileSync11(path2, `${current}${prefix}
+    writeFileSync12(path2, `${current}${prefix}
 ${GITIGNORE_LINES.join("\n")}
 `, "utf8");
   } catch {
@@ -50727,20 +50980,20 @@ var CausalBuffer = class {
 // src/profile.ts
 init_src2();
 init_paths();
-import { existsSync as existsSync16, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "node:fs";
 import { createHash as createHash12 } from "node:crypto";
 import { join as join21 } from "node:path";
 
 // src/git-remote.ts
 init_src();
-import { existsSync as existsSync15, readFileSync as readFileSync14, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync15, statSync as statSync4 } from "node:fs";
 import { isAbsolute as isAbsolute3, join as join20, resolve as resolve5 } from "node:path";
 function resolveGitDir(root) {
   const dotGit = join20(root, ".git");
   try {
     const st = statSync4(dotGit);
     if (st.isDirectory()) return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync14(dotGit, "utf8"));
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync15(dotGit, "utf8"));
     if (!m) return null;
     const dir = m[1];
     return isAbsolute3(dir) ? dir : resolve5(root, dir);
@@ -50750,8 +51003,8 @@ function resolveGitDir(root) {
 }
 function gitConfigPath(gitDir) {
   const commondirFile = join20(gitDir, "commondir");
-  if (existsSync15(commondirFile)) {
-    const common = readFileSync14(commondirFile, "utf8").trim();
+  if (existsSync16(commondirFile)) {
+    const common = readFileSync15(commondirFile, "utf8").trim();
     const commonDir = isAbsolute3(common) ? common : resolve5(gitDir, common);
     return join20(commonDir, "config");
   }
@@ -50761,10 +51014,10 @@ function readRemotes(root) {
   const gitDir = resolveGitDir(root);
   if (!gitDir) return [];
   const cfgPath = gitConfigPath(gitDir);
-  if (!existsSync15(cfgPath)) return [];
+  if (!existsSync16(cfgPath)) return [];
   let txt;
   try {
-    txt = readFileSync14(cfgPath, "utf8");
+    txt = readFileSync15(cfgPath, "utf8");
   } catch {
     return [];
   }
@@ -50796,13 +51049,13 @@ function refreshRepoLocator(root, profile) {
 }
 function loadProfile(root) {
   const p = workspacePaths(root);
-  if (!existsSync16(p.workspaceJson)) return null;
-  return JSON.parse(readFileSync15(p.workspaceJson, "utf8"));
+  if (!existsSync17(p.workspaceJson)) return null;
+  return JSON.parse(readFileSync16(p.workspaceJson, "utf8"));
 }
 function saveProfile(root, profile) {
   const p = workspacePaths(root);
   ensureDir(p.configDir);
-  writeFileSync12(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
+  writeFileSync13(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
 }
 function autodetectProfile(root) {
   const id = workspaceId(root);
@@ -50811,9 +51064,9 @@ function autodetectProfile(root) {
   const locator = detectRepoLocator(root);
   if (locator) p.repoLocator = locator;
   const pkgPath = join21(root, "package.json");
-  if (existsSync16(pkgPath)) {
+  if (existsSync17(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync15(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync16(pkgPath, "utf8"));
       p.languages.push("typescript", "javascript");
       const nodeVer = pkg.engines?.node ?? "node";
       p.stack.push(`node@${nodeVer}`);
@@ -50835,9 +51088,9 @@ function autodetectProfile(root) {
     }
   }
   const pyproject = join21(root, "pyproject.toml");
-  if (existsSync16(pyproject)) {
+  if (existsSync17(pyproject)) {
     try {
-      const txt = readFileSync15(pyproject, "utf8");
+      const txt = readFileSync16(pyproject, "utf8");
       const py = /python\s*=\s*"([^"]+)"/.exec(txt)?.[1];
       p.languages.push("python");
       p.stack.push(`python@${py ?? "3"}`);
@@ -50849,15 +51102,15 @@ function autodetectProfile(root) {
     }
   }
   const reqs = join21(root, "requirements.txt");
-  if (existsSync16(reqs)) {
+  if (existsSync17(reqs)) {
     if (!p.languages.includes("python")) p.languages.push("python");
     if (!p.stack.includes("python@3")) p.stack.push("python@3");
   }
-  if (existsSync16(join21(root, "go.mod"))) {
+  if (existsSync17(join21(root, "go.mod"))) {
     p.languages.push("go");
     p.stack.push("go");
   }
-  if (existsSync16(join21(root, "Cargo.toml"))) {
+  if (existsSync17(join21(root, "Cargo.toml"))) {
     p.languages.push("rust");
     p.stack.push("rust");
   }
@@ -51015,7 +51268,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.0-dev.88" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.0-dev.90" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -51025,7 +51278,7 @@ var TURN_REPLAY_LOOKBACK_MS = 7 * 24 * 60 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync17(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync18(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync2(path2, `${path2}.1`);
     }
     appendFileSync2(path2, line);
@@ -51035,14 +51288,14 @@ function appendIdentityAudit(path2, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    return new Map(Object.entries(JSON.parse(readFileSync16(path2, "utf8"))));
+    return new Map(Object.entries(JSON.parse(readFileSync17(path2, "utf8"))));
   } catch {
     return /* @__PURE__ */ new Map();
   }
 }
 function saveTurnCursors(path2, cursors) {
   try {
-    writeFileSync13(path2, JSON.stringify(Object.fromEntries(cursors)), "utf8");
+    writeFileSync14(path2, JSON.stringify(Object.fromEntries(cursors)), "utf8");
   } catch {
   }
 }
@@ -51279,7 +51532,7 @@ function createWorkspaceEngine(opts) {
       );
     };
     const gitDir = join22(opts.workspaceRoot, ".git");
-    if (existsSync17(gitDir)) {
+    if (existsSync18(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -51347,8 +51600,9 @@ function createWorkspaceEngine(opts) {
       ...pendingUpdate ? { pendingUpdate } : {}
     });
     doneRender?.();
+    writeContextFile(opts.workspaceRoot, body2);
     const target = join22(opts.workspaceRoot, "AGENTS.md");
-    writeManagedBlock(target, { body: body2 });
+    writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
       writePrimingHandles(join22(paths.configDir, "priming-handles.json"), [
         ...snapshot.recentProblems.map((r) => r.node),
@@ -52242,7 +52496,7 @@ function createWorkspaceEngine(opts) {
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync17(paths.outbox) ? readdirSync8(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync18(paths.outbox) ? readdirSync8(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -52329,7 +52583,7 @@ async function startDaemon(opts) {
     reviewUrl: () => webUiUrl + "/review"
   });
   const writeLockFile = (url2) => {
-    writeFileSync14(
+    writeFileSync15(
       engine.paths.daemonLock,
       JSON.stringify({ pid: process.pid, webUiUrl: url2, startedAt: Date.now() }),
       "utf8"
@@ -52372,7 +52626,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync18(engine.paths.daemonLock)) {
+        if (existsSync19(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -52389,16 +52643,16 @@ async function listenServer(fetchFn, port) {
 
 // src/registry.ts
 init_paths();
-import { existsSync as existsSync19, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "node:fs";
 import { join as join23 } from "node:path";
 function registryPath() {
   return process.env["ERRATA_REGISTRY_PATH"] ?? join23(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync19(p)) return { version: 1, workspaces: {} };
+  if (!existsSync20(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync17(p, "utf8"));
+    const parsed = JSON.parse(readFileSync18(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -52406,7 +52660,7 @@ function read() {
 }
 function write(reg) {
   ensureDir(globalDir());
-  writeFileSync15(registryPath(), JSON.stringify(reg, null, 2), "utf8");
+  writeFileSync16(registryPath(), JSON.stringify(reg, null, 2), "utf8");
 }
 function registerWorkspace(profile, root, now = Date.now()) {
   const reg = read();
@@ -52423,7 +52677,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync19(entry.path)) {
+    if (!existsSync20(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -52432,13 +52686,13 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync19(entry.path);
+  const missing = !existsSync20(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
-  if (existsSync19(lockPath)) {
+  if (existsSync20(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync17(lockPath, "utf8"));
+      const lock = JSON.parse(readFileSync18(lockPath, "utf8"));
       if (lock.pid && lock.webUiUrl && pidAlive(lock.pid)) {
         running = true;
         webUiUrl = lock.webUiUrl;
@@ -52466,7 +52720,7 @@ function pidAlive(pid) {
 // src/multi.ts
 init_dist();
 init_src4();
-import { readFileSync as readFileSync20, unlinkSync as unlinkSync3, writeFileSync as writeFileSync16 } from "node:fs";
+import { readFileSync as readFileSync21, unlinkSync as unlinkSync3, writeFileSync as writeFileSync17 } from "node:fs";
 
 // src/principle-sync.ts
 init_src4();
@@ -52494,7 +52748,7 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "node:fs";
 import { join as join24 } from "node:path";
 
 // src/package-index.ts
@@ -52630,10 +52884,10 @@ function runLockfilePass(opts) {
   ];
   for (const c of candidates) {
     const p = join24(opts.root, c.file);
-    if (!existsSync20(p)) continue;
+    if (!existsSync21(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync18(p, "utf8"));
+      sbom = c.parse(readFileSync19(p, "utf8"));
     } catch {
       continue;
     }
@@ -52954,7 +53208,7 @@ var ConsolidateWorker = class {
 init_paths();
 
 // src/lock.ts
-import { existsSync as existsSync21, readFileSync as readFileSync19 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync20 } from "node:fs";
 function isProcessAlive(pid) {
   if (!pid || pid <= 0) return false;
   try {
@@ -52965,9 +53219,9 @@ function isProcessAlive(pid) {
   }
 }
 function readDaemonLock(lockPath) {
-  if (!existsSync21(lockPath)) return null;
+  if (!existsSync22(lockPath)) return null;
   try {
-    const lock = JSON.parse(readFileSync19(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync20(lockPath, "utf8"));
     return typeof lock.pid === "number" ? lock : null;
   } catch {
     return null;
@@ -53209,13 +53463,13 @@ async function reanchorProject(opts) {
 }
 
 // src/adopt.ts
-import { existsSync as existsSync22 } from "node:fs";
-import { dirname as dirname8, join as join25 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { dirname as dirname9, join as join25 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync22(join25(dir, ".git"))) return dir;
-    const parent = dirname8(dir);
+    if (existsSync23(join25(dir, ".git"))) return dir;
+    const parent = dirname9(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -53410,7 +53664,7 @@ async function startMultiDaemon(opts = {}) {
     void ambientLinkAll();
     app.route(`/ws/${rec.id}`, rec.webApp);
     try {
-      writeFileSync16(
+      writeFileSync17(
         rec.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${rec.id}`, startedAt: Date.now() }),
         "utf8"
@@ -53596,7 +53850,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync16(
+    writeFileSync17(
       lockPath,
       JSON.stringify({ pid: process.pid, webUiUrl: baseUrl, startedAt: Date.now() }),
       "utf8"
@@ -53605,7 +53859,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync16(
+      writeFileSync17(
         r.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${r.id}`, startedAt: Date.now() }),
         "utf8"
@@ -54004,7 +54258,7 @@ async function startMultiDaemon(opts = {}) {
     },
     async stop() {
       try {
-        const cur = readFileSync20(lockPath, "utf8");
+        const cur = readFileSync21(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
       } catch {
       }
@@ -54599,21 +54853,21 @@ async function cmdInit() {
   if (!skipHooks) {
     console.log("");
     console.log("installing harness hooks...");
-    const { existsSync: existsSync24 } = await import("node:fs");
+    const { existsSync: existsSync25 } = await import("node:fs");
     const { join: join27 } = await import("node:path");
     try {
       await installClaudeHooks(port);
     } catch (err2) {
       console.warn(`  \u26A0\uFE0F  Claude hook install failed: ${err2 instanceof Error ? err2.message : err2}`);
     }
-    if (existsSync24(join27(ROOT, ".cursor"))) {
+    if (existsSync25(join27(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
         console.warn(`  \u26A0\uFE0F  Cursor MCP config failed: ${err2 instanceof Error ? err2.message : err2}`);
       }
     }
-    if (existsSync24(join27(ROOT, ".codex"))) {
+    if (existsSync25(join27(ROOT, ".codex"))) {
       try {
         await installCodexHooks(port);
       } catch (err2) {
@@ -54770,8 +55024,8 @@ async function cmdStatus() {
     console.log(`    stack:     ${profile.stack.join(", ") || "(none)"}`);
     console.log(`    languages: ${profile.languages.join(", ") || "(none)"}`);
   }
-  console.log(`  graph db:  ${existsSync23(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
-  console.log(`  event log: ${existsSync23(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
+  console.log(`  graph db:  ${existsSync24(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
+  console.log(`  event log: ${existsSync24(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
   const lockPath = globalDaemonLock();
   const running = isDaemonAlive(lockPath) ? readDaemonLock(lockPath) : null;
   console.log(
@@ -55223,11 +55477,11 @@ async function cmdUse(args2) {
 }
 async function cmdReview() {
   const paths = workspacePaths(ROOT);
-  if (!existsSync23(paths.reviewQueue)) {
+  if (!existsSync24(paths.reviewQueue)) {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync21(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync22(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -55881,7 +56135,7 @@ async function gatherRepo(store, ws) {
   };
 }
 async function gatherReportData(generatedAt) {
-  const { existsSync: existsSync24 } = await import("node:fs");
+  const { existsSync: existsSync25 } = await import("node:fs");
   const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const cfg = loadConfig();
   const outbound = cfg.consent.sync ? "auto" : "off";
@@ -55889,7 +56143,7 @@ async function gatherReportData(generatedAt) {
   for (const ws of listWorkspaces()) {
     if (ws.missing) continue;
     const dbPath = workspacePaths(ws.path).castalia;
-    if (!existsSync24(dbPath)) continue;
+    if (!existsSync25(dbPath)) continue;
     let store = null;
     try {
       store = openGraphStore2({ path: dbPath });
@@ -55920,7 +56174,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync7, writeFileSync: writeFileSync17 } = await import("node:fs");
+  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync18 } = await import("node:fs");
   const { renderReport: renderReport2 } = await Promise.resolve().then(() => (init_report_render(), report_render_exports));
   const includeFutureVerbs = args2.includes("--future-verbs");
   const now = /* @__PURE__ */ new Date();
@@ -55931,9 +56185,9 @@ async function cmdReport(args2) {
     process.exit(2);
   }
   const outDir = workspacePaths(ROOT).configDir;
-  mkdirSync7(outDir, { recursive: true });
+  mkdirSync8(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync17(join26(outDir, f.name), f.html, "utf8");
+  for (const f of files) writeFileSync18(join26(outDir, f.name), f.html, "utf8");
   const indexPath = join26(outDir, "report.html");
   console.log(`report \u2192 ${indexPath}`);
   console.log(`  ${data.repos.length} repo(s) \xB7 ${files.length} file(s) \xB7 ${data.rollup.nodes.toLocaleString("en-US")} nodes`);
@@ -56054,15 +56308,15 @@ function hookRelayCommand(port, path2) {
   return process.platform === "win32" ? `cmd //c "curl -s --connect-timeout 1 --max-time 2 -X POST -H \\"Content-Type: application/json\\" --data-binary @- ${url2} 2>NUL || echo {}"` : `curl -s --connect-timeout 1 --max-time 2 -X POST -H 'Content-Type: application/json' --data-binary @- ${url2} 2>/dev/null || echo '{}'`;
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync7, existsSync: existsSync24, readFileSync: readFileSync22, writeFileSync: writeFileSync17 } = await import("node:fs");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
   const { join: join27 } = await import("node:path");
   const dir = join27(ROOT, ".claude");
-  if (!existsSync24(dir)) mkdirSync7(dir, { recursive: true });
+  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
   const file2 = join27(dir, "settings.json");
   let settings = {};
-  if (existsSync24(file2)) {
+  if (existsSync25(file2)) {
     try {
-      settings = JSON.parse(readFileSync22(file2, "utf8"));
+      settings = JSON.parse(readFileSync23(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -56070,7 +56324,7 @@ async function installClaudeHooks(port) {
   }
   const matcher = "Read|Edit|Write|Grep|Glob|NotebookEdit|Bash";
   const postMatcher = `${matcher}|ToolSearch|mcp__errata__.*`;
-  const preCmd = `${hookCurlCommand(port)} ${ERRATA_TAG}`;
+  const preCmd = `${hookRelayCommand(port, "/api/hook")} ${ERRATA_TAG}`;
   const postCmd = `${hookRelayCommand(port, "/api/hook")} ${ERRATA_TAG}`;
   settings.hooks ??= {};
   const dropErrata = (list) => {
@@ -56108,7 +56362,7 @@ async function installClaudeHooks(port) {
     dropErrata(list);
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
-  writeFileSync17(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync18(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   await installClaudeMcpConfig();
   const claudeMd = join27(ROOT, "CLAUDE.md");
@@ -56123,15 +56377,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync7, existsSync: existsSync24, readFileSync: readFileSync22, writeFileSync: writeFileSync17 } = await import("node:fs");
-  const { join: join27, dirname: dirname9 } = await import("node:path");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
+  const { join: join27, dirname: dirname10 } = await import("node:path");
   const file2 = join27(ROOT, ".mcp.json");
-  const dir = dirname9(file2);
-  if (!existsSync24(dir)) mkdirSync7(dir, { recursive: true });
+  const dir = dirname10(file2);
+  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
   let cfg = {};
-  if (existsSync24(file2)) {
+  if (existsSync25(file2)) {
     try {
-      cfg = JSON.parse(readFileSync22(file2, "utf8"));
+      cfg = JSON.parse(readFileSync23(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -56139,21 +56393,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync17(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync18(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code MCP server config \u2192 ${file2}`);
   console.log(`  Claude Code will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync7, existsSync: existsSync24, readFileSync: readFileSync22, writeFileSync: writeFileSync17 } = await import("node:fs");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
   const { join: join27 } = await import("node:path");
   const dir = join27(ROOT, ".cursor");
-  if (!existsSync24(dir)) mkdirSync7(dir, { recursive: true });
+  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
   const file2 = join27(dir, "mcp.json");
   let cfg = {};
-  if (existsSync24(file2)) {
+  if (existsSync25(file2)) {
     try {
-      cfg = JSON.parse(readFileSync22(file2, "utf8"));
+      cfg = JSON.parse(readFileSync23(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -56161,7 +56415,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync17(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync18(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Cursor MCP server config \u2192 ${file2}`);
   console.log(`  Cursor will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses`);
@@ -56169,16 +56423,16 @@ async function installCursorMcpConfig() {
   console.log(`  \u26A0\uFE0F  reload Cursor (Cmd/Ctrl-Shift-P \u2192 "Reload Window") to pick it up.`);
 }
 async function installCodexHooks(port) {
-  const { mkdirSync: mkdirSync7, existsSync: existsSync24, readFileSync: readFileSync22, writeFileSync: writeFileSync17 } = await import("node:fs");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
   const { join: join27 } = await import("node:path");
   const dir = join27(ROOT, ".codex");
-  if (!existsSync24(dir)) mkdirSync7(dir, { recursive: true });
+  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
   const file2 = join27(dir, "config.toml");
   const BEGIN = `# >>> errata hooks (errata-managed)`;
   const END = `# <<< errata hooks`;
   let existing = "";
-  if (existsSync24(file2)) {
-    existing = readFileSync22(file2, "utf8");
+  if (existsSync25(file2)) {
+    existing = readFileSync23(file2, "utf8");
     const beginIdx = existing.indexOf(BEGIN);
     const endIdx = existing.indexOf(END);
     if (beginIdx >= 0 && endIdx > beginIdx) {
@@ -56207,7 +56461,7 @@ ${END}
   const final = existing.length > 0 && !existing.endsWith("\n") ? `${existing}
 
 ${block}` : existing + (existing.endsWith("\n\n") ? "" : "\n") + block;
-  writeFileSync17(file2, final, "utf8");
+  writeFileSync18(file2, final, "utf8");
   console.log(`installed Codex hooks \u2192 ${file2}`);
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
   console.log("");