@inerrata-corporation/errata 2.0.16-dev.3332 → 2.0.16-dev.3355

package/errata.mjs

@@ -139,6 +139,7 @@ var init_castalia = __esm({
     ROUTING_REASONS = [
       /** Harness org (CTF lane, e2e battery, canary) — forced org-private. */
       "harness-clamp",
+      "witnessed-vulnerability-private",
       /** A signed gateway write target named the destination. */
       "signed-target-public",
       "signed-target-org",
@@ -1080,6 +1081,12 @@ function identityId(input) {
     }
     case "Claim":
       return canonicalClaimId(input.text, input.scope);
+    case "WitnessedVulnerability":
+      return genericCanonicalId("dvuln", {
+        workspaceId: input.workspaceId,
+        target: input.target.replace(/\\/g, "/").replace(/^\.\//, ""),
+        statement: canonicalClaimId(input.statement.trim())
+      });
     case "DesignProblem":
       return `${DESIGN_PROBLEM_PREFIX}${canonicalClaimId(input.statement.trim())}`.slice(
         0,
@@ -15849,7 +15856,7 @@ var init_edge_rules = __esm({
       // anchor anything at anything, e.g. at a public `Package`, quietly re-creating
       // the code↔collective bridge the membrane exists to prevent.
       ANCHORED_AT: {
-        from: ["Problem", "Solution", "RootCause", "Claim"],
+        from: ["Problem", "Vulnerability", "Solution", "RootCause", "Claim"],
         to: ["Symbol"]
       },
       // ── Security spine (v1 taxonomy.ts SECURITY_FORWARD_ONLY commentary) ──
@@ -15894,7 +15901,7 @@ var init_edge_rules = __esm({
       // `Component` joined the target set with OM-agent-anchors: an agent-named
       // component ("React Router") is the same knowledge→named-unit anchor shape as
       // a Tool — the knowledge is ABOUT it, not dependent on it.
-      CONCERNS: { from: ["Problem", "Solution", "RootCause", "Claim", "Pattern"], to: ["Tool", "Component"] },
+      CONCERNS: { from: ["Problem", "Vulnerability", "Solution", "RootCause", "Claim", "Pattern"], to: ["Tool", "Component"] },
       OPERATES_ON: { from: ["Algorithm"], to: ["DataStructure"] },
       INVOLVES: { from: ["Problem", "Solution"], to: ["DataStructure"] },
       // ── Taxonomy (Track 4 Stream C: MITRE CWE `ChildOf` → `Weakness —IS_A→ Weakness`) ──
@@ -16448,8 +16455,8 @@ function parsePackageLockJson(jsonText) {
   }
   const dependencies = [];
   for (const [path2, meta3] of Object.entries(packages)) {
-    const self = byPath.get(path2);
-    if (!self) continue;
+    const self2 = byPath.get(path2);
+    if (!self2) continue;
     const deps = meta3.dependencies;
     if (!deps || typeof deps !== "object") continue;
     const dependsOn = [];
@@ -16458,7 +16465,7 @@ function parsePackageLockJson(jsonText) {
       if (target) dependsOn.push(npmPurl(depName, target.version));
     }
     if (dependsOn.length > 0)
-      dependencies.push({ ref: npmPurl(self.name, self.version), dependsOn });
+      dependencies.push({ ref: npmPurl(self2.name, self2.version), dependsOn });
   }
   const directRaw = [];
   for (const [path2, meta3] of Object.entries(packages)) {
@@ -16929,9 +16936,9 @@ function pomSelf(text) {
   const group = (/<groupId>([^<]+)<\/groupId>/.exec(own)?.[1] ?? parentGroup)?.trim();
   const artifact = /<artifactId>([^<]+)<\/artifactId>/.exec(own)?.[1]?.trim();
   if (!group) return [];
-  const self = [{ ecosystem: "maven", kind: "namespace", value: group }];
-  if (artifact) self.push({ ecosystem: "maven", kind: "name", value: mavenName(group, artifact) });
-  return self;
+  const self2 = [{ ecosystem: "maven", kind: "namespace", value: group }];
+  if (artifact) self2.push({ ecosystem: "maven", kind: "name", value: mavenName(group, artifact) });
+  return self2;
 }
 function parseManifestSelf(path2, text) {
   const file2 = basename(path2);
@@ -16944,10 +16951,10 @@ function parseManifestSelf(path2, text) {
     }
     const name2 = obj && typeof obj === "object" ? obj["name"] : null;
     if (typeof name2 !== "string" || !name2.trim()) return [];
-    const self = [{ ecosystem: "npm", kind: "name", value: name2.trim() }];
+    const self2 = [{ ecosystem: "npm", kind: "name", value: name2.trim() }];
     const scope = /^(@[^/]+)\//.exec(name2.trim())?.[1];
-    if (scope) self.push({ ecosystem: "npm", kind: "namespace", value: scope });
-    return self;
+    if (scope) self2.push({ ecosystem: "npm", kind: "namespace", value: scope });
+    return self2;
   }
   if (file2 === "pom.xml") return pomSelf(text);
   if (file2 === "build.gradle" || file2 === "build.gradle.kts") {
@@ -18268,7 +18275,8 @@ CREATE INDEX IF NOT EXISTS nodes_live ON nodes(label, valid_to);
 -- its table row. Partial, so it maintains a few thousand rows instead of adding
 -- a write to every node write. Its label list is FINGERPRINT_INDEXED_LABELS.
 DROP INDEX IF EXISTS nodes_live_fingerprint;
-CREATE INDEX IF NOT EXISTS nodes_instance_fingerprint ON nodes(label, last_updated_at, last_reinforced_at_seq, created_at_seq) WHERE valid_to IS NULL AND label IN ('Problem','Solution','RootCause');
+DROP INDEX IF EXISTS nodes_instance_fingerprint;
+CREATE INDEX IF NOT EXISTS nodes_instance_fingerprint_v2 ON nodes(label, last_updated_at, last_reinforced_at_seq, created_at_seq) WHERE valid_to IS NULL AND label IN ('Problem','Vulnerability','Solution','RootCause');
 CREATE INDEX IF NOT EXISTS nodes_logical ON nodes(logical_id, version);
 CREATE INDEX IF NOT EXISTS edges_live ON edges(valid_to);
 -- Expression index on the per-node relPath (stored in attrs_json) so the
@@ -18282,7 +18290,7 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
 -- every edited file of every turn, and a scan parses every Problem's attrs.
 CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
 `;
-    FINGERPRINT_INDEXED_LABELS = ["Problem", "Solution", "RootCause"];
+    FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
     SqliteGraphStore = class {
       db;
       // Typed edge lookups build their SQL from the number of types asked for, and
@@ -18960,8 +18968,8 @@ CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_js
           const r2 = this.db.prepare(
             `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
                   MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
-             FROM nodes INDEXED BY nodes_instance_fingerprint
-            WHERE valid_to IS NULL AND label IN ('Problem','Solution','RootCause')`
+             FROM nodes INDEXED BY nodes_instance_fingerprint_v2
+            WHERE valid_to IS NULL AND label IN ('Problem','Vulnerability','Solution','RootCause')`
           ).get();
           return `${r2.n}:${r2.t ?? 0}:${r2.s ?? 0}`;
         }
@@ -20257,7 +20265,7 @@ function mergeContextEdge(store, from, to, type, ts) {
 function deriveContextFromAnchors(store, problemId, ts, pkgIndex) {
   const report = { languages: [], packages: [] };
   const p = store.getNode(problemId);
-  if (!p || p.label !== "Problem") return report;
+  if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return report;
   const files = store.outEdges(problemId, ["ANCHORED_AT"]).map((e) => store.getNode(e.to)).filter((n) => !!n && n.label === "File");
   if (files.length === 0) return report;
   const idx = pkgIndex ?? buildPackageIndex(store);
@@ -20895,6 +20903,81 @@ function ingestDesignProblem(store, flag, opts) {
     ...reopenedFromRegression ? { reopenedFromRegression } : {}
   };
 }
+function ingestWitnessedVulnerability(store, flag, opts) {
+  const statement = flag.statement.trim();
+  if (isPlaceholderStatement(statement)) return { id: "", created: false, corroborated: false, upgraded: false, rejected: "statement" };
+  const target = flag.target?.trim().replace(/\\/g, "/").replace(/^\.\//, "") ?? "";
+  const file2 = target ? resolveFileNode(store, target, opts.workspaceId) : null;
+  const symbol2 = file2 && flag.line !== void 0 && flag.fileText !== void 0 ? resolveEnclosingSymbol(store, file2.id, flag.line, flag.fileText) : null;
+  const identityTarget = symbol2 ? String(symbol2.attrs["logicalId"] ?? `${target}#${symbol2.attrs["qname"] ?? symbol2.description}`) : target;
+  const compatibleTarget = (n) => !symbol2 || !n.attrs["identityTarget"] || n.attrs["identityTarget"] === target || n.attrs["identityTarget"] === identityTarget;
+  const bound = flag.existingId ? store.getNode(flag.existingId) : null;
+  if (flag.existingId && (!bound || bound.label !== "Vulnerability" || bound.attrs["workspaceId"] !== opts.workspaceId || target && bound.attrs["affectedTarget"] && bound.attrs["affectedTarget"] !== target || !compatibleTarget(bound))) {
+    return { id: "", created: false, corroborated: false, upgraded: false, rejected: "binding-conflict" };
+  }
+  const statementKey = identityId({ kind: "DesignProblem", statement });
+  const restated = bound ? null : store.findNodesByLabel("Vulnerability").find((n) => n.attrs["workspaceId"] === opts.workspaceId && n.attrs["affectedTarget"] === target && compatibleTarget(n) && [n.description, ...n.attrs["statementAliases"] ?? []].some((s) => identityId({ kind: "DesignProblem", statement: s }) === statementKey));
+  const id = bound?.id ?? restated?.id ?? identityId({ kind: "WitnessedVulnerability", workspaceId: opts.workspaceId, target: identityTarget, statement });
+  const existing = bound ?? store.getNode(id);
+  const sources = existing?.attrs["sources"] ?? [];
+  const corroborated = !!existing && !sources.includes(opts.source);
+  const upgraded = !!existing && existing.attrs["assessment"] !== "asserted" && flag.assessment === "asserted";
+  const assessment = existing?.attrs["assessment"] === "asserted" ? "asserted" : flag.assessment;
+  if (!existing) {
+    store.mergeNode(buildNode(store, id, "Vulnerability", statement, opts.ts, {
+      source: "convo",
+      sourceClass: "agent-observation",
+      privateFinding: id,
+      workspaceId: opts.workspaceId,
+      affectedTarget: target,
+      identityTarget,
+      assessment,
+      anchorDisposition: target ? "unresolved" : "absent",
+      provisional: true,
+      sources: [opts.source],
+      corroborations: 0,
+      ...opts.hostHarness ? { hostHarness: opts.hostHarness } : {}
+    }));
+  } else if (corroborated || upgraded || !existing.attrs["affectedTarget"] && target || symbol2 && existing.attrs["identityTarget"] !== identityTarget) {
+    store.updateNode(id, {
+      attrs: {
+        ...existing.attrs,
+        assessment,
+        ...upgraded && existing.description !== statement ? { statementAliases: [...existing.attrs["statementAliases"] ?? [], existing.description].slice(-5) } : {},
+        affectedTarget: existing.attrs["affectedTarget"] || target,
+        ...symbol2 ? { identityTarget } : {},
+        sources: corroborated ? [...sources, opts.source] : sources,
+        corroborations: (Number(existing.attrs["corroborations"]) || 0) + (corroborated ? 1 : 0)
+      },
+      // Assessment strengthens on evidence, but does not certify exploitability.
+      ...upgraded ? { description: statement } : {},
+      ...corroborated ? { cumulativeHits: existing.cumulativeHits + 1 } : {},
+      ...reinforcedSeqAttrs(store, "Vulnerability"),
+      lastUpdatedAt: opts.ts
+    });
+  }
+  return { id, created: !existing, corroborated, upgraded };
+}
+function recordVulnerabilityCause(store, findingId, causes, ts) {
+  const finding = store.getNode(findingId);
+  if (finding?.label !== "Vulnerability") return 0;
+  let from = findingId;
+  let count = 0;
+  for (const description of causes) {
+    if (isPlaceholderStatement(description)) continue;
+    const id = genericCanonicalId("dcause", { findingId, description: description.trim() });
+    if (!store.getNode(id)) store.mergeNode(buildNode(store, id, "RootCause", description.trim(), ts, {
+      source: "convo",
+      privateFinding: findingId,
+      sources: finding.attrs["sources"],
+      assessment: finding.attrs["assessment"]
+    }));
+    mergeEdge(store, from, id, "CAUSED_BY", ts);
+    from = id;
+    count++;
+  }
+  return count;
+}
 function canonicalizePatternText(name2) {
   const stripped = name2.replace(/^\s*pattern(?:\s*[×x]\s*\d+)?\s*(?:\(exemplar\))?\s*[:—–-]\s*/i, "").replace(/\s+/g, " ").trim();
   return stripped.length > 0 ? stripped : name2.replace(/\s+/g, " ").trim();
@@ -21205,6 +21288,7 @@ function findReusableSolution(store, fixText) {
   const key = solutionTextKey(fixText);
   if (!key) return null;
   for (const s of store.findNodesByLabel("Solution")) {
+    if (s.attrs["privateFinding"]) continue;
     if (s.validTo != null) continue;
     if (isAutoMinted(s)) continue;
     if (solutionTextKey(s.description ?? "") === key) return s;
@@ -21229,7 +21313,7 @@ function priorsForFile(store, relPath) {
   for (const e of store.inEdges(file2.id, ["ANCHORED_AT"])) {
     const n = store.getNode(e.from);
     if (!n) continue;
-    if (n.label === "Problem") {
+    if (n.label === "Problem" || n.label === "Vulnerability") {
       if (seenProblem.has(n.id)) continue;
       seenProblem.add(n.id);
       if (!n.attrs["resolvedAt"]) {
@@ -21299,7 +21383,8 @@ function solutionForProblem(store, problemId) {
 }
 function anchorProblemToWorkingFile(store, problemId, relPath, workspaceId2, ts, provenance = "edited", opts = {}) {
   const p = store.getNode(problemId);
-  if (!p || p.label !== "Problem") return false;
+  if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return false;
+  if (p.label === "Vulnerability" && provenance !== "witnessed") return false;
   if (!isAnchorableCodePath(relPath)) return false;
   const file2 = resolveFileNode(store, relPath, workspaceId2);
   if (!file2) return false;
@@ -21478,18 +21563,22 @@ function resolveDesignProblemById(store, id, fixNote, t) {
 }
 function closeDesignProblem(store, problemId, fixNote, t) {
   const p = store.getNode(problemId);
-  if (!p || p.label !== "Problem") return false;
+  if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return false;
   if (p.attrs["resolvedAs"]) return false;
   if (fixNote?.trim() && !isFragmentFixNote(fixNote)) {
     const sols = store.outEdges(problemId, ["SOLVED_BY"]).map((e) => store.getNode(e.to)).filter((n) => n !== null);
     if (sols.every((s) => isAutoMinted(s))) {
-      const reuse = findReusableSolution(store, fixNote);
+      const reuse = p.label === "Vulnerability" ? null : findReusableSolution(store, fixNote);
       if (reuse) {
         mergeEdge(store, problemId, reuse.id, "SOLVED_BY", t);
       } else {
         const solId = `dfix_${digest({ problemId, fix: fixNote })}`.slice(0, 56);
         store.mergeNode(
-          buildNode(store, solId, "Solution", fixNote.trim(), t, { source: "convo", provisional: false })
+          buildNode(store, solId, "Solution", fixNote.trim(), t, {
+            source: "convo",
+            provisional: false,
+            ...p.label === "Vulnerability" ? { privateFinding: problemId, sources: p.attrs["sources"] } : {}
+          })
         );
         mergeEdge(store, problemId, solId, "SOLVED_BY", t);
       }
@@ -21503,6 +21592,7 @@ function closeDesignProblem(store, problemId, fixNote, t) {
     // mints no Solution, and a legacy placeholder beside it reads as
     // all-heuristic either way.
     attrs: { ...p.attrs, provisional: false, resolvedAt: t, resolutionWitnessed: true },
+    ...reinforcedSeqAttrs(store, p.label),
     lastUpdatedAt: t
   });
   return true;
@@ -23854,7 +23944,7 @@ function detectLocalCommunities(store, opts = {}) {
   const ids = /* @__PURE__ */ new Set();
   for (const label of JOINT_COMMUNITY_LABELS) {
     for (const n of store.findNodesByLabel(label)) {
-      if (label === "Problem" && n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) continue;
+      if (n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) continue;
       ids.add(n.id);
     }
   }
@@ -23991,6 +24081,7 @@ var init_community2 = __esm({
     init_src4();
     JOINT_COMMUNITY_LABELS = [
       "Problem",
+      "Vulnerability",
       "Solution",
       "RootCause",
       "Pattern"
@@ -24852,6 +24943,7 @@ __export(src_exports2, {
   induceAbstractions: () => induceAbstractions,
   induceTriage: () => induceTriage,
   ingestDesignProblem: () => ingestDesignProblem,
+  ingestWitnessedVulnerability: () => ingestWitnessedVulnerability,
   isConstraintProblem: () => isConstraintProblem,
   isFragmentFixNote: () => isFragmentFixNote,
   isPlaceholderStatement: () => isPlaceholderStatement,
@@ -24899,6 +24991,7 @@ __export(src_exports2, {
   recordMisreadPrior: () => recordMisreadPrior,
   recordRenderLedger: () => recordRenderLedger,
   recordTriageObservation: () => recordTriageObservation,
+  recordVulnerabilityCause: () => recordVulnerabilityCause,
   reinforceSameAnchorProblem: () => reinforceSameAnchorProblem,
   relateClaims: () => relateClaims,
   reopenAutoClosedProblems: () => reopenAutoClosedProblems,
@@ -24968,11 +25061,11 @@ function isPassiveInjectable(node2, atCommit) {
   return false;
 }
 function buildSnapshot(opts) {
-  const problems = opts.store.findNodesByLabel("Problem").filter((p) => p.attrs["mergedInto"] === void 0 && historyReadPolicy(p, { mode: "passive", atCommit: opts.atCommit }).allow);
+  const problems = [...opts.store.findNodesByLabel("Problem"), ...opts.store.findNodesByLabel("Vulnerability")].filter((p) => p.attrs["mergedInto"] === void 0 && historyReadPolicy(p, { mode: "passive", atCommit: opts.atCommit }).allow);
   const stillOpen = problems.filter((p) => p.attrs["resolvedAt"] == null);
   const allProblems = stillOpen.filter((p) => !isConstraintProblem(p));
   allProblems.sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt);
-  const recent2 = allProblems.slice(0, 8).map((p) => ({
+  const recent3 = allProblems.slice(0, 8).map((p) => ({
     node: p,
     anchors: opts.store.outEdges(p.id, ["MANIFESTED_IN", "EVIDENCED_BY"])
   }));
@@ -25045,10 +25138,10 @@ function buildSnapshot(opts) {
     packages: opts.profile.stack.map((name2) => ({ name: name2, node: matchNode(pkgNodes, pkgBase(name2)) })),
     tools: toolNodes.map((node2) => ({ name: String(node2.attrs["name"] ?? node2.description), node: node2 }))
   };
-  const causalNudge = recent2.length >= 2 && recent2.every(
+  const causalNudge = recent3.length >= 2 && recent3.every(
     (r) => opts.store.outEdges(r.node.id, ["CAUSED_BY"]).length === 0 && opts.store.inEdges(r.node.id, ["CAUSED_BY"]).length === 0
   );
-  const abstractUndomained = recent2.filter((r) => {
+  const abstractUndomained = recent3.filter((r) => {
     const grounded = opts.store.outEdges(r.node.id, ["ANCHORED_AT", "OCCURS_IN", "DEPENDS_ON"]).length > 0;
     const hasDomain = opts.store.outEdges(r.node.id, ["PERTAIN_TO"]).length > 0;
     return !grounded && !hasDomain;
@@ -25057,7 +25150,7 @@ function buildSnapshot(opts) {
   return {
     profile: opts.profile,
     profileContext,
-    recentProblems: recent2,
+    recentProblems: recent3,
     recentResolved,
     recentConstraints,
     regressions,
@@ -25123,11 +25216,11 @@ function sliceForFile(store, relPath, atCommit) {
   const priors = fp ? {
     openProblems: fp.openProblems.slice(0, 3).map((p) => ({
       id: p.id,
-      description: p.description,
+      description: p.label === "Vulnerability" ? `Vulnerability (${p.attrs["assessment"] ?? "unassessed"}): ${p.description}` : p.description,
       ...typeof p.attrs["fixCandidateFile"] === "string" ? { fixCandidateFile: p.attrs["fixCandidateFile"] } : {}
     })),
     constraints: fp.constraints.slice(0, 2).map((c) => ({ id: c.id, description: c.description })),
-    resolvedProblems: fp.resolvedProblems.slice(0, 3).map((p) => ({ id: p.id, description: p.description })),
+    resolvedProblems: fp.resolvedProblems.slice(0, 3).map((p) => ({ id: p.id, description: p.label === "Vulnerability" ? `Vulnerability (${p.attrs["assessment"] ?? "unassessed"}): ${p.description}` : p.description })),
     related: fp.related.slice(0, 4).map((n) => ({ id: n.id, label: n.label, description: n.description })),
     solutionsByProblem: Object.fromEntries(
       [...fp.openProblems.slice(0, 3), ...fp.resolvedProblems.slice(0, 3)].map((p) => [
@@ -25245,7 +25338,8 @@ function renderSnapshot(s) {
     if (s.recentProblems.length > 0) {
       lines.push("_Open \u2014 recently observed here, derived from your work (a recency slice, not an inventory \u2014 burst an id for its full neighborhood):_");
       for (const r of s.recentProblems) {
-        lines.push(`- **${r.node.description}** \u2014 \`${r.node.id}\`${tagOf(r.node)}`);
+        const badge = r.node.label === "Vulnerability" ? `Vulnerability (${r.node.attrs["assessment"] ?? "unassessed"}): ` : "";
+        lines.push(`- **${badge}${r.node.description}** \u2014 \`${r.node.id}\`${tagOf(r.node)}`);
         const hits = r.node.cumulativeHits ?? 0;
         const surprise = (r.node.cumulativeSurprise ?? 0).toFixed(2);
         lines.push(`  - observed ${hits}\xD7 \xB7 cumulativeSurprise ${surprise}`);
@@ -25286,7 +25380,8 @@ function renderSnapshot(s) {
     if (s.recentResolved.length > 0) {
       lines.push("_Recently resolved \u2014 solved here; jumping-off points, not live defects:_");
       for (const r of s.recentResolved) {
-        lines.push(`- \u2713 **${r.node.description}** \u2014 \`${r.node.id}\`${tagOf(r.node)}`);
+        const badge = r.node.label === "Vulnerability" ? `Vulnerability (${r.node.attrs["assessment"] ?? "unassessed"}): ` : "";
+        lines.push(`- \u2713 **${badge}${r.node.description}** \u2014 \`${r.node.id}\`${tagOf(r.node)}`);
         if (r.solution) {
           lines.push(`  - solved: ${r.solution.description.slice(0, 160)} \u2014 \`${r.solution.id}\`${tagOf(r.solution)}`);
         }
@@ -31707,7 +31802,7 @@ var init_src8 = __esm({
 
 // src/agent-signals.ts
 function buildFileRecallInstruction(referent = "\u2026") {
-  return `Touching one? paste its token: ${TAG_EXAMPLE.fix(referent)} resolved \xB7 ${TAG_EXAMPLE.prior(referent)} leaned-on \xB7 ${TAG_EXAMPLE.problem()} new. We harvest it.`;
+  return `Touching one? paste its token: ${TAG_EXAMPLE.fix(referent)} resolved \xB7 ${TAG_EXAMPLE.prior(referent)} leaned-on \xB7 ${TAG_EXAMPLE.problem()} new \xB7 ${TAG_EXAMPLE.vulnerability()} security. We harvest it.`;
 }
 function triageBullet(ref) {
   return [
@@ -31743,15 +31838,15 @@ function attemptBullet() {
   ].join("\n");
 }
 function buildAgentInstruction(opts = {}) {
-  const signals = opts.signals ?? ["prior", "problem", "domain", "fix", "constraint", "triage", "attempt", "link"];
+  const signals = opts.signals ?? ["prior", "problem", "vulnerability", "domain", "fix", "constraint", "triage", "attempt", "link"];
   const ref = opts.referent ?? "its-handle";
   const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : s === "attempt" ? TAG_EXAMPLE.tried() : s === "domain" ? TAG_EXAMPLE.domain() : s === "link" ? TAG_EXAMPLE.pattern() : s === "verdict" ? TAG_EXAMPLE.confirm(ref) : TAG_EXAMPLE[s](ref);
-  const head2 = `We tag the priors we show you with a short handle like [${opts.handleExample ?? "chokidar-glob"}]. Untagged prose is silently lost. Put each tag inline in prose (no fences or backticks). Requested errata-* answer blocks are the exception: keep their fences in your turn-final reply. Tag everything, we filter downstream:`;
-  const tail = "Mid-turn text (between tool calls) can be dropped by the harness \u2014 RESTATE every tag in your turn-final message; the final message is what reliably survives \u2014 EXCEPT one already shown above with an id: that is captured, so cite `[its-handle]` rather than retyping it (drift mints a duplicate).";
+  const head2 = "Tag inline (no fences or backticks). Untagged findings are silently lost. Cite short handles; tag everything, we filter downstream. Requested errata-* answer blocks are the exception: keep their fences in your turn-final reply:";
+  const tail = "Restate mid-turn tags in your final reply; the harness can drop mid-turn text. EXCEPT one already shown with an id: cite [its-handle] instead of retyping (drift mints a duplicate).";
   return [
     head2,
     ...signals.map(
-      (s) => s === "triage" ? triageBullet(ref) : s === "attempt" ? attemptBullet() : s === "link" ? linkBullet(ref) : s === "verdict" ? verdictBullet(ref) : `  \u2022 ${GLOSS[s]} \u2192 ${token(s)}`
+      (s) => s === "triage" ? triageBullet(ref) : s === "vulnerability" ? `  \u2022 ${GLOSS.vulnerability} \u2192 ${TAG_EXAMPLE.vulnerability()}. Uncertain? ${TAG_EXAMPLE.suspectedVulnerability()}. Code review counts, even if immediately fixed. No CVE/exploit needed. For fixes: ${TAG_EXAMPLE.vulnerabilityThread()} ${TAG_EXAMPLE.fixThread("v")}.` : s === "attempt" ? attemptBullet() : s === "link" ? linkBullet(ref) : s === "verdict" ? verdictBullet(ref) : `  \u2022 ${GLOSS[s]} \u2192 ${token(s)}`
     ),
     tail
   ].join("\n");
@@ -31763,6 +31858,9 @@ var init_agent_signals = __esm({
     TAG_EXAMPLE = {
       prior: (ref) => `([${ref}])`,
       problem: () => `[!one line on what's wrong]`,
+      vulnerability: () => `[!vuln: who can do what; observed basis @ path:line]`,
+      suspectedVulnerability: () => `[?vuln: consequence; missing check]`,
+      vulnerabilityThread: () => `[!#v vuln: finding here]`,
       fix: (ref) => `(fix:[${ref}])`,
       // CONSTRAINT — the native capture path for a DIFFUSE problem (a constraint/tension/
       // conflict that shaped a decision). Free text, attaches to the decision sentence the
@@ -31783,7 +31881,7 @@ var init_agent_signals = __esm({
       // tags never need one — the id is for diagnoses that unfold over distance.
       problemThread: () => `[!#slug one line on what's wrong]`,
       causeThread: () => `(cause:#slug the mechanism)`,
-      fixThread: () => `(fix:#slug what you changed)`,
+      fixThread: (thread = "slug") => `(fix:#${thread} what you changed)`,
       // ATTEMPT arc — what's being tried and what didn't work. A failed attempt is a
       // witnessed NEGATIVE result: it saves the next agent the same dead end.
       tried: () => `(tried: the approach you're attempting)`,
@@ -31825,8 +31923,9 @@ var init_agent_signals = __esm({
       // problems, and narrated them as progress (a pick-best-before-scoring bug lost).
       // Every example here was diagnosis-framed, so nothing contradicted that sorting.
       // Kept to 29 chars: the instruction sits at the 2600 passive-budget ceiling.
-      problem: "a problem you notice or report \u2014 any bug, finding, or thing wrong, even in code you just wrote; about specific code? name the file: [!what's wrong @ src/file.ts:42]",
-      fix: "your edit fixed a PROBLEM we showed you; for one you flagged yourself: (fix: what you changed) \u2014 a fix resolves a stated problem, completing routine work is not a fix",
+      problem: "any bug or finding, even in code you just wrote; name affected code: [!what's wrong @ path:42]",
+      vulnerability: "unauthorized actions, data exposure, or execution/disruption an attacker can trigger",
+      fix: "you fixed a shown finding; for your own non-security finding: (fix: what changed) \u2014 a fix resolves a stated problem, completing routine work is not a fix",
       constraint: "a design decision forced by conflicting requirements or constraints \u2014 tag the tension, especially when your fix makes it 'only look' resolved",
       triage: "you diagnosed a cause \u2014 fold the chain into the flag with <- (caused-by), deepest sure mechanism rightmost",
       attempt: "attempting an approach / an attempt failed \u2014 a failed attempt is knowledge, it rules out a path",
@@ -31848,7 +31947,7 @@ var init_agent_signals = __esm({
       // Sim note (2026-08-02 shrink): domain emission held 4/4 with just the trigger
       // clause; the pattern convergence hook now rides here too (it fell 0/4 when it
       // only appeared in the link bullet's tail).
-      domain: "a problem with no single file \u2014 name the area it's about (Title Case). Also name the general shape it instantiates: (pattern: the shape) \u2014 needs no code anchor, and two agents naming the same shape converge on one node",
+      domain: "no single file? name the area (Title Case), and (pattern: the shape). No code anchor needed; two agents naming the same shape converge on one node",
       link: "the problem you flagged is an instance of priors/abstractions you can name \u2014 (instance:[h1],[h2],\u2026) / (pattern: \u2026) / (aids:[h]); rendered whole via linkBullet",
       verdict: "you can judge a prior we SHOWED you \u2014 confirm it if it held, refute it (with why) if it didn't; rendered whole via verdictBullet"
     };
@@ -32085,7 +32184,7 @@ function readContextCard(root, hash2) {
 function openProblems(store, now = Date.now()) {
   const hit = openProblemsCache.get(store);
   if (hit && now - hit.at < OPEN_PROBLEMS_TTL_MS) return hit.nodes;
-  const nodes = store.findNodesByLabel("Problem").filter((p) => live(p) && !p.attrs["resolvedAt"] && p.attrs["mergedInto"] === void 0 && !isConstraintProblem(p));
+  const nodes = [...store.findNodesByLabel("Problem"), ...store.findNodesByLabel("Vulnerability")].filter((p) => live(p) && !p.attrs["resolvedAt"] && p.attrs["mergedInto"] === void 0 && !isConstraintProblem(p));
   openProblemsCache.set(store, { at: now, nodes });
   return nodes;
 }
@@ -32479,17 +32578,172 @@ var init_checkout_root = __esm({
   }
 });
 
+// src/process-identity.ts
+import { execFileSync } from "node:child_process";
+import { readFileSync as readFileSync10 } from "node:fs";
+function readProcessIdentity(pid, fresh = false) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+  if (pid === process.pid && self) return self;
+  const cached2 = recent.get(pid);
+  if (!fresh && cached2 && Date.now() - cached2.at < 1e3) return cached2.value;
+  try {
+    const run3 = (bin, args2) => execFileSync(bin, args2, {
+      encoding: "utf8",
+      windowsHide: true,
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env, LC_ALL: "C", TZ: "UTC" }
+    }).trim();
+    let value;
+    if (process.platform === "win32") {
+      const ticks = run3("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().Ticks`
+      ]);
+      if (!/^\d+$/.test(ticks)) return null;
+      value = { key: `win32:${ticks}`, bornAt: Number((BigInt(ticks) - 621355968000000000n) / 10000n) };
+    } else if (process.platform === "linux") {
+      const stat4 = readFileSync10(`/proc/${pid}/stat`, "utf8");
+      const ticks = stat4.slice(stat4.lastIndexOf(")") + 2).split(" ")[19];
+      const bootId = readFileSync10("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      const boot = /^btime (\d+)$/m.exec(readFileSync10("/proc/stat", "utf8"))?.[1];
+      const hz = Number(run3("getconf", ["CLK_TCK"]));
+      if (!boot || !/^\d+$/.test(ticks) || !Number.isFinite(hz) || hz <= 0) return null;
+      value = { key: `linux:${bootId}:${ticks}`, bornAt: Number(boot) * 1e3 + Number(ticks) * 1e3 / hz };
+    } else if (process.platform === "darwin") {
+      const start2 = run3("ps", ["-p", String(pid), "-o", "lstart="]);
+      value = { key: `darwin:${start2}`, bornAt: Date.parse(`${start2} UTC`) };
+    } else return null;
+    if (!Number.isFinite(value.bornAt) || value.bornAt <= 0) return null;
+    if (pid === process.pid) self = value;
+    if (recent.size >= 64) recent.clear();
+    recent.set(pid, { at: Date.now(), value });
+    return value;
+  } catch {
+    return null;
+  }
+}
+var recent, self;
+var init_process_identity = __esm({
+  "src/process-identity.ts"() {
+    "use strict";
+    recent = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/lock.ts
+import { existsSync as existsSync12, readFileSync as readFileSync11, unlinkSync } from "node:fs";
+function daemonLockPayload(lock) {
+  return JSON.stringify({
+    pid: lock.pid,
+    webUiUrl: lock.webUiUrl,
+    startedAt: lock.processStartedAt,
+    ...lock.pid === process.pid ? { processIdentity: readProcessIdentity(lock.pid)?.key } : {},
+    ...lock.wokeAt !== void 0 ? { wokeAt: lock.wokeAt } : {},
+    ...lock.entry ? { entry: lock.entry } : {},
+    ...lock.version ? { version: lock.version } : {}
+  });
+}
+function isInstalledEntry(entry) {
+  return /\/node_modules\/@inerrata-corporation\/errata\//.test(normEntry(entry) + "/");
+}
+function foreignDaemonNote(lock, selfEntry) {
+  if (!lock.entry || normEntry(lock.entry) === normEntry(selfEntry)) return null;
+  const runningInstalled = isInstalledEntry(lock.entry);
+  const head2 = [
+    `launched from ${runningInstalled ? "the installed package" : "a LOCAL BUILD"}, not this one${lock.version ? ` (it is ${lock.version})` : ""}:`,
+    `  running: ${lock.entry}`,
+    `  this:    ${selfEntry}`
+  ];
+  return runningInstalled ? [...head2, "this CLI is a different bundle from the daemon it is talking to \u2014 its view may not match what the daemon runs."] : [...head2, "`errata update` does not replace it. To move onto the installed package: errata stop, then errata dash."];
+}
+function isProcessAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err2) {
+    return err2.code === "EPERM";
+  }
+}
+function readDaemonLock(lockPath) {
+  if (!existsSync12(lockPath)) return null;
+  try {
+    return parseDaemonLock(readFileSync11(lockPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function parseDaemonLock(raw2) {
+  try {
+    const lock = JSON.parse(raw2);
+    return lock && Number.isSafeInteger(lock.pid) && lock.pid > 0 ? lock : null;
+  } catch {
+    return null;
+  }
+}
+function daemonLockState(lock, fresh = false) {
+  if (!lock || !isProcessAlive(lock.pid)) return "stale";
+  const identity = readProcessIdentity(lock.pid, fresh);
+  if (!identity) return "unknown";
+  if (lock.processIdentity) return lock.processIdentity === identity.key ? "running" : "stale";
+  if (!Number.isFinite(lock.startedAt) || lock.startedAt <= 0) return "unknown";
+  return identity.bornAt <= lock.startedAt ? "running" : "stale";
+}
+function isDaemonAlive(lockPath) {
+  return daemonLockState(readDaemonLock(lockPath)) === "running";
+}
+function daemonLockBlocksStartup(lockPath) {
+  return daemonLockState(readDaemonLock(lockPath), true) !== "stale";
+}
+function stopLockedDaemon(lockPath) {
+  let original;
+  try {
+    original = readFileSync11(lockPath, "utf8");
+  } catch {
+    return "missing";
+  }
+  const lock = parseDaemonLock(original);
+  if (!lock) return "unknown";
+  const state = daemonLockState(lock, true);
+  try {
+    if (readFileSync11(lockPath, "utf8") !== original) return "changed";
+  } catch {
+    return "changed";
+  }
+  if (state === "unknown") return "unknown";
+  if (state === "stale") {
+    unlinkSync(lockPath);
+    return "stale";
+  }
+  process.kill(lock.pid, "SIGTERM");
+  return "signaled";
+}
+var normEntry;
+var init_lock = __esm({
+  "src/lock.ts"() {
+    "use strict";
+    init_process_identity();
+    normEntry = (p) => {
+      const s = p.replace(/\\/g, "/").replace(/\/+$/, "");
+      return /^[A-Za-z]:\//.test(s) ? s.toLowerCase() : s;
+    };
+  }
+});
+
 // src/registry.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join11 } from "node:path";
 function registryPath() {
   return process.env["ERRATA_REGISTRY_PATH"] ?? join11(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync12(p)) return { version: 1, workspaces: {} };
+  if (!existsSync13(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync10(p, "utf8"));
+    const parsed = JSON.parse(readFileSync12(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -32497,9 +32751,9 @@ function read() {
 }
 function registryCorrupt() {
   const p = registryPath();
-  if (!existsSync12(p)) return false;
+  if (!existsSync13(p)) return false;
   try {
-    JSON.parse(readFileSync10(p, "utf8"));
+    JSON.parse(readFileSync12(p, "utf8"));
     return false;
   } catch {
     return true;
@@ -32552,7 +32806,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync12(entry.path)) {
+    if (!existsSync13(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -32561,19 +32815,14 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync12(entry.path);
+  const missing = !existsSync13(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
-  if (existsSync12(lockPath)) {
-    try {
-      const lock = JSON.parse(readFileSync10(lockPath, "utf8"));
-      if (lock.pid && lock.webUiUrl && pidAlive(lock.pid)) {
-        running = true;
-        webUiUrl = lock.webUiUrl;
-      }
-    } catch {
-    }
+  const lock = readDaemonLock(lockPath);
+  if (lock?.webUiUrl && daemonLockState(lock) === "running") {
+    running = true;
+    webUiUrl = lock.webUiUrl;
   }
   return { ...entry, running, webUiUrl, missing };
 }
@@ -32583,19 +32832,12 @@ function listWorkspaces() {
 function listWorkspaceEntries() {
   return Object.values(read().workspaces).sort((a, b) => b.lastSeenAt - a.lastSeenAt);
 }
-function pidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err2) {
-    return err2.code === "EPERM";
-  }
-}
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
     init_paths();
     init_checkout_root();
+    init_lock();
   }
 });
 
@@ -33892,7 +34134,7 @@ var init_dual_augment = __esm({
 
 // ../../packages/indexer/src/parse-cache.ts
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync13, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join12 } from "node:path";
 function parseCacheDir() {
@@ -33907,7 +34149,7 @@ function entryPath(dir, key) {
 function readParseCache(dir, key) {
   const file2 = entryPath(dir, key);
   try {
-    const raw2 = readFileSync11(file2, "utf8");
+    const raw2 = readFileSync13(file2, "utf8");
     const parsed = JSON.parse(raw2);
     if (parsed.v !== PARSE_CACHE_VERSION || !Array.isArray(parsed.symbols)) return null;
     return { symbols: parsed.symbols, reExports: parsed.reExports ?? [] };
@@ -33936,7 +34178,7 @@ function sweepParseCacheOnce(dir, now = Date.now()) {
   sweptThisProcess = true;
   let removed = 0;
   try {
-    if (!existsSync13(dir)) return 0;
+    if (!existsSync14(dir)) return 0;
     for (const bucket of readdirSync2(dir)) {
       const bucketDir = join12(dir, bucket);
       let names;
@@ -34194,11 +34436,11 @@ var init_identity3 = __esm({
 });
 
 // ../../packages/indexer/src/pipeline.ts
-import { appendFileSync, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
+import { appendFileSync, readFileSync as readFileSync14, statSync as statSync3 } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { extname, join as join13, relative as relative2, sep } from "node:path";
 import { createHash as createHash7 } from "node:crypto";
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 function nowTs() {
   return indexNow ?? Date.now();
 }
@@ -34334,7 +34576,7 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   for (const rel of [...changedRelPaths]) {
     let h;
     try {
-      h = createHash7("sha256").update(readFileSync12(join13(rootPath, rel))).digest("hex");
+      h = createHash7("sha256").update(readFileSync14(join13(rootPath, rel))).digest("hex");
     } catch {
       continue;
     }
@@ -34389,7 +34631,7 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
     if (!provider) continue;
     let symbols;
     try {
-      symbols = provider.extractSymbols(readFileSync12(abs, "utf8"), abs);
+      symbols = provider.extractSymbols(readFileSync14(abs, "utf8"), abs);
     } catch {
       continue;
     }
@@ -34709,7 +34951,7 @@ async function runIndexer(store, opts) {
         report.filesSkipped++;
         continue;
       }
-      source = readFileSync12(f.absPath, "utf8");
+      source = readFileSync14(f.absPath, "utf8");
     } catch {
       report.filesSkipped++;
       continue;
@@ -34781,7 +35023,7 @@ async function runIndexer(store, opts) {
     const depth = fileNode.relPath.split("/").length;
     if (depth !== 3) continue;
     try {
-      const pkg = JSON.parse(readFileSync12(fileNode.absPath, "utf8"));
+      const pkg = JSON.parse(readFileSync14(fileNode.absPath, "utf8"));
       if (!pkg.name) continue;
       const pkgDir = fileNode.relPath.replace(/\/package\.json$/, "");
       const candidates = [
@@ -35199,7 +35441,7 @@ async function scan(root, current, ignores, providers, out2) {
 function gitListRelPaths(root, ignores) {
   let stdout;
   try {
-    stdout = execFileSync(
+    stdout = execFileSync2(
       "git",
       ["-C", root, "ls-files", "--cached", "--others", "--exclude-standard", "-z"],
       {
@@ -35257,7 +35499,7 @@ function upsertFile(store, id, f, workspaceId2, skip) {
   if (existing && fileUnchanged(existing.attrs, f, skip)) return;
   let contentHash;
   try {
-    contentHash = createHash7("sha256").update(readFileSync12(f.absPath)).digest("hex");
+    contentHash = createHash7("sha256").update(readFileSync14(f.absPath)).digest("hex");
   } catch {
   }
   const carried = { ...existing?.attrs ?? {} };
@@ -39641,7 +39883,7 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 // ../../packages/indexer/src/languages/tree-sitter-loader.ts
 import { fileURLToPath } from "node:url";
 import { dirname as dirname7, join as join14 } from "node:path";
-import { existsSync as existsSync14, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 function entryDir() {
   try {
@@ -39656,7 +39898,7 @@ function entryDir() {
 function findWasmDir() {
   const here = entryDir();
   const seaWasm = join14(here, "resources", "wasm");
-  if (existsSync14(join14(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
+  if (existsSync15(join14(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
     const flat = join14(
@@ -39666,13 +39908,13 @@ function findWasmDir() {
       "tree-sitter-wasm",
       "wasm"
     );
-    if (existsSync14(join14(flat, "tree-sitter-typescript.wasm"))) return flat;
+    if (existsSync15(join14(flat, "tree-sitter-typescript.wasm"))) return flat;
     dir = dirname7(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
     const pnpmDir = join14(root, "node_modules", ".pnpm");
-    if (existsSync14(pnpmDir)) {
+    if (existsSync15(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("@vscode+tree-sitter-wasm@")) {
           const candidate = join14(
@@ -39683,7 +39925,7 @@ function findWasmDir() {
             "tree-sitter-wasm",
             "wasm"
           );
-          if (existsSync14(join14(candidate, "tree-sitter-typescript.wasm"))) {
+          if (existsSync15(join14(candidate, "tree-sitter-typescript.wasm"))) {
             return candidate;
           }
         }
@@ -39698,17 +39940,17 @@ function findWasmDir() {
 function findRuntimeDir() {
   const here = entryDir();
   const seaRuntime = join14(here, "resources", "wasm");
-  if (existsSync14(join14(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
+  if (existsSync15(join14(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
     const flat = join14(dir, "node_modules", "web-tree-sitter");
-    if (existsSync14(join14(flat, "web-tree-sitter.wasm"))) return flat;
+    if (existsSync15(join14(flat, "web-tree-sitter.wasm"))) return flat;
     dir = dirname7(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
     const pnpmDir = join14(root, "node_modules", ".pnpm");
-    if (existsSync14(pnpmDir)) {
+    if (existsSync15(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("web-tree-sitter@")) {
           const candidate = join14(
@@ -39717,7 +39959,7 @@ function findRuntimeDir() {
             "node_modules",
             "web-tree-sitter"
           );
-          if (existsSync14(join14(candidate, "web-tree-sitter.wasm"))) {
+          if (existsSync15(join14(candidate, "web-tree-sitter.wasm"))) {
             return candidate;
           }
         }
@@ -42666,7 +42908,7 @@ var init_src11 = __esm({
 });
 
 // src/reconcile.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
 import { join as join15, relative as relative3, sep as sep2 } from "node:path";
 function indexerWouldScan(rel) {
@@ -42680,7 +42922,7 @@ function indexerWouldScan(rel) {
 function gitSourceFiles(root) {
   let stdout;
   try {
-    stdout = execFileSync2(
+    stdout = execFileSync3(
       "git",
       ["-C", root, "ls-files", "--cached", "--others", "--exclude-standard", "-z"],
       { encoding: "utf8", maxBuffer: 128 * 1024 * 1024, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }
@@ -42856,7 +43098,7 @@ __export(mcp_exports, {
   runTool: () => runTool,
   searchGraph: () => searchGraph
 });
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync15 } from "node:fs";
 import { resolve as resolve3 } 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);
@@ -42893,7 +43135,7 @@ function takeEnrichmentNudge(store) {
 ` + items;
 }
 function takeDiscriminatorNudge(path2) {
-  if (!path2 || !existsSync15(path2)) return null;
+  if (!path2 || !existsSync16(path2)) return null;
   let shared;
   try {
     shared = openGraphStore({ path: path2 });
@@ -43024,10 +43266,10 @@ function showNode(store, node2, maxLines) {
   if (!relPath) return { found: false, reason: "no file owner for node" };
   const workspaceRoot = process.cwd();
   const absPath = resolve3(workspaceRoot, relPath);
-  if (!existsSync15(absPath)) {
+  if (!existsSync16(absPath)) {
     return { found: false, reason: `file not found on disk: ${absPath}` };
   }
-  const source = readFileSync13(absPath, "utf8");
+  const source = readFileSync15(absPath, "utf8");
   const attrs = node2.attrs;
   let startByte = attrs["bodyStartByte"] ?? attrs["startByte"];
   let endByte = attrs["bodyEndByte"] ?? attrs["endByte"];
@@ -43329,47 +43571,9 @@ var init_mcp = __esm({
     init_reconcile();
     init_agent_signals();
     INSTRUCTIONS = [
-      // KEEP THIS UNDER THE CLIENT'S ~2 KB instruction-injection budget (the client
-      // truncates `instructions` on connect, ~2008 chars observed). Capture no longer
-      // depends on a standing emit-instruction block: the daemon derives problems/fixes
-      // from your WORK deterministically, and the one thing it asks of the agent — a
-      // one-line root cause at a fix — rides INLINE on the next tool response (the ⚡
-      // errata line; see the dispatch's enrichment piggyback) instead of a fenced
-      // protocol the agent has to remember. So this stays short: tool-routing steering
-      // plus a single line about the inline nudge. Per-tool routing lives in each tool's
-      // own `description` (delivered via tools/list). Don't re-add a tool table here.
-      "errata is a LIVE, bi-temporal code graph of this workspace, kept current by a",
-      "file watcher \u2014 a SEPARATE DIAGNOSTIC AXIS to run ALONGSIDE grep/glob/read, not",
-      "instead of them. For STRUCTURAL questions (callers of callers, blast-radius,",
-      "rename lineage) prefer it: faster, more complete, and it reaches relationships",
-      "grep can't. Each tool's description says when to reach for it. Fall back to",
-      'grep/read when a tool returns found:false (ESPECIALLY reason:"unresolved" \u2014 the',
-      "name was not recognized, NOT an empty answer; an empty list like callers:[] is a",
-      'confident "none" \u2014 trust it), when you need EXACT bytes before a high-stakes',
-      "edit, or for an unindexed file/language. Always confirm exact bytes with a read",
-      "before editing.",
-      "",
-      "errata is a cloud knowledge substrate \u2014 AND ALSO this workspace's code graph.",
-      "The problems you hit and the fixes you make become shared knowledge other agents",
-      "recall. That capture is automatic: derived from your edits/commands/commits \u2014 no",
-      "emit needed. Just after you resolve something a tool result may carry a one-line",
-      "\u26A1 errata note asking the ROOT CAUSE; answer via errata.annotate_resolution when",
-      "you know it, skip it otherwise.",
-      "",
-      "Two things it CAN'T derive \u2014 only you witness them, and this is a CAPTURE",
-      "PROTOCOL, not optional formatting: a problem or fix you state only in prose, a",
-      "list, or your own numbering is SILENTLY LOST \u2014 the tag is the ONLY thing recorded.",
-      "So the moment you state one, wrap it inline (no fence, no extra call):",
-      // Signal tokens come from the single source (agent-signals.ts) so this always-on
-      // block can't teach a grammar the parser rejects. Referent is "its-id" here — the
-      // raw MCP channel has no primed handles, so the agent cites a tool-result id.
-      `  \u2022 ${TAG_EXAMPLE.problem()}  \u2014 EVERY problem you notice or report ([?\u2026] = TODO)`,
-      `  \u2022 ${TAG_EXAMPLE.fix("its-id")}               \u2014 your edit fixed a problem errata showed you`,
-      "Tag every one you state \u2014 we filter downstream, so don't self-censor or batch.",
-      "",
-      "Graph-as-files: the graph is ALSO a virtual FS \u2014 Read (or `cat`)",
-      ".errata/g/<verb>/<seed> to run a query as a file read (e.g. .errata/g/burst/",
-      "<symbol>, /why/<sym>, /trace/<a>..<b>). Read .errata/g/index for the vocabulary."
+      "errata is a live code and knowledge graph, a SEPARATE DIAGNOSTIC AXIS alongside grep/read for callers, blast radius, rename lineage and prior fixes. Fall back to read/search on found:false (unresolved is not an empty answer), or for unindexed code. Confirm exact bytes before editing.",
+      buildAgentInstruction({ signals: ["prior", "problem", "vulnerability", "fix"], referent: "its-id" }),
+      "Read .errata/g/index for graph-as-files query paths. A tool result may ask for a root cause; answer via errata.annotate_resolution when known."
     ].join("\n");
     AUDIT_RUN_THRESHOLD = 5;
     AUDIT_NUDGE_COOLDOWN = 12;
@@ -43784,7 +43988,7 @@ var init_mcp = __esm({
           const local = causalChain(store, { seedId: id, direction: "both", maxHops, limit });
           try {
             const path2 = sharedStorePath();
-            if (!existsSync15(path2)) return { found: true, ...local };
+            if (!existsSync16(path2)) return { found: true, ...local };
             const shared = openGraphStore({ path: path2 });
             try {
               if (!shared.getNode(id)) return { found: true, ...local };
@@ -43961,7 +44165,7 @@ var init_mcp = __esm({
       },
       {
         name: "errata.problems",
-        description: "List the workspace's Problem backlog \u2014 the triage view that search/why/impact can't give because they need a seed. status: 'open' (default) | 'resolved' (a real fix) | 'retracted' (false alarms \u2014 false_positive/dissolution) | 'constraint' (design TENSIONS captured via `(constraint: \u2026)` \u2014 standing context, not open work, so they're excluded from 'open') | 'all'. Also returns a `retracted` breakdown so the false-positive rate stays visible.",
+        description: "List the workspace's Problem and Vulnerability backlog \u2014 the triage view that search/why/impact can't give because they need a seed. status: 'open' (default) | 'resolved' (a real fix) | 'retracted' (false alarms \u2014 false_positive/dissolution) | 'constraint' (design TENSIONS captured via `(constraint: \u2026)` \u2014 standing context, not open work, so they're excluded from 'open') | 'all'. Also returns a `retracted` breakdown so the false-positive rate stays visible.",
         inputSchema: {
           type: "object",
           properties: {
@@ -43973,13 +44177,15 @@ var init_mcp = __esm({
           const want = String(args2["status"] ?? "open");
           const limit = Math.max(1, Math.min(200, Number(args2["limit"] ?? 50)));
           const RETRACTIONS = /* @__PURE__ */ new Set(["false_positive", "invalid", "duplicate"]);
-          const rows = store.findAllVersionsByLabel("Problem").map((p) => {
+          const rows = [...store.findAllVersionsByLabel("Problem"), ...store.findAllVersionsByLabel("Vulnerability")].map((p) => {
             const ra = p.attrs["resolvedAs"];
             const status = ra && RETRACTIONS.has(ra) ? ra : p.attrs["resolvedAt"] != null ? "resolved" : isConstraintProblem(p) ? "constraint" : "open";
             const anchorEdge = store.outEdges(p.id, ["ANCHORED_AT"])[0];
             const anchor = anchorEdge ? store.getNode(anchorEdge.to)?.description : void 0;
             return {
               id: p.id,
+              label: p.label,
+              ...p.label === "Vulnerability" ? { assessment: p.attrs["assessment"] } : {},
               problem: p.description,
               status,
               createdAt: p.createdAt,
@@ -44385,7 +44591,7 @@ var init_mcp = __esm({
         inputSchema: { type: "object", properties: {} },
         handler: () => {
           const path2 = sharedStorePath();
-          if (!existsSync15(path2)) return { count: 0, pending: [] };
+          if (!existsSync16(path2)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const pending = pendingAbstractions(shared);
@@ -44413,7 +44619,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path2 = sharedStorePath();
-          if (!existsSync15(path2)) return { count: 0, pending: [] };
+          if (!existsSync16(path2)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const pending = pendingDiscriminators(shared, {
@@ -44457,7 +44663,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path2 = sharedStorePath();
-          if (!existsSync15(path2)) return { count: 0, routes: [] };
+          if (!existsSync16(path2)) return { count: 0, routes: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const result = triageOf(shared, {
@@ -52344,11 +52550,11 @@ var init_tool_index = __esm({
 
 // src/outbox.ts
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync16,
   renameSync,
-  unlinkSync,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync12
 } from "node:fs";
 import { join as join17 } from "node:path";
@@ -52362,7 +52568,7 @@ function enqueueOutbox(paths, payload) {
 }
 async function flushOutbox(paths, client, store) {
   ensureDir(paths.outbox);
-  const entries = existsSync16(paths.outbox) ? readdirSync5(paths.outbox) : [];
+  const entries = existsSync17(paths.outbox) ? readdirSync5(paths.outbox) : [];
   let uploaded = 0;
   let failed = 0;
   const quarantine = (abs, reason) => {
@@ -52376,7 +52582,7 @@ async function flushOutbox(paths, client, store) {
     const abs = join17(paths.outbox, f);
     let payload;
     try {
-      payload = JSON.parse(readFileSync14(abs, "utf8"));
+      payload = JSON.parse(readFileSync16(abs, "utf8"));
     } catch {
       failed++;
       quarantine(abs, "unparseable JSON");
@@ -52411,7 +52617,7 @@ async function flushOutbox(paths, client, store) {
           }
         }
       }
-      unlinkSync(abs);
+      unlinkSync2(abs);
       if (res.accepted === 0) uploaded++;
     } catch (err2) {
       failed++;
@@ -52421,7 +52627,7 @@ async function flushOutbox(paths, client, store) {
       }
     }
   }
-  const remainingFiles = existsSync16(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
+  const remainingFiles = existsSync17(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
   return { uploaded, failed, remaining: remainingFiles.length };
 }
 var init_outbox = __esm({
@@ -52544,7 +52750,8 @@ function errorRecallTerms(errorText) {
 }
 function recallLine(n, token) {
   const desc = (n.description ?? "").replace(/\s+/g, " ").slice(0, 120);
-  return `- [${n.label}] ${desc}  \u2192  ${token}`;
+  const label = n.label === "Vulnerability" ? `Vulnerability; ${n.attrs["assessment"] ?? "unassessed"}` : n.label;
+  return `- [${label}] ${desc}  \u2192  ${token}`;
 }
 function recallForFile(store, relPath) {
   return fileRecall(store, relPath)?.context ?? null;
@@ -52565,7 +52772,7 @@ function fileRecall(store, relPath) {
   const shownRelated = priors.related.slice(0, 4);
   for (const p of shownProblems) {
     const hasCause = store.outEdges(p.id, ["CAUSED_BY"]).some((e) => store.getNode(e.to)?.label === "RootCause");
-    const causeCue = hasCause ? "" : ` \xB7 ${TAG_EXAMPLE.triageMint()} to diagnose its cause`;
+    const causeCue = hasCause ? "" : ` \xB7 ${p.label === "Vulnerability" ? `(cause:#${p.id} the mechanism)` : TAG_EXAMPLE.triageMint()} to diagnose its cause`;
     lines.push(
       recallLine(p, `${TAG_EXAMPLE.fix(p.id)} if you resolved it \xB7 ${TAG_EXAMPLE.prior(p.id)} to cite${causeCue}`)
     );
@@ -52986,12 +53193,17 @@ function buildWebUi(deps) {
       block,
       lastInjectedHash
     });
+    let systemMessage = null;
     if (sid && block && recallCardEnabled() && (decision || atPrompt)) {
       const card = readContextCard(deps.paths.root, block.hash);
-      if (card) rememberCard(sid, card);
+      if (card) {
+        rememberCard(sid, card);
+        if (decision && sid.startsWith("codex:")) systemMessage = renderRecallLine(card);
+      }
     }
     if (!decision) return c.json({});
     return c.json({
+      ...systemMessage ? { systemMessage } : {},
       hookSpecificOutput: {
         hookEventName: decision.hookEventName,
         additionalContext: decision.additionalContext
@@ -62746,11 +62958,11 @@ var require_readable = __commonJS({
         });
       }
     };
-    function isLocked(self) {
-      return self[kBody] && self[kBody].locked === true || self[kConsume];
+    function isLocked(self2) {
+      return self2[kBody] && self2[kBody].locked === true || self2[kConsume];
     }
-    function isUnusable(self) {
-      return util.isDisturbed(self) || isLocked(self);
+    function isUnusable(self2) {
+      return util.isDisturbed(self2) || isLocked(self2);
     }
     async function consume(stream, type) {
       assert2(!stream[kConsume]);
@@ -63137,42 +63349,42 @@ var require_abort_signal = __commonJS({
     var { RequestAbortedError } = require_errors();
     var kListener = Symbol("kListener");
     var kSignal = Symbol("kSignal");
-    function abort2(self) {
-      if (self.abort) {
-        self.abort(self[kSignal]?.reason);
+    function abort2(self2) {
+      if (self2.abort) {
+        self2.abort(self2[kSignal]?.reason);
       } else {
-        self.reason = self[kSignal]?.reason ?? new RequestAbortedError();
+        self2.reason = self2[kSignal]?.reason ?? new RequestAbortedError();
       }
-      removeSignal(self);
+      removeSignal(self2);
     }
-    function addSignal(self, signal) {
-      self.reason = null;
-      self[kSignal] = null;
-      self[kListener] = null;
+    function addSignal(self2, signal) {
+      self2.reason = null;
+      self2[kSignal] = null;
+      self2[kListener] = null;
       if (!signal) {
         return;
       }
       if (signal.aborted) {
-        abort2(self);
+        abort2(self2);
         return;
       }
-      self[kSignal] = signal;
-      self[kListener] = () => {
-        abort2(self);
+      self2[kSignal] = signal;
+      self2[kListener] = () => {
+        abort2(self2);
       };
-      addAbortListener(self[kSignal], self[kListener]);
+      addAbortListener(self2[kSignal], self2[kListener]);
     }
-    function removeSignal(self) {
-      if (!self[kSignal]) {
+    function removeSignal(self2) {
+      if (!self2[kSignal]) {
         return;
       }
-      if ("removeEventListener" in self[kSignal]) {
-        self[kSignal].removeEventListener("abort", self[kListener]);
+      if ("removeEventListener" in self2[kSignal]) {
+        self2[kSignal].removeEventListener("abort", self2[kListener]);
       } else {
-        self[kSignal].removeListener("abort", self[kListener]);
+        self2[kSignal].removeListener("abort", self2[kListener]);
       }
-      self[kSignal] = null;
-      self[kListener] = null;
+      self2[kSignal] = null;
+      self2[kListener] = null;
     }
     module2.exports = {
       addSignal,
@@ -72029,7 +72241,7 @@ __export(witness_ledger_exports, {
   summarizeWitnessLedger: () => summarizeWitnessLedger,
   witnessLedgerPath: () => witnessLedgerPath
 });
-import { appendFileSync as appendFileSync3, existsSync as existsSync25, readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "node:fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync26, readFileSync as readFileSync29, writeFileSync as writeFileSync20 } from "node:fs";
 import { join as join33 } from "node:path";
 function witnessLedgerPath(configDir) {
   return join33(configDir, "witness-ledger.jsonl");
@@ -72038,7 +72250,7 @@ function appendWitnessLedger(configDir, entry) {
   const path2 = witnessLedgerPath(configDir);
   try {
     appendFileSync3(path2, JSON.stringify(entry) + "\n");
-    const lines = readFileSync27(path2, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync29(path2, "utf8").split("\n").filter(Boolean);
     if (lines.length > LEDGER_MAX_LINES) {
       writeFileSync20(path2, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
     }
@@ -72047,9 +72259,9 @@ function appendWitnessLedger(configDir, entry) {
 }
 function readWitnessLedger(configDir) {
   const path2 = witnessLedgerPath(configDir);
-  if (!existsSync25(path2)) return [];
+  if (!existsSync26(path2)) return [];
   try {
-    return readFileSync27(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
+    return readFileSync29(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
   } catch {
     return [];
   }
@@ -72488,12 +72700,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync2, existsSync as existsSync36, openSync as openSync2, readFileSync as readFileSync37, renameSync as renameSync4, statSync as statSync10 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync36, openSync as openSync2, readFileSync as readFileSync38, renameSync as renameSync4, statSync as statSync10 } from "node:fs";
 import { join as join44, resolve as pathResolve2 } from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync27, writeFileSync as writeFileSync23 } from "node:fs";
+import { existsSync as existsSync28, writeFileSync as writeFileSync23 } 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";
@@ -73072,8 +73284,8 @@ init_webui();
 init_config();
 
 // src/engine.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync26, statSync as statSync8, appendFileSync as appendFileSync4, readdirSync as readdirSync10, renameSync as renameSync3, readFileSync as readFileSync29, writeFileSync as writeFileSync22 } from "node:fs";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync27, statSync as statSync8, appendFileSync as appendFileSync4, readdirSync as readdirSync10, renameSync as renameSync3, readFileSync as readFileSync31, writeFileSync as writeFileSync22 } from "node:fs";
 import { basename as basename7, join as join35, relative as relative6, sep as sep4 } from "node:path";
 
 // src/source-watcher.ts
@@ -74781,16 +74993,16 @@ function createSourceWatcher(targets, opts) {
 }
 function chokidarSourceWatcher(targets, ignored) {
   const w = esm_default.watch([...targets], { ignored, ignoreInitial: true, persistent: true });
-  const self = {
+  const self2 = {
     on(event, listener) {
       w.on(event, listener);
-      return self;
+      return self2;
     },
     add: (p) => void w.add(p),
     unwatch: (p) => void w.unwatch(p),
     close: () => w.close()
   };
-  return self;
+  return self2;
 }
 var NativeSourceWatcher = class extends EventEmitter2 {
   constructor(targets, ignored) {
@@ -75118,7 +75330,7 @@ init_review2();
 
 // src/turn.ts
 init_checkout_root();
-import { closeSync, existsSync as existsSync17, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync6 } from "node:fs";
+import { closeSync, existsSync as existsSync18, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync6 } from "node:fs";
 import { basename as basename5, delimiter, dirname as dirname10, join as join21, normalize as normalize3 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { createHash as createHash16 } from "node:crypto";
@@ -75511,7 +75723,7 @@ function claudeProjectDir(cwd, home = homedir4()) {
 }
 function recentTranscripts(cwd, opts = {}) {
   const dir = claudeProjectDir(cwd, opts.home ?? homedir4());
-  if (!existsSync17(dir)) return [];
+  if (!existsSync18(dir)) return [];
   let names;
   try {
     names = readdirSync6(dir);
@@ -75538,7 +75750,7 @@ function recentTranscripts(cwd, opts = {}) {
 function subagentTranscripts(mainTranscriptPath, sessionId) {
   if (!mainTranscriptPath || !sessionId) return [];
   const dir = join21(dirname10(mainTranscriptPath), sessionId, "subagents");
-  if (!existsSync17(dir)) return [];
+  if (!existsSync18(dir)) return [];
   let names;
   try {
     names = readdirSync6(dir);
@@ -75622,7 +75834,7 @@ function codexRolloutsForCwd(cwd, opts = {}) {
   const owner = checkoutRootOf(cwd);
   const owners = /* @__PURE__ */ new Map();
   for (const root of codexSessionRoots(opts.env, opts.home)) {
-    if (!existsSync17(root)) {
+    if (!existsSync18(root)) {
       codexRolloutActivity.delete(root);
       continue;
     }
@@ -75723,7 +75935,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
   const hashes = geminiHashesFor(cwd);
   const out2 = [];
   for (const root of geminiSessionRoots(opts.env, opts.home)) {
-    if (!existsSync17(root)) continue;
+    if (!existsSync18(root)) continue;
     let slugs;
     try {
       slugs = readdirSync6(root);
@@ -75794,7 +76006,7 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
   }
   const out2 = [];
   for (const root of opencodeSessionRoots(opts.env, opts.home)) {
-    if (!existsSync17(root)) continue;
+    if (!existsSync18(root)) continue;
     let names;
     try {
       names = readdirSync6(root);
@@ -75826,10 +76038,10 @@ init_src2();
 init_agent_signals();
 init_tool_index();
 init_src5();
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "node:fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync13 } 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,80})\]|((?:pat|sol|drc|dcause|dfix|dprob|prob|claim|err)_[0-9a-f]{6,})/gi;
+var HANDLE_RE = /\[([a-z0-9][\w-]{0,80})\]|((?:pat|sol|drc|dcause|dfix|dprob|dvuln|prob|claim|err)_[0-9a-f]{6,})/gi;
 var PLACEHOLDER_HANDLES = /* @__PURE__ */ new Set([
   "handle",
   "its-handle",
@@ -75844,7 +76056,7 @@ var PLACEHOLDER_HANDLES = /* @__PURE__ */ new Set([
   "b"
 ]);
 var isPlaceholderHandle = (h) => PLACEHOLDER_HANDLES.has(h.toLowerCase());
-var FLAG_BODY_HANDLE_RE = /^(?:[a-z0-9]+(?:-[a-z0-9]+){2,}-(?=[0-9a-f]{0,3}\d)[0-9a-f]{4}|(?:pat|sol|drc|dcause|dfix|dprob|prob|claim|err)_[0-9a-f]{6,})$/i;
+var FLAG_BODY_HANDLE_RE = /^(?:[a-z0-9]+(?:-[a-z0-9]+){2,}-(?=[0-9a-f]{0,3}\d)[0-9a-f]{4}|(?:pat|sol|drc|dcause|dfix|dprob|dvuln|prob|claim|err)_[0-9a-f]{6,})$/i;
 var FIX_PREFIX = /^\s*fix:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var CONSTRAINT_RE = /\(\s*constraint:\s*([^()\n]{8,}?)\s*\)/gi;
 var CAUSE_PREFIX = /^\s*cause:(?:#([a-z][\w-]{0,63}))?\s*/i;
@@ -75869,7 +76081,7 @@ var DOMAIN_RE = /\(\s*domain:\s*([^()\n]{3,}?)\s*\)/gi;
 var PACKAGE_RE = /\(\s*package:\s*([^()\n]{2,}?)\s*\)/gi;
 var COMPONENT_RE = /\(\s*component:\s*([^()\n]{2,}?)\s*\)/gi;
 var CAUSE_TEXT_MIN = 8;
-var FLAG_RE = /\[([!?])(?:#([a-z][\w-]{0,63})\s+)?\s*((?:\[[^\]\n]*\]|[^\]\n]){8,}?)\s*(?:@\s*([^\s\]]+?)(?::(\d+))?\s*)?\]/g;
+var FLAG_RE = /\[([!?])(?:#([a-z][\w-]{0,63})\s+)?\s*((?:\[[^\]\n]*\]|[^\]\n])*?)\s*(?:@\s*([^\s\]]+?)(?::(\d+))?\s*)?\]/g;
 var CONSTRAINT_MIN = 8;
 function clauseBefore(sentence, idx) {
   const win = sentence.slice(Math.max(0, idx - 80), idx);
@@ -76013,6 +76225,7 @@ function cleanEmittedTags(tags) {
 }
 function emptyTagDispositions() {
   return {
+    invalidVulnerability: 0,
     oversizeSegments: 0,
     codeSpanNeutralized: 0,
     refuteTooShort: 0,
@@ -76025,6 +76238,7 @@ function emptyTagDispositions() {
   };
 }
 function addTagDispositions(a, b) {
+  a.invalidVulnerability += b.invalidVulnerability;
   a.oversizeSegments += b.oversizeSegments;
   a.codeSpanNeutralized += b.codeSpanNeutralized;
   a.refuteTooShort += b.refuteTooShort;
@@ -76038,12 +76252,31 @@ function addTagDispositions(a, b) {
 function parseInlineTags(text) {
   return parseInlineTagsWithDispositions(text).tags;
 }
+function* captureSentences(text) {
+  for (const line of text.split(/\n+/)) {
+    if (line.length > 2e4) {
+      yield line;
+      continue;
+    }
+    const flags2 = [...line.matchAll(new RegExp(FLAG_RE.source, FLAG_RE.flags))].map((m) => ({ start: m.index, end: m.index + m[0].length }));
+    let flag = 0;
+    let start2 = 0;
+    for (const boundary of line.matchAll(/(?<=[.!?])\s+(?!\(fix:)/g)) {
+      const index = boundary.index;
+      while (flags2[flag] && flags2[flag].end <= index) flag++;
+      if (flags2[flag] && flags2[flag].start < index) continue;
+      yield line.slice(start2, index);
+      start2 = index + boundary[0].length;
+    }
+    yield line.slice(start2);
+  }
+}
 function parseInlineTagsWithDispositions(text) {
   const out2 = [];
   const dispositions = emptyTagDispositions();
   const deFenced = text.replace(/```[\s\S]*?```/g, " ");
   let seqNo = -1;
-  for (const raw2 of deFenced.split(/(?<=[.!?])\s+(?!\(fix:)|\n+/)) {
+  for (const raw2 of captureSentences(deFenced)) {
     seqNo++;
     if (raw2.length > 2e4) {
       dispositions.oversizeSegments++;
@@ -76269,6 +76502,29 @@ function parseInlineTagsWithDispositions(text) {
     while ((f = FLAG_RE.exec(sentence)) !== null) {
       const flagThread = f[2];
       const raw3 = f[3].trim();
+      if (/^vuln\b/i.test(raw3)) {
+        const typed = /^vuln:\s*([\s\S]*)$/i.exec(raw3);
+        const body2 = typed?.[1]?.trim() ?? "";
+        const parts2 = body2.split(CAUSE_ARROW).map((s) => s.trim());
+        const symptom = f[1] === "!" && parts2.length > 1 && !f[4] ? new RegExp(FLAG_RE.source, "i").exec(`[!${parts2[0]}]`) : null;
+        const statement = f[1] === "?" ? body2 : symptom?.[3]?.trim() ?? parts2[0];
+        if (statement.length < 8 || /^<[^>]*>$/.test(statement)) {
+          dispositions.invalidVulnerability++;
+          continue;
+        }
+        const path2 = (f[4] ?? symptom?.[4])?.trim();
+        const line = f[5] ?? symptom?.[5];
+        out2.push({
+          kind: "vulnerability",
+          statement,
+          assessment: f[1] === "!" ? "asserted" : "suspected",
+          ...f[1] === "!" && parts2.length > 1 ? { vulnerabilityCauses: parts2.slice(1).filter((s) => s.length >= CAUSE_TEXT_MIN) } : {},
+          ...path2 ? { location: { path: path2, ...line ? { line: Number(line) } : {} } } : {},
+          ...flagThread ? { threadId: flagThread } : {},
+          sentence: sfield
+        });
+        continue;
+      }
       if (FLAG_BODY_HANDLE_RE.test(raw3) && !f[4]) {
         dispositions.flagAsHandle++;
         out2.push({ kind: "prior", handle: raw3, sentence: sfield });
@@ -76521,7 +76777,7 @@ function writePrimingHandles(path2, nodes, now = Date.now()) {
 }
 function readPrimingHandles(path2) {
   try {
-    return JSON.parse(readFileSync15(path2, "utf8"));
+    return JSON.parse(readFileSync17(path2, "utf8"));
   } catch {
     return {};
   }
@@ -76639,7 +76895,7 @@ function harvestInlineTags(store, text, opts) {
   const parsed = parseInlineTagsWithDispositions(text);
   const tags = parsed.tags;
   plan.dispositions = parsed.dispositions;
-  const symptomSeqs = tags.filter((t) => (t.kind === "problem" || t.kind === "todo") && t.statement).map((t) => ({ seq: t.seq ?? -1, statement: t.statement, threadId: t.threadId })).sort((a, b) => a.seq - b.seq);
+  const symptomSeqs = tags.filter((t) => (t.kind === "problem" || t.kind === "todo" || t.kind === "vulnerability") && t.statement).map((t) => ({ seq: t.seq ?? -1, statement: t.statement, threadId: t.threadId, kind: t.kind })).sort((a, b) => a.seq - b.seq);
   const bindSymptom = (seq, threadId) => {
     if (threadId) {
       const hit = symptomSeqs.find((s) => s.threadId === threadId);
@@ -76652,6 +76908,7 @@ function harvestInlineTags(store, text, opts) {
     if (seq == null) return { evidence: "inferred" };
     let best;
     for (const s of symptomSeqs) {
+      if (s.kind === "vulnerability") continue;
       if (s.seq <= seq) best = s;
       else break;
     }
@@ -76666,10 +76923,13 @@ function harvestInlineTags(store, text, opts) {
     return id;
   };
   for (const tag of tags) {
-    if (tag.kind === "problem" || tag.kind === "todo") {
+    if (tag.kind === "problem" || tag.kind === "todo" || tag.kind === "vulnerability") {
       plan.problems.push({
         statement: tag.statement,
         kind: tag.kind,
+        ...tag.assessment ? { assessment: tag.assessment } : {},
+        ...tag.vulnerabilityCauses ? { vulnerabilityCauses: tag.vulnerabilityCauses } : {},
+        ...tag.kind === "vulnerability" && tag.seq !== void 0 ? { seq: tag.seq } : {},
         ...tag.location ? { location: tag.location } : {},
         ...tag.threadId ? { threadId: tag.threadId } : {}
       });
@@ -76692,7 +76952,7 @@ function harvestInlineTags(store, text, opts) {
         } else if (tag.threadId && !b.statement) {
           plan.fixes.push({ inScope: true, fixNote: tag.fixRationale, threadId: tag.threadId });
         } else if (b.statement && b.evidence === "witnessed") {
-          plan.fixes.push({ inScope: true, fixNote: tag.fixRationale, boundStatement: b.statement });
+          plan.fixes.push({ inScope: true, fixNote: tag.fixRationale, boundStatement: b.statement, ...tag.threadId ? { threadId: tag.threadId } : {} });
         } else {
           plan.fixes.push({ inScope: true, fixNote: tag.fixRationale, ambiguous: true });
         }
@@ -76895,6 +77155,7 @@ function harvestInlineTags(store, text, opts) {
 }
 var CORROBORATABLE_LABELS = /* @__PURE__ */ new Set([
   "Problem",
+  "Vulnerability",
   "Solution",
   "RootCause",
   "Pattern",
@@ -76996,7 +77257,7 @@ ${conversation}` }]
 // src/constraint-backfill.ts
 init_src5();
 init_src2();
-import { existsSync as existsSync18, readFileSync as readFileSync16, readdirSync as readdirSync7, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync18, readdirSync as readdirSync7, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join22 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 var BACKFILL_VERSION = 1;
@@ -77015,9 +77276,9 @@ function markerPath(configDir) {
 }
 function alreadyDone(configDir) {
   const p = markerPath(configDir);
-  if (!existsSync18(p)) return false;
+  if (!existsSync19(p)) return false;
   try {
-    const raw2 = JSON.parse(readFileSync16(p, "utf8"));
+    const raw2 = JSON.parse(readFileSync18(p, "utf8"));
     return raw2?.version === BACKFILL_VERSION;
   } catch {
     return false;
@@ -77027,7 +77288,7 @@ function replay(root) {
   const statements = /* @__PURE__ */ new Set();
   const citedByFix = /* @__PURE__ */ new Set();
   const dir = claudeProjectDir(root, homedir5());
-  if (!existsSync18(dir)) return { statements, citedByFix };
+  if (!existsSync19(dir)) return { statements, citedByFix };
   let names;
   try {
     names = readdirSync7(dir).filter((n) => n.endsWith(".jsonl"));
@@ -77037,7 +77298,7 @@ function replay(root) {
   for (const f of names) {
     let lines;
     try {
-      lines = readFileSync16(join22(dir, f), "utf8").split("\n");
+      lines = readFileSync18(join22(dir, f), "utf8").split("\n");
     } catch {
       continue;
     }
@@ -77164,7 +77425,7 @@ function backfillConstraintKind(store, opts) {
 // src/edge-repair.ts
 init_src();
 init_src5();
-import { existsSync as existsSync19, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync15 } from "node:fs";
 import { join as join23 } from "node:path";
 function citeEdgeId(from, type, to) {
   return `edge_${digest({ from, type, to })}`.slice(0, 24);
@@ -77184,9 +77445,9 @@ function markerPath2(configDir) {
 }
 function alreadyDone2(configDir) {
   const p = markerPath2(configDir);
-  if (!existsSync19(p)) return false;
+  if (!existsSync20(p)) return false;
   try {
-    return JSON.parse(readFileSync17(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
+    return JSON.parse(readFileSync19(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
   } catch {
     return false;
   }
@@ -77249,7 +77510,7 @@ function repairInvalidEdges(store, opts) {
 init_reconcile();
 
 // src/pass-ledger.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync16 } from "node:fs";
 import { join as join24 } from "node:path";
 
 // src/isolate-census.ts
@@ -77302,7 +77563,7 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
       return;
     }
     appendsSinceTrim.set(path2, 0);
-    const lines = readFileSync18(path2, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync20(path2, "utf8").split("\n").filter(Boolean);
     const keptByKind = /* @__PURE__ */ new Map();
     const kept = [];
     for (let i2 = lines.length - 1; i2 >= 0; i2--) {
@@ -77325,9 +77586,9 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
 }
 function readPassLedger(configDir) {
   const path2 = passLedgerPath(configDir);
-  if (!existsSync20(path2)) return [];
+  if (!existsSync21(path2)) return [];
   try {
-    return readFileSync18(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
+    return readFileSync20(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
       (e) => typeof e?.ts === "number" && typeof e?.kind === "string" && typeof e?.durationMs === "number"
     ).map((e) => ({ ...e, counts: e.counts ?? {} }));
   } catch {
@@ -77699,11 +77960,11 @@ init_outbox();
 init_src10();
 init_src();
 init_src2();
-import { readFileSync as readFileSync19 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 import { join as join25 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync19(join25(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync21(join25(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -78080,8 +78341,8 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 
 // src/retrieval-stack.ts
 init_src();
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync20, statSync as statSync7 } from "node:fs";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { existsSync as existsSync22, readFileSync as readFileSync22, statSync as statSync7 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join26 } from "node:path";
 var RETRIEVAL_STACK_CAP = 24;
@@ -78373,7 +78634,7 @@ function mavenGroupIsSelfDisclosing(name2, selfTokens) {
 function loadRegistryPolicy(root, env2 = process.env, repoLocator) {
   const read2 = (p) => {
     try {
-      return readFileSync20(p, "utf8");
+      return readFileSync22(p, "utf8");
     } catch {
       return null;
     }
@@ -78599,7 +78860,7 @@ function readDirectDependencies(root) {
   for (const c of LOCKFILES) {
     if (familiesSeen.has(c.family)) continue;
     const p = join26(root, c.file);
-    if (!existsSync21(p)) continue;
+    if (!existsSync22(p)) continue;
     try {
       const s = statSync7(p);
       stamps.push(`${c.file}:${s.mtimeMs}:${s.size}`);
@@ -78619,7 +78880,7 @@ function readDirectDependencies(root) {
   const direct = [];
   for (const { c, path: path2 } of found) {
     try {
-      direct.push(...c.parse(readFileSync20(path2, "utf8")).direct ?? []);
+      direct.push(...c.parse(readFileSync22(path2, "utf8")).direct ?? []);
     } catch {
     }
   }
@@ -78628,7 +78889,7 @@ function readDirectDependencies(root) {
 }
 function manifestPaths(root) {
   try {
-    const out2 = execFileSync3("git", ["-C", root, "ls-files", "-z"], {
+    const out2 = execFileSync4("git", ["-C", root, "ls-files", "-z"], {
       encoding: "utf8",
       maxBuffer: 128 * 1024 * 1024,
       windowsHide: true,
@@ -78662,14 +78923,14 @@ function manifestPaths(root) {
     "project.godot"
   ];
   return {
-    paths: ROOT_MANIFESTS.filter((f) => existsSync21(join26(root, f))),
+    paths: ROOT_MANIFESTS.filter((f) => existsSync22(join26(root, f))),
     tracked: false,
     truncated: false
   };
 }
 var WORKSPACE_MARKERS = ["pnpm-workspace.yaml", "lerna.json", "go.work", "settings.gradle", "settings.gradle.kts"];
 function rootDeclaresWorkspace(root, texts) {
-  if (WORKSPACE_MARKERS.some((f) => existsSync21(join26(root, f)))) return true;
+  if (WORKSPACE_MARKERS.some((f) => existsSync22(join26(root, f)))) return true;
   return /"workspaces"\s*:/.test(texts.get("package.json") ?? "") || /<modules>/.test(texts.get("pom.xml") ?? "") || /^\s*\[workspace\]/m.test(texts.get("Cargo.toml") ?? "");
 }
 var EMPTY_SCAN = { deps: [], self: [], complete: true };
@@ -78687,7 +78948,7 @@ function scanManifests(root) {
     try {
       const s = statSync7(abs);
       stamps.push(`${rel}:${s.mtimeMs}:${s.size}`);
-      texts.set(rel, readFileSync20(abs, "utf8"));
+      texts.set(rel, readFileSync22(abs, "utf8"));
     } catch {
     }
   }
@@ -78716,11 +78977,11 @@ function readManifestDependencies(root) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync22, readFileSync as readFileSync21, watch as fsWatch } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync23, watch as fsWatch } from "node:fs";
 import { join as join27 } from "node:path";
 function readFirstLine(path2) {
   try {
-    return readFileSync21(path2, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync23(path2, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
@@ -78739,13 +79000,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync22(join27(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync22(join27(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync23(join27(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync23(join27(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync21(join27(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync23(join27(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -78779,7 +79040,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync22(join27(gitDir, "index.lock"))) {
+      if (existsSync23(join27(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -79014,7 +79275,7 @@ var TelemetryRecorder = class {
 };
 
 // src/file-activity.ts
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync25 } from "node:fs";
 import { join as join29 } from "node:path";
 import { createHash as createHash17 } from "node:crypto";
 
@@ -79767,7 +80028,7 @@ init_git_remote();
 // src/history-bundle.ts
 init_src();
 import { execFile as execFile2 } from "node:child_process";
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 import { join as join28 } from "node:path";
 var DEFAULT_MAX_TOKENS = 6e3;
 var FILE_LIST_CAP = 60;
@@ -79803,7 +80064,7 @@ function pathAllowedByFloor(path2) {
 function loadRepoIgnore(root, extraPatterns = []) {
   let source = "";
   try {
-    source = readFileSync22(join28(root, ".errataignore"), "utf8");
+    source = readFileSync24(join28(root, ".errataignore"), "utf8");
   } catch {
     source = "";
   }
@@ -80096,7 +80357,7 @@ function readActivityBranch(root) {
   try {
     const gitDir = resolveGitDir(root);
     if (!gitDir) return null;
-    const head2 = readFileSync23(join29(gitDir, "HEAD"), "utf8").trim();
+    const head2 = readFileSync25(join29(gitDir, "HEAD"), "utf8").trim();
     const branch = head2.startsWith("ref: refs/heads/") ? head2.slice(16) : /^[a-f0-9]{40,64}$/i.test(head2) ? "HEAD" : null;
     return branch && branch.length <= 256 && !/[\x00-\x1f\x7f]/.test(branch) ? branch : null;
   } catch {
@@ -80253,11 +80514,11 @@ var FileActivityReporter = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync26,
   readdirSync as readdirSync8,
-  unlinkSync as unlinkSync2,
+  unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync17
 } from "node:fs";
 import { basename as basename6, join as join30 } from "node:path";
@@ -80265,9 +80526,9 @@ function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync23(manifestPath)) return [];
+  if (!existsSync24(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync24(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync26(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -80318,7 +80579,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     if (!f.endsWith(".md")) continue;
     if (keep.has(basename6(f))) continue;
     try {
-      unlinkSync2(join30(paths.skillsDir, f));
+      unlinkSync3(join30(paths.skillsDir, f));
       pruned++;
     } catch {
     }
@@ -80336,10 +80597,10 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
 init_src2();
 import {
   cpSync,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   lstatSync,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync25,
+  readFileSync as readFileSync27,
   readdirSync as readdirSync9,
   rmSync as rmSync3,
   symlinkSync,
@@ -80396,7 +80657,7 @@ function skillCiteHandle(s) {
   return priorHandle({ id: s.id, description: s.title });
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync24(dir)) return 0;
+  if (!existsSync25(dir)) return 0;
   let pruned = 0;
   for (const name2 of readdirSync9(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
@@ -80410,7 +80671,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync24(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
+    if (existsSync25(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -80439,7 +80700,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync25(s.bodyPath, "utf8");
+      body2 = readFileSync27(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -80459,7 +80720,7 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync24(join31(root, h.configDir))) continue;
+    if (!existsSync25(join31(root, h.configDir))) continue;
     const dir = join31(root, h.skillsDir);
     mkdirSync8(dir, { recursive: true });
     for (const slug2 of slugs) {
@@ -80472,9 +80733,9 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync24(manifestPath)) return [];
+  if (!existsSync25(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync25(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync27(manifestPath, "utf8"));
     return (parsed.skills ?? []).filter((s) => Boolean(s.id && s.file)).map((s) => ({
       id: s.id,
       title: s.title ?? s.id,
@@ -80497,7 +80758,7 @@ function ensureSkillGitignore(root) {
   const path2 = join31(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync24(path2) ? readFileSync25(path2, "utf8") : "";
+    current = existsSync25(path2) ? readFileSync27(path2, "utf8") : "";
   } catch {
     return;
   }
@@ -80515,7 +80776,7 @@ ${GITIGNORE_LINES.join("\n")}
 var INTENT_TTL_MS = 15 * 60 * 1e3;
 function createIntentState(ttlMs = INTENT_TTL_MS) {
   const bySession = /* @__PURE__ */ new Map();
-  let recent2 = null;
+  let recent3 = null;
   const live3 = (s, nowMs) => s !== void 0 && nowMs - s.atMs < ttlMs;
   return {
     set(sessionId, text, nowMs) {
@@ -80523,8 +80784,8 @@ function createIntentState(ttlMs = INTENT_TTL_MS) {
       if (!trimmed) return false;
       const prev = bySession.get(sessionId);
       bySession.set(sessionId, { text: trimmed, atMs: nowMs });
-      const changed = !(recent2 && recent2.text === trimmed);
-      recent2 = { sessionId, text: trimmed, atMs: nowMs };
+      const changed = !(recent3 && recent3.text === trimmed);
+      recent3 = { sessionId, text: trimmed, atMs: nowMs };
       if (!changed && prev && prev.text === trimmed) return false;
       return changed;
     },
@@ -80533,12 +80794,12 @@ function createIntentState(ttlMs = INTENT_TTL_MS) {
       return live3(s, nowMs) ? s.text : void 0;
     },
     mostRecent(nowMs) {
-      if (!recent2) return void 0;
-      return nowMs - recent2.atMs < ttlMs ? recent2.text : void 0;
+      if (!recent3) return void 0;
+      return nowMs - recent3.atMs < ttlMs ? recent3.text : void 0;
     },
     clear(sessionId) {
       bySession.delete(sessionId);
-      if (recent2?.sessionId === sessionId) recent2 = null;
+      if (recent3?.sessionId === sessionId) recent3 = null;
     }
   };
 }
@@ -80546,19 +80807,19 @@ function createIntentState(ttlMs = INTENT_TTL_MS) {
 // src/working-file-state.ts
 function createWorkingFileState() {
   const bySession = /* @__PURE__ */ new Map();
-  let recent2 = null;
+  let recent3 = null;
   return {
     set(sessionId, rel) {
       bySession.set(sessionId, rel);
-      if (rel === recent2) return false;
-      recent2 = rel;
+      if (rel === recent3) return false;
+      recent3 = rel;
       return true;
     },
     get(sessionId) {
       return bySession.get(sessionId);
     },
     mostRecent() {
-      return recent2;
+      return recent3;
     }
   };
 }
@@ -80600,7 +80861,7 @@ init_paths();
 init_profile2();
 
 // src/witness-queue.ts
-import { readFileSync as readFileSync26, renameSync as renameSync2, writeFileSync as writeFileSync19 } from "node:fs";
+import { readFileSync as readFileSync28, renameSync as renameSync2, writeFileSync as writeFileSync19 } from "node:fs";
 import { dirname as dirname11, join as join32 } from "node:path";
 var WITNESS_QUEUE_CAP = 500;
 var WITNESS_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -80611,7 +80872,7 @@ function witnessQueuePath(workspaceConfigDir) {
 function loadWitnessQueueWithLosses(path2) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync26(path2, "utf8"));
+    raw2 = JSON.parse(readFileSync28(path2, "utf8"));
   } catch (err2) {
     const absent = err2?.code === "ENOENT";
     return { queue: [], fileUnreadable: !absent, malformedEntries: 0 };
@@ -80673,9 +80934,9 @@ function partitionReplayable(queue, channel, isShipped) {
 function retireWitnesses(queue, channel, settledKeys) {
   return queue.filter((w) => !(w.channel === channel && settledKeys.has(w.witnessKey)));
 }
-var WIRE_SHIPPED_LABELS = /* @__PURE__ */ new Set(["Problem", "Solution", "RootCause"]);
+var WIRE_SHIPPED_LABELS = /* @__PURE__ */ new Set(["Problem", "Vulnerability", "Solution", "RootCause"]);
 var MOTIF_ID_PREFIX = "motif_community_";
-var CANONICAL_ID_RE = /^(?:pat|sol|drc|dcause|dfix|dprob|prob|claim|err)_[0-9a-f]{6,}$/i;
+var CANONICAL_ID_RE = /^(?:pat|sol|drc|dcause|dfix|dprob|dvuln|prob|claim|err)_[0-9a-f]{6,}$/i;
 function classifyWitnessTarget(nodeId, getNode) {
   if (nodeId.startsWith(MOTIF_ID_PREFIX)) {
     const exemplar = nodeId.slice(MOTIF_ID_PREFIX.length);
@@ -80932,7 +81193,7 @@ function maybeFlushDigests() {
 
 // src/liveness-watch.ts
 init_src5();
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "node:fs";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync21 } from "node:fs";
 import { join as join34 } from "node:path";
 
 // src/loop-lag.ts
@@ -80941,7 +81202,7 @@ var RECENT_PASS_LIMIT = 12;
 var active = /* @__PURE__ */ new Map();
 var nextPassId = 1;
 var started = false;
-var recent = [];
+var recent2 = [];
 function markPass(name2) {
   const id = nextPassId++;
   const startedAt = Date.now();
@@ -80951,8 +81212,8 @@ function markPass(name2) {
     if (ended) return;
     ended = true;
     active.delete(id);
-    recent.unshift({ name: name2, ms: Date.now() - startedAt, endedAt: Date.now() });
-    if (recent.length > RECENT_PASS_LIMIT) recent.pop();
+    recent2.unshift({ name: name2, ms: Date.now() - startedAt, endedAt: Date.now() });
+    if (recent2.length > RECENT_PASS_LIMIT) recent2.pop();
   };
 }
 function oldestActive() {
@@ -80966,7 +81227,7 @@ function passState() {
     current: oldest?.name ?? "idle",
     runningMs: oldest === null ? null : now - oldest.startedAt,
     active: [...active.values()].map((p) => ({ name: p.name, runningMs: now - p.startedAt })),
-    recent: [...recent]
+    recent: [...recent2]
   };
 }
 function describeHolders(running, finished, windowStart, now) {
@@ -80985,7 +81246,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
     const now = Date.now();
     const lag = now - last - HEARTBEAT_MS;
     if (lag > thresholdMs) {
-      const who = describeHolders(active.values(), recent, last, now);
+      const who = describeHolders(active.values(), recent2, last, now);
       console.warn(
         `[loop-lag] ${(/* @__PURE__ */ new Date()).toISOString()} event loop held ~${(lag / 1e3).toFixed(1)}s during "${who}"`
       );
@@ -81068,7 +81329,7 @@ function alarmStatePath(configDir) {
 }
 function loadAlarmState(configDir) {
   try {
-    const raw2 = JSON.parse(readFileSync28(alarmStatePath(configDir), "utf8"));
+    const raw2 = JSON.parse(readFileSync30(alarmStatePath(configDir), "utf8"));
     return new Map(Object.entries(raw2).filter((e) => typeof e[1] === "number"));
   } catch {
     return /* @__PURE__ */ new Map();
@@ -81229,8 +81490,8 @@ function createWatchBreaker(deps) {
         windows2.set(watchedPath, w);
       }
       w.dispatched++;
-      const self = evPath == null || evPath === "" || typeof evPath === "string" && normalizeWatchPath(evPath) === normalizeWatchPath(watchedPath);
-      if (!self) return;
+      const self2 = evPath == null || evPath === "" || typeof evPath === "string" && normalizeWatchPath(evPath) === normalizeWatchPath(watchedPath);
+      if (!self2) return;
       w.self++;
       if (!w.tripped && !quarantined.has(watchedPath) && w.self >= BREAKER_TRIP_SELF_EVENTS) {
         w.tripped = true;
@@ -81245,7 +81506,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.16-dev.3332" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.16-dev.3355" : "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;
@@ -81257,7 +81518,7 @@ var CODEX_SWEEP_LOOKBACK_MS = 10 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync26(path2) && statSync8(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync27(path2) && statSync8(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync3(path2, `${path2}.1`);
     }
     appendFileSync4(path2, line);
@@ -81267,7 +81528,7 @@ function appendIdentityAudit(path2, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync29(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync31(path2, "utf8"));
     return new Map(
       Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
     );
@@ -81277,7 +81538,7 @@ function loadTurnCursors(path2) {
 }
 function loadTurnOffsets(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync29(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync31(path2, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const off = typeof v === "object" && v !== null ? v.offset : void 0;
@@ -81300,7 +81561,7 @@ function saveTurnCursors(path2, cursors, offsets) {
 function gitSourceWatchTargets(root) {
   const SOURCE = /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i;
   try {
-    const lsOut = execFileSync4("git", ["-C", root, "ls-files", "-z"], {
+    const lsOut = execFileSync5("git", ["-C", root, "ls-files", "-z"], {
       encoding: "utf8",
       maxBuffer: 128 * 1024 * 1024,
       windowsHide: true,
@@ -81310,7 +81571,7 @@ function gitSourceWatchTargets(root) {
     if (sourceFiles.length === 0) throw new Error("no tracked source");
     let ignoredDirs = [];
     try {
-      const igOut = execFileSync4(
+      const igOut = execFileSync5(
         "git",
         ["-C", root, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"],
         { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }
@@ -81582,7 +81843,7 @@ function createWorkspaceEngine(opts) {
       );
     };
     const gitDir = join35(opts.workspaceRoot, ".git");
-    if (existsSync26(gitDir)) {
+    if (existsSync27(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -82137,6 +82398,9 @@ function createWorkspaceEngine(opts) {
   const harvestTextsInner = async (sessionId, items) => {
     let minted = 0;
     let tagsSeen = 0;
+    let vulnerabilitiesSeen = 0;
+    let vulnerabilitiesMinted = 0;
+    let vulnerabilitiesSuspected = 0;
     let tagsRejected = 0;
     let tagsRestated = 0;
     let resolved = 0;
@@ -82367,10 +82631,73 @@ function createWorkspaceEngine(opts) {
         if ((toolRuns.get(sessionId)?.size ?? 0) > 0) touchedToolTurns++;
         const wf = workingFiles.get(sessionId);
         let inScopeProblemId;
+        const findingIds = /* @__PURE__ */ new Map();
+        const conflictingThreads = /* @__PURE__ */ new Set();
         const threads = sessionThreads.get(sessionId) ?? /* @__PURE__ */ new Map();
         sessionThreads.set(sessionId, threads);
         for (const p of plan.problems) {
           tagsSeen++;
+          if (p.kind === "vulnerability") {
+            vulnerabilitiesSeen++;
+            if (p.assessment === "suspected") vulnerabilitiesSuspected++;
+            let fileText;
+            let anchorReadFailed = false;
+            if (p.location) {
+              try {
+                fileText = readFileSync31(join35(opts.workspaceRoot, p.location.path), "utf8");
+              } catch {
+                anchorReadFailed = true;
+              }
+            }
+            const result = ingestWitnessedVulnerability(store, {
+              statement: p.statement,
+              assessment: p.assessment,
+              target: p.location?.path,
+              line: p.location?.line,
+              fileText,
+              existingId: p.threadId ? threads.get(p.threadId) ?? handleMap[p.threadId]?.id ?? store.getNode(p.threadId)?.id : void 0
+            }, { workspaceId: profile.id, source: sessionId, ts: t, hostHarness: turn.hostHarness });
+            let anchorDisposition = p.location ? "unresolved" : "absent";
+            if (result.rejected) {
+              tagsRejected++;
+              if (p.threadId) conflictingThreads.add(p.threadId);
+            } else {
+              findingIds.set(p.statement, result.id);
+              if (p.threadId) threads.set(p.threadId, result.id);
+              if (result.created || result.corroborated || result.upgraded) minted++;
+              else tagsRestated++;
+              if (result.created) vulnerabilitiesMinted++;
+              if (p.location) {
+                try {
+                  const anchored = anchorProblemToWorkingFile(store, result.id, p.location.path, profile.id, t, "witnessed", { line: p.location.line, fileText });
+                  anchorDisposition = anchored ? "resolved" : anchorReadFailed ? "error" : "unresolved";
+                  if (anchored) deriveContextFromAnchors(store, result.id, t);
+                } catch {
+                  anchorDisposition = "error";
+                }
+              }
+              const node2 = store.getNode(result.id);
+              store.updateNode(result.id, { attrs: { ...node2.attrs, anchorDisposition } });
+              if (p.vulnerabilityCauses) triaged += recordVulnerabilityCause(store, result.id, p.vulnerabilityCauses, t);
+            }
+            log.append({
+              kind: "vulnerability.witness",
+              workspaceId: profile.id,
+              ts: t,
+              digest: digest({ kind: "vulnerability.witness", workspaceId: profile.id, sessionId, turnId: turn.uuid, statement: p.statement, assessment: p.assessment, location: p.location }),
+              sessionId,
+              turnId: turn.uuid,
+              harness: turn.hostHarness,
+              findingId: result.id,
+              statement: p.statement,
+              assessment: p.assessment,
+              location: p.location,
+              seq: p.seq,
+              anchorDisposition,
+              disposition: result.rejected ?? (result.created ? "created" : result.upgraded ? "upgraded" : result.corroborated ? "corroborated" : "restated")
+            });
+            continue;
+          }
           const anchorPath = p.location?.path ?? editedTurnFile;
           const anchorProvenance = p.location?.path ? "witnessed" : "edited";
           const hintPath = anchorPath ? void 0 : turnFile ?? wf;
@@ -82465,10 +82792,10 @@ function createWorkspaceEngine(opts) {
           if (r.created || r.corroborated) {
             minted++;
             if (p.kind !== "constraint") {
-              sessionLastProblem.set(sessionId, designProblemId(p.statement));
-              inScopeProblemId = designProblemId(p.statement);
+              sessionLastProblem.set(sessionId, r.problemId);
+              inScopeProblemId = r.problemId;
             }
-            if (p.threadId) threads.set(p.threadId, designProblemId(p.statement));
+            if (p.threadId) threads.set(p.threadId, r.problemId);
             try {
               if (anchorPath) {
                 let enclosing = {};
@@ -82477,7 +82804,7 @@ function createWorkspaceEngine(opts) {
                     const headSha = readGitRefState(join35(opts.workspaceRoot, ".git")).sha ?? void 0;
                     enclosing = {
                       line: p.location.line,
-                      fileText: readFileSync29(join35(opts.workspaceRoot, anchorPath), "utf8"),
+                      fileText: readFileSync31(join35(opts.workspaceRoot, anchorPath), "utf8"),
                       ...headSha ? { headSha } : {}
                     };
                   } catch {
@@ -82505,7 +82832,8 @@ function createWorkspaceEngine(opts) {
           );
         }
         for (const fx of plan.fixes) {
-          const pid = fx.problemId ?? (fx.threadId ? threads.get(fx.threadId) : void 0) ?? (fx.boundStatement ? designProblemId(fx.boundStatement) : void 0);
+          if (fx.threadId && conflictingThreads.has(fx.threadId)) continue;
+          const pid = fx.problemId ?? (fx.threadId ? threads.get(fx.threadId) : void 0) ?? (fx.boundStatement ? findingIds.get(fx.boundStatement) ?? designProblemId(fx.boundStatement) : void 0);
           if (!pid) {
             if (fx.inScope) {
               console.warn(
@@ -82517,7 +82845,7 @@ function createWorkspaceEngine(opts) {
           const closed = resolveDesignProblemById(store, pid, fx.fixNote, t);
           if (!closed) {
             const n = store.getNode(pid);
-            if (!n || n.label !== "Problem" || n.attrs["resolvedAs"] != null) {
+            if (!n || n.label !== "Problem" && n.label !== "Vulnerability" || n.attrs["resolvedAs"] != null) {
               console.warn(
                 `[errata] fix tag went nowhere: ${!n ? `id ${pid.slice(0, 32)} unknown` : n.label !== "Problem" ? `${pid.slice(0, 32)} is a ${n.label}, not a Problem` : "the problem was retracted \u2014 a retraction is not fixable"} \u2014 the fix was NOT recorded`
               );
@@ -82536,10 +82864,23 @@ function createWorkspaceEngine(opts) {
             }
           }
         }
+        const vulnerabilityTriages = /* @__PURE__ */ new Set();
+        for (const tr of plan.triages) {
+          if (tr.threadId && conflictingThreads.has(tr.threadId)) {
+            vulnerabilityTriages.add(tr);
+            continue;
+          }
+          const id = tr.symptomProblemId ?? (tr.threadId ? threads.get(tr.threadId) : void 0) ?? (tr.symptomStatement ? findingIds.get(tr.symptomStatement) : void 0);
+          if (id && store.getNode(id)?.label === "Vulnerability") {
+            vulnerabilityTriages.add(tr);
+            if (tr.evidence === "witnessed" && tr.causeDescription) triaged += recordVulnerabilityCause(store, id, [tr.causeDescription], t);
+          }
+        }
         if (opts.sharedStore && plan.triages.length > 0) {
           const fallbackId = sessionLastProblem.get(sessionId);
           const fallbackStatement = fallbackId ? store.getNode(fallbackId)?.description : void 0;
           for (const tr of plan.triages) {
+            if (vulnerabilityTriages.has(tr)) continue;
             let presentingStatement = tr.symptomStatement;
             let evidence = tr.evidence;
             if (!presentingStatement && tr.threadId) {
@@ -82557,7 +82898,7 @@ function createWorkspaceEngine(opts) {
               evidence = "inferred";
             }
             if (!presentingStatement) continue;
-            const presentingId = tr.symptomProblemId ?? designProblemId(presentingStatement);
+            const presentingId = tr.symptomProblemId ?? (tr.threadId ? threads.get(tr.threadId) : void 0) ?? designProblemId(presentingStatement);
             if (tr.causeId === presentingId) continue;
             try {
               recordTriageObservation(
@@ -82615,7 +82956,7 @@ function createWorkspaceEngine(opts) {
           }
         }
         for (const at of plan.attempts) {
-          const pid = at.problemId ?? (at.threadId ? threads.get(at.threadId) : void 0) ?? (at.boundStatement ? designProblemId(at.boundStatement) : void 0);
+          const pid = at.problemId ?? (at.threadId ? threads.get(at.threadId) : void 0) ?? (at.boundStatement ? findingIds.get(at.boundStatement) ?? designProblemId(at.boundStatement) : void 0);
           const node2 = pid ? store.getNode(pid) : void 0;
           if (!pid || !node2) continue;
           try {
@@ -82631,7 +82972,7 @@ function createWorkspaceEngine(opts) {
           }
         }
         const bindPid = (tag) => {
-          const pid = tag.problemId ?? (tag.threadId ? threads.get(tag.threadId) : void 0) ?? (tag.boundStatement ? designProblemId(tag.boundStatement) : void 0) ?? inScopeProblemId ?? sessionLastProblem.get(sessionId);
+          const pid = tag.problemId ?? (tag.threadId ? threads.get(tag.threadId) : void 0) ?? (tag.boundStatement ? findingIds.get(tag.boundStatement) ?? designProblemId(tag.boundStatement) : void 0) ?? inScopeProblemId ?? sessionLastProblem.get(sessionId);
           return pid && store.getNode(pid) ? pid : void 0;
         };
         const mintCiteEdge = (from, to, type, confidence, extraAttrs) => {
@@ -82785,7 +83126,12 @@ function createWorkspaceEngine(opts) {
           for (const [session, items2] of groups) {
             if (items2.length === 0) continue;
             try {
-              const raw2 = await send(items2, session);
+              const wireItems = items2.map(({ nodeId, witnessKey }) => {
+                const node2 = store.getNode(nodeId);
+                const cloudId = node2?.attrs["privateFinding"] ? node2.attrs["cloudNodeId"] : void 0;
+                return { nodeId: typeof cloudId === "string" ? cloudId : nodeId, witnessKey };
+              });
+              const raw2 = await send(wireItems, session);
               const d = {
                 recorded: raw2?.recorded ?? 0,
                 unmatched: raw2?.unmatched ?? 0,
@@ -82798,8 +83144,8 @@ function createWorkspaceEngine(opts) {
               duplicate += d.duplicate;
               selfGated += d.selfGated;
               const missing = new Set(d.unmatchedIds);
-              for (const it of items2) {
-                if (missing.has(it.nodeId)) stillUnmatched.push({ channel, ...it, sessionKey: session, counted: isShipped(it.nodeId) });
+              for (const [index, it] of items2.entries()) {
+                if (missing.has(wireItems[index].nodeId)) stillUnmatched.push({ channel, ...it, sessionKey: session, counted: isShipped(it.nodeId) });
                 else settled.add(it.witnessKey);
               }
             } catch (err2) {
@@ -82969,6 +83315,10 @@ function createWorkspaceEngine(opts) {
         // but nothing judgeable was cited.
         tagsVerdictNoHandle: dispositions.verdictNoHandle,
         tagsFlagAsHandle: dispositions.flagAsHandle,
+        tagsInvalidVulnerability: dispositions.invalidVulnerability,
+        vulnerabilitiesSeen,
+        vulnerabilitiesMinted,
+        vulnerabilitiesSuspected,
         unresolvedHandles,
         priorEdgesFlagOff,
         priorEdgesNoSource,
@@ -83583,7 +83933,7 @@ B: ${b}`,
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync26(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync27(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       const onDisk = loadProfile(opts.workspaceRoot);
@@ -83591,7 +83941,7 @@ B: ${b}`,
         console.log(
           "[errata] sync held \u2014 this repo is already on errata in another workspace; run `errata link` to join it or create your own project"
         );
-        const pending = existsSync26(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync27(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -83727,7 +84077,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync27(engine.paths.daemonLock)) {
+        if (existsSync28(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -83928,7 +84278,7 @@ function instanceReceiptSequence(n) {
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync33, readFileSync as readFileSync34, unlinkSync as unlinkSync3, writeFileSync as writeFileSync25 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync35, unlinkSync as unlinkSync4, writeFileSync as writeFileSync25 } from "node:fs";
 import { resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
@@ -83957,7 +84307,7 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync28, readFileSync as readFileSync30 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync32 } from "node:fs";
 import { join as join36 } from "node:path";
 
 // src/package-index.ts
@@ -84108,10 +84458,10 @@ function runLockfilePass(opts) {
   ];
   for (const c of candidates) {
     const p = join36(opts.root, c.file);
-    if (!existsSync28(p)) continue;
+    if (!existsSync29(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync30(p, "utf8"));
+      sbom = c.parse(readFileSync32(p, "utf8"));
     } catch {
       continue;
     }
@@ -84171,7 +84521,7 @@ function noveltyAgainst(node2, neighbors, opts = {}) {
 init_profile2();
 
 // src/public-symbols.ts
-import { readFileSync as readFileSync31, readdirSync as readdirSync11, existsSync as existsSync29 } from "node:fs";
+import { readFileSync as readFileSync33, readdirSync as readdirSync11, existsSync as existsSync30 } from "node:fs";
 import { join as join37 } from "node:path";
 var HEAD_BYTES = 8 * 1024;
 var INDEX_TTL_MS = 10 * 60 * 1e3;
@@ -84206,9 +84556,9 @@ function internalPackageNames(workspaceRoot) {
   const names = /* @__PURE__ */ new Set();
   const tryRead = (dir) => {
     const pj = join37(dir, "package.json");
-    if (!existsSync29(pj)) return;
+    if (!existsSync30(pj)) return;
     try {
-      const name2 = JSON.parse(readFileSync31(pj, "utf8")).name;
+      const name2 = JSON.parse(readFileSync33(pj, "utf8")).name;
       if (typeof name2 === "string" && name2.length > 0) names.add(name2);
     } catch {
     }
@@ -84216,7 +84566,7 @@ function internalPackageNames(workspaceRoot) {
   tryRead(workspaceRoot);
   for (const group of ["packages", "apps"]) {
     const groupDir = join37(workspaceRoot, group);
-    if (!existsSync29(groupDir)) continue;
+    if (!existsSync30(groupDir)) continue;
     try {
       for (const entry of readdirSync11(groupDir)) tryRead(join37(groupDir, entry));
     } catch {
@@ -84237,7 +84587,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const readHead = deps.readHead ?? ((absPath) => {
     try {
-      return readFileSync31(absPath, "utf8").slice(0, HEAD_BYTES);
+      return readFileSync33(absPath, "utf8").slice(0, HEAD_BYTES);
     } catch {
       return "";
     }
@@ -84305,7 +84655,7 @@ function internalSymbolsFor(description, lexiconHas, publicIndex) {
 
 // src/instance-ingest.ts
 init_generalize_graph();
-var INSTANCE_LABELS = ["Problem", "Solution", "RootCause"];
+var INSTANCE_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
 var INSTANCE_EDGES = ["CAUSED_BY", "SOLVED_BY"];
 var ANCHOR_EDGES = ["OCCURS_IN", "DEPENDS_ON", "PERTAIN_TO", "CONCERNS"];
 var ANCHOR_TARGET_LABELS = ["Language", "Package", "Domain", "Component"];
@@ -84440,6 +84790,10 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
       attrs: {
         scope: stripCodebaseScope(n.attrs["scope"]),
         ...n.attrs["kind"] ? { kind: n.attrs["kind"] } : {},
+        ...n.attrs["privateFinding"] ? { privateFinding: true } : {},
+        ...n.attrs["assessment"] ? { assessment: n.attrs["assessment"] } : {},
+        ...n.attrs["sourceClass"] ? { sourceClass: n.attrs["sourceClass"] } : {},
+        ...n.attrs["resolutionWitnessed"] ? { resolutionWitnessed: true, resolvedAt: n.attrs["resolvedAt"] } : {},
         ...n.attrs["resolvedAs"] ? { resolvedAs: n.attrs["resolvedAs"] } : {},
         ...preserved.length > 0 ? { preservedSymbols: preserved } : {},
         ...internal.length > 0 ? { internalSymbols: internal } : {}
@@ -84454,6 +84808,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   const semanticEndpoints = /* @__PURE__ */ new Map();
   const includedByLabel = /* @__PURE__ */ new Map();
   const composition = {
+    privateTargetMissing: 0,
     candidates: 0,
     shipped: 0,
     cloudSourced: 0,
@@ -84499,11 +84854,15 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
       if (walked.has(n.id)) continue;
       walked.add(n.id);
       composition.candidates++;
+      if ((n.attrs["privateFinding"] || n.label === "Vulnerability") && !opts.project) {
+        composition.privateTargetMissing++;
+        continue;
+      }
       if (n.attrs["source"] === "cloud") {
         composition.cloudSourced++;
         continue;
       }
-      if (label === "Problem" && n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) {
+      if (n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) {
         composition.falsePositive++;
         continue;
       }
@@ -84526,7 +84885,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
         composition.terminalRefused++;
         continue;
       }
-      if (!noveltyAgainst(n, ref, noveltyOpts).ready) {
+      if (!n.attrs["privateFinding"] && !noveltyAgainst(n, ref, noveltyOpts).ready) {
         composition.notNovel++;
         continue;
       }
@@ -84569,7 +84928,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     }
     if (targets.length === 0) continue;
     const shipped = shippedById.get(sourceId);
-    if (shipped) {
+    if (shipped && !shipped.attrs["privateFinding"]) {
       const anchors = (label) => targets.filter((x) => x.t.label === label).map(
         (x) => label === "Language" ? langAnchor(x.t) : label === "Component" ? `component:${x.wireId}` : x.wireId
       ).filter((a) => a != null).sort();
@@ -85055,59 +85414,8 @@ function cloudTargetDrift(daemon, shell2) {
   return out2;
 }
 
-// src/lock.ts
-import { existsSync as existsSync30, readFileSync as readFileSync32 } from "node:fs";
-function daemonLockPayload(lock) {
-  return JSON.stringify({
-    pid: lock.pid,
-    webUiUrl: lock.webUiUrl,
-    startedAt: lock.processStartedAt,
-    ...lock.wokeAt !== void 0 ? { wokeAt: lock.wokeAt } : {},
-    ...lock.entry ? { entry: lock.entry } : {},
-    ...lock.version ? { version: lock.version } : {}
-  });
-}
-var normEntry = (p) => {
-  const s = p.replace(/\\/g, "/").replace(/\/+$/, "");
-  return /^[A-Za-z]:\//.test(s) ? s.toLowerCase() : s;
-};
-function isInstalledEntry(entry) {
-  return /\/node_modules\/@inerrata-corporation\/errata\//.test(normEntry(entry) + "/");
-}
-function foreignDaemonNote(lock, selfEntry) {
-  if (!lock.entry || normEntry(lock.entry) === normEntry(selfEntry)) return null;
-  const runningInstalled = isInstalledEntry(lock.entry);
-  const head2 = [
-    `launched from ${runningInstalled ? "the installed package" : "a LOCAL BUILD"}, not this one${lock.version ? ` (it is ${lock.version})` : ""}:`,
-    `  running: ${lock.entry}`,
-    `  this:    ${selfEntry}`
-  ];
-  return runningInstalled ? [...head2, "this CLI is a different bundle from the daemon it is talking to \u2014 its view may not match what the daemon runs."] : [...head2, "`errata update` does not replace it. To move onto the installed package: errata stop, then errata dash."];
-}
-function isProcessAlive(pid) {
-  if (!pid || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err2) {
-    return err2.code === "EPERM";
-  }
-}
-function readDaemonLock(lockPath) {
-  if (!existsSync30(lockPath)) return null;
-  try {
-    const lock = JSON.parse(readFileSync32(lockPath, "utf8"));
-    return typeof lock.pid === "number" ? lock : null;
-  } catch {
-    return null;
-  }
-}
-function isDaemonAlive(lockPath) {
-  const lock = readDaemonLock(lockPath);
-  return lock !== null && isProcessAlive(lock.pid);
-}
-
 // src/multi.ts
+init_lock();
 init_config();
 
 // src/update.ts
@@ -85810,7 +86118,7 @@ async function syncHistoryRevisionPage(opts) {
 init_src7();
 init_src();
 import { execFile as execFile5 } from "node:child_process";
-import { readFileSync as readFileSync33 } from "node:fs";
+import { readFileSync as readFileSync34 } from "node:fs";
 import { join as join38 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
@@ -86358,7 +86666,7 @@ async function defaultGit(root, args2) {
 function readIgnoreLines(root, profile) {
   let lines = [];
   try {
-    lines = readFileSync33(join38(root, ".errataignore"), "utf8").split("\n");
+    lines = readFileSync34(join38(root, ".errataignore"), "utf8").split("\n");
   } catch {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -86787,7 +87095,7 @@ async function startHistoryStage(root, input, client, walk11 = {}) {
 // src/link-flow.ts
 init_cloud_auth();
 import { createHash as createHash19 } from "node:crypto";
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync6 } from "node:child_process";
 import { existsSync as existsSync31, writeFileSync as writeFileSync24 } from "node:fs";
 import { join as join39 } from "node:path";
 
@@ -87175,7 +87483,7 @@ async function linkThroughConsole(opts) {
 function collectRepoFacts(root) {
   const git3 = (args2) => {
     try {
-      return execFileSync5("git", args2, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      return execFileSync6("git", args2, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
       return null;
     }
@@ -87609,9 +87917,9 @@ function ownerOf(records, absPath) {
 }
 async function startMultiDaemon(opts = {}) {
   const lockPath = globalDaemonLock();
-  if (opts.enforceSingleton !== false && isDaemonAlive(lockPath)) {
+  if (opts.enforceSingleton !== false && daemonLockBlocksStartup(lockPath)) {
     throw new Error(
-      `an errata daemon is already running (lock: ${lockPath}). Run \`errata stop\` first, or attach to the running one.`
+      `a daemon lock is live or its process ownership cannot be verified (lock: ${lockPath}). Run \`errata doctor\` to inspect it, or \`errata stop\` to stop a verified owner.`
     );
   }
   const cfg = loadConfig();
@@ -89298,8 +89606,8 @@ async function startMultiDaemon(opts = {}) {
       clearInterval(anchorPull);
       clearTimeout(codexWakeBoot);
       try {
-        const cur = readFileSync34(lockPath, "utf8");
-        if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
+        const cur = readFileSync35(lockPath, "utf8");
+        if (JSON.parse(cur).pid === process.pid) unlinkSync4(lockPath);
       } catch {
       }
       await new Promise(
@@ -89659,6 +89967,7 @@ function openInBrowser(url2) {
 // src/cli.ts
 init_paths();
 init_checkout_root();
+init_lock();
 
 // src/cli-args.ts
 var BURST_VALUE_FLAGS = /* @__PURE__ */ new Set(["--limit", "--hops", "--max-hops"]);
@@ -89861,7 +90170,7 @@ import { spawn as spawn4 } from "node:child_process";
 import { createInterface } from "node:readline";
 
 // src/codex-hooks.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync9, readFileSync as readFileSync35, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync9, readFileSync as readFileSync36, writeFileSync as writeFileSync26 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join42 } from "node:path";
 
@@ -89887,15 +90196,24 @@ function buildCodexHooksToml(port, options) {
   };
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid hook port");
   const command = (platform === "win32" ? "& " : "") + quote(options.nodePath) + " " + quote(options.relayPath) + " " + port;
-  const handlers = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"].map(
-    (event) => "[[hooks." + event + "]]\n" + (["UserPromptSubmit", "Stop"].includes(event) ? "" : 'matcher = ".*"\n') + "\n[[hooks." + event + '.hooks]]\ntype = "command"\ncommand = ' + JSON.stringify(command) + "\ntimeout = 10\n" + (event === "Stop" ? "" : "additionalContextLimit = 5000\n")
+  const status = {
+    SessionStart: "errata: loading workspace priors",
+    UserPromptSubmit: "errata: checking workspace priors",
+    PreToolUse: "errata: checking relevant priors",
+    PostToolUse: "errata: capturing feedback and checking priors",
+    Stop: "errata: capturing session feedback"
+  };
+  const handlers = Object.keys(status).map(
+    (event) => "[[hooks." + event + "]]\n" + (["UserPromptSubmit", "Stop"].includes(event) ? "" : 'matcher = ".*"\n') + "\n[[hooks." + event + '.hooks]]\ntype = "command"\ncommand = ' + JSON.stringify(command) + "\nstatusMessage = " + JSON.stringify(status[event]) + "\ntimeout = 10\n" + (event === "Stop" ? "" : "additionalContextLimit = 5000\n")
   );
   return CODEX_HOOKS_BEGIN + "\n" + handlers.join("\n") + CODEX_HOOKS_END + "\n";
 }
 
 // src/codex-hook-relay.ts
 var CODEX_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata install-hooks codex
-import { readFileSync } from 'node:fs';
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const workspaceRoot = null;
 
 try {
   const payload = JSON.parse(readFileSync(0, 'utf8') || '{}');
@@ -89913,13 +90231,15 @@ try {
         method: 'POST', headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(payload), signal: AbortSignal.timeout(2000),
       });
-      if (!response.ok || !relay) return;
+      if (!response.ok) return false;
+      if (!relay) return true;
       const result = await response.json();
       const context = result.hookSpecificOutput?.additionalContext;
       if (typeof context === 'string' && context.trim()) contexts.push(context);
-      // The user-visible recall card; Codex renders it inline as '↳ Hook · …'.
+      // Codex exposes systemMessage to the UI/event stream; styling is host-owned.
       if (typeof result.systemMessage === 'string' && result.systemMessage.trim()) messages.push(result.systemMessage);
-    } catch { /* An unavailable daemon must never block the agent. */ }
+      return true;
+    } catch { return false; /* An unavailable daemon must never block the agent. */ }
   };
   if (event === 'PreToolUse' || event === 'PostToolUse') await post('hook', true);
   // Stop sees the final assistant message, including turns with no tools.
@@ -89927,7 +90247,23 @@ try {
   if (['SessionStart', 'UserPromptSubmit', 'PostToolUse'].includes(event)) {
     // Run after capture, so changes already rendered by the daemon arrive now.
     // Background extraction finishing later arrives at the next tool boundary.
-    await post('context-inject', true);
+    const available = await post('context-inject', true);
+    // Startup/resume/compaction must not depend on the daemon's busy event loop.
+    // Read only the installer's resolved workspace, never a caller-supplied path
+    // or tracked AGENTS.md. SessionStart already re-injects unconditionally;
+    // prompt/tool refreshes retain daemon hash deduplication (no repeated copies).
+    if (!available && event === 'SessionStart' && workspaceRoot) {
+      try {
+        const path = join(workspaceRoot, '.errata', 'context.md');
+        if (statSync(path).size <= 128 * 1024) {
+          const body = readFileSync(path, 'utf8').trim();
+          if (body) {
+            contexts.push('Errata loaded the maintained local workspace context while the daemon response was unavailable. This block REPLACES any earlier errata context block in this conversation. It is the last saved snapshot; live updates resume when the daemon responds.\n\n' + body);
+            if (!/^(0|off|false|no)$/i.test((process.env.ERRATA_RECALL_CARD || '').trim())) messages.push('⚡ errata · saved workspace priors loaded');
+          }
+        }
+      } catch { /* No saved context is honest; never substitute another project. */ }
+    }
   }
   if (contexts.length || messages.length) {
     process.stdout.write(JSON.stringify({
@@ -89939,8 +90275,12 @@ try {
   }
 } catch { /* Invalid input is also fail-open. */ }
 `;
+function buildCodexRelaySource(workspaceRoot) {
+  return CODEX_RELAY_SOURCE.replace("const workspaceRoot = null;", () => `const workspaceRoot = ${JSON.stringify(workspaceRoot)};`);
+}
 
 // src/codex-hooks.ts
+init_checkout_root();
 var CODEX_HOOK_REVIEW_HELP = "Codex desktop: Settings > Hooks, select this project, expand each event and Trust the Errata hook. CLI users can use /hooks.";
 function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join42(homedir7(), ".codex")) {
   return existsSync34(join42(root, ".codex")) || existsSync34(codexHome);
@@ -89963,9 +90303,9 @@ function writeCodexHooks(root, port, nodePath = process.execPath) {
   const file2 = join42(dir, "config.toml");
   const relay = join42(dir, "hooks", "errata-relay.mjs");
   const block = buildCodexHooksToml(port, { nodePath, relayPath: relay });
-  const final = replaceCodexHooks(existsSync34(file2) ? readFileSync35(file2, "utf8") : "", block);
+  const final = replaceCodexHooks(existsSync34(file2) ? readFileSync36(file2, "utf8") : "", block);
   mkdirSync9(join42(dir, "hooks"), { recursive: true });
-  writeFileSync26(relay, CODEX_RELAY_SOURCE, "utf8");
+  writeFileSync26(relay, buildCodexRelaySource(checkoutRootOf(root)), "utf8");
   writeFileSync26(file2, final, "utf8");
   return file2;
 }
@@ -90133,7 +90473,7 @@ function consolidationGapMs(lastPassMs, policy) {
 }
 
 // src/claude-statusline.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync10, readFileSync as readFileSync36, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync10, readFileSync as readFileSync37, writeFileSync as writeFileSync27 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname13, join as join43 } from "node:path";
 var STATUSLINE_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata init / install-hooks claude
@@ -90179,7 +90519,7 @@ function ensureUserStatusLine(opts) {
   let settings = {};
   if (existsSync35(settingsPath)) {
     try {
-      const parsed = JSON.parse(readFileSync36(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync37(settingsPath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unreadable";
       settings = parsed;
     } catch {
@@ -90189,7 +90529,7 @@ function ensureUserStatusLine(opts) {
   if (settings["statusLine"] !== void 0 && !isErrataStatusLine(settings["statusLine"])) return "kept-own";
   const relay = join43(opts.relayDir, STATUSLINE_RELAY_FILE);
   mkdirSync10(opts.relayDir, { recursive: true });
-  if (!existsSync35(relay) || readFileSync36(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
+  if (!existsSync35(relay) || readFileSync37(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
     writeFileSync27(relay, STATUSLINE_RELAY_SOURCE, "utf8");
   }
   const next = buildStatusLine(opts.port, opts.nodePath ?? process.execPath, relay);
@@ -90732,6 +91072,9 @@ async function cmdStart() {
   const lockPath = globalDaemonLock();
   const running = isDaemonAlive(lockPath) ? readDaemonLock(lockPath) : null;
   const where = profile ? `${profile.name} (${profile.id})` : ROOT;
+  if (!running && daemonLockState(readDaemonLock(lockPath), true) === "unknown") {
+    throw new Error(`Cannot verify the daemon process owning ${lockPath}; leaving it untouched. Run errata doctor to inspect it.`);
+  }
   if (running) {
     console.log(`errata: workspace registered; attached to the running daemon`);
     console.log(`  workspace: ${where}`);
@@ -91790,7 +92133,7 @@ async function cmdReview() {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync37(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync38(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -92522,31 +92865,20 @@ async function cmdReport(args2) {
   console.log(`  open: file://${indexPath.replace(/\\/g, "/")}`);
 }
 async function cmdStop() {
-  const { unlinkSync: unlinkSync4 } = await import("node:fs");
   const lockPath = [globalDaemonLock(), workspacePaths(ROOT).daemonLock].find((p) => readDaemonLock(p) !== null);
   if (!lockPath) {
     console.log(`no daemon lock found \u2014 nothing to stop`);
     return;
   }
-  const lock = readDaemonLock(lockPath);
-  if (!isProcessAlive(lock.pid)) {
-    try {
-      unlinkSync4(lockPath);
-      console.log(`removed stale lock (pid ${lock.pid} not running)`);
-    } catch {
-    }
-    return;
-  }
   try {
-    process.kill(lock.pid, "SIGTERM");
-    console.log(`sent SIGTERM to daemon (pid ${lock.pid})`);
+    const result = stopLockedDaemon(lockPath);
+    if (result === "signaled") console.log(`sent SIGTERM to the verified daemon process`);
+    else if (result === "stale") console.log(`removed stale daemon lock; no process was signaled`);
+    else if (result === "missing") console.log(`no daemon lock found \u2014 nothing to stop`);
+    else throw new Error(`daemon lock ownership is ${result}; no process was signaled and the lock was preserved`);
   } catch (err2) {
-    console.warn(`could not signal pid ${lock.pid}: ${err2 instanceof Error ? err2.message : err2}`);
-    try {
-      unlinkSync4(lockPath);
-      console.log(`removed stale lock file`);
-    } catch {
-    }
+    console.warn(`could not stop daemon: ${err2 instanceof Error ? err2.message : err2}`);
+    process.exitCode = 1;
   }
 }
 async function cmdMcp(args2) {
@@ -92557,9 +92889,9 @@ async function cmdMcp(args2) {
   await runMcpServer2(ROOT, { toolNameStyle: grokCompatibility ? "bare" : "prefixed" });
 }
 function selfArgv(sub) {
-  const self = process.execPath;
-  if (/errata(\.exe)?$/i.test(self)) return { cmd: self, args: [sub] };
-  return { cmd: self, args: [...process.execArgv, process.argv[1] ?? "", sub] };
+  const self2 = process.execPath;
+  if (/errata(\.exe)?$/i.test(self2)) return { cmd: self2, args: [sub] };
+  return { cmd: self2, args: [...process.execArgv, process.argv[1] ?? "", sub] };
 }
 function spawnDaemonDetached(options = {}) {
   const { cmd: cmd2, args: args2 } = selfArgv("dash");
@@ -92594,11 +92926,11 @@ function spawnDaemonDetached(options = {}) {
 }
 function ensureSingletonRunning(options = {}) {
   try {
-    if (isDaemonAlive(globalDaemonLock())) return true;
+    if (daemonLockBlocksStartup(globalDaemonLock())) return true;
     spawnDaemonDetached(options);
     void (async () => {
       if (await waitForDaemon(globalDaemonLock(), 8e3)) return;
-      if (isDaemonAlive(globalDaemonLock())) return;
+      if (daemonLockBlocksStartup(globalDaemonLock())) return;
       spawnDaemonDetached(options);
       await waitForDaemon(globalDaemonLock(), 8e3);
     })();
@@ -92634,13 +92966,13 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync39, writeFileSync: writeFileSync28 } = await import("node:fs");
   const { join: join45 } = await import("node:path");
   const dir = join45(ROOT, ".opencode", "plugin");
   if (!existsSync37(dir)) mkdirSync11(dir, { recursive: true });
   const file2 = join45(dir, "inerrata.js");
   if (existsSync37(file2)) {
-    const head2 = readFileSync38(file2, "utf8").split("\n")[0] ?? "";
+    const head2 = readFileSync39(file2, "utf8").split("\n")[0] ?? "";
     if (head2.trim() !== OPENCODE_PLUGIN_MARKER) {
       console.error(`refusing to overwrite ${file2}: not an errata-managed plugin (line 1 lacks the marker)`);
       process.exit(2);
@@ -92651,7 +92983,7 @@ async function installOpencodePlugin(port) {
   let cfg = { $schema: "https://opencode.ai/config.json" };
   if (existsSync37(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync38(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync39(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -92689,7 +93021,7 @@ function ensureStatusLine(port) {
   }
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync39, writeFileSync: writeFileSync28 } = await import("node:fs");
   const { join: join45 } = await import("node:path");
   const dir = join45(ROOT, ".claude");
   if (!existsSync37(dir)) mkdirSync11(dir, { recursive: true });
@@ -92697,7 +93029,7 @@ async function installClaudeHooks(port) {
   let settings = {};
   if (existsSync37(file2)) {
     try {
-      settings = JSON.parse(readFileSync38(file2, "utf8"));
+      settings = JSON.parse(readFileSync39(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -92761,7 +93093,7 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync39, writeFileSync: writeFileSync28 } = await import("node:fs");
   const { join: join45, dirname: dirname14 } = await import("node:path");
   const file2 = join45(ROOT, ".mcp.json");
   const dir = dirname14(file2);
@@ -92769,7 +93101,7 @@ async function installClaudeMcpConfig() {
   let cfg = {};
   if (existsSync37(file2)) {
     try {
-      cfg = JSON.parse(readFileSync38(file2, "utf8"));
+      cfg = JSON.parse(readFileSync39(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -92783,7 +93115,7 @@ async function installClaudeMcpConfig() {
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync39, writeFileSync: writeFileSync28 } = await import("node:fs");
   const { join: join45 } = await import("node:path");
   const dir = join45(ROOT, ".cursor");
   if (!existsSync37(dir)) mkdirSync11(dir, { recursive: true });
@@ -92791,7 +93123,7 @@ async function installCursorMcpConfig() {
   let cfg = {};
   if (existsSync37(file2)) {
     try {
-      cfg = JSON.parse(readFileSync38(file2, "utf8"));
+      cfg = JSON.parse(readFileSync39(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);