@inerrata-corporation/errata 2.0.22-dev.4130 → 2.0.22-dev.4148

package/generalize-worker.mjs

@@ -14855,6 +14855,542 @@ function normalizeParam(v) {
   return v;
 }
 
+// ../../packages/local-shared/src/tag-grammar.ts
+var TAG_CANONICAL_ID_PREFIXES = ["pat", "sol", "drc", "dcause", "dfix", "dprob", "dvuln", "prob", "claim", "err"];
+var TAG_HANDLE_SOURCE = String.raw`\[([a-z0-9][\w-]{0,80})\]|((?:${TAG_CANONICAL_ID_PREFIXES.join("|")})_[0-9a-f]{6,})`;
+var TAG_THREAD_SOURCE = String.raw`#([a-z][\w-]{0,63})`;
+var TAG_PLACEHOLDER_HANDLES = /* @__PURE__ */ new Set([
+  "handle",
+  "its-handle",
+  "another",
+  "a-third",
+  "h",
+  "h1",
+  "h2",
+  "id",
+  "its-id",
+  "a",
+  "b",
+  "\u2026",
+  "..."
+]);
+var TAG_EXAMPLES = {
+  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
+  // agent is already writing. Full rationale in the constraint note below + prior-tags.ts.
+  constraint: () => `(constraint: the limitation that forced it)`,
+  // TRIAGE — routes the problem/symptom in scope to its cause. `(cause:[handle])`
+  // links to a cited RootCause/Solution node; `(cause: free text)` mints a RootCause
+  // from the text. Harvested in prior-tags.ts → engine.ts (see the triage note below).
+  triage: (ref) => `(cause:[${ref}])`,
+  // Unlike a bare cause citation, this handle names the Problem being explained.
+  triageExplain: (ref) => `(cause:[${ref}] the mechanism)`,
+  // The MINT form — free-text cause that mints a RootCause. Prime-time surfacing
+  // (recallForFile) pastes this next to an open Problem that has no cause yet, so the
+  // diagnostic moment is cued when the agent is looking at the problem. Kept here so
+  // the grammar can't drift from parseInlineTags' `(cause: …)` acceptance.
+  triageMint: () => `(cause: why it happens)`,
+  // THREAD forms — the witness-declared symptom↔cause/fix binding. A `#id` on the
+  // flag names the diagnosis thread; the same `#id` on a later verb binds to it
+  // explicitly (across sentences AND turns), replacing proximity guessing. Adjacent
+  // 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: (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)`,
+  failed: () => `(failed: what didn't work and the dead end it rules out)`,
+  // `(failed:[h] …)` on a shown SOLUTION — the refute-by-failure form the context render teaches.
+  failedCite: (ref) => `(failed:[${ref}] what came back)`,
+  // LINK verbs (AC epic) — bind the problem in scope to CANONICAL priors and
+  // abstractions. Multi-target by design: single links are weak; ~3 links to 3
+  // DIFFERENT relevant priors is the target shape (see linkBullet).
+  instance: (ref) => `(instance:[${ref}],[another],[a-third])`,
+  pattern: () => `(pattern: name the general shape)`,
+  // DOMAIN — the abstract area a problem is about; the concept layer an
+  // anchor-less problem clusters on. Mints/resolves a Domain by name.
+  domain: () => `(domain: The Area)`,
+  // PACKAGE/COMPONENT — agent-named public anchors (OM-agent-anchors): the
+  // package a problem is ABOUT (even when not a dependency) and the
+  // framework/product-level unit it concerns. Public spine anchors → the
+  // knowledge can cross to the collective.
+  package: () => `(package: the-package-name)`,
+  component: () => `(component: The Component)`,
+  aids: (ref) => `(aids:[${ref}])`,
+  // SOLUTION-STRUCTURE (SS-structure) — taught in the link bullet; Solution→Solution.
+  buildsOn: (ref) => `(builds-on:[${ref}])`,
+  supersedes: (ref) => `(supersedes:[${ref}])`,
+  alternative: (ref) => `(alternative:[${ref}])`,
+  // VERDICT (VS-verdict-tags) — a judgment on a SHOWN prior, distinct from leaning on it.
+  // `confirm` rides the corroborate channel (it held); `refute` the contradict channel
+  // (it's wrong / didn't hold) and REQUIRES a reason. This is the inline producer the
+  // evidence channels lacked — refute sat dead (contradictionPressure 0) until now, while
+  // lean-on corroboration lived, because only corroboration had an inline path. Grammar
+  // single-sourced with parseInlineTags' CONFIRM_PREFIX/REFUTE_PREFIX.
+  confirm: (ref) => `(confirm:[${ref}])`,
+  refute: (ref) => `(refute:[${ref}] one line why)`,
+  // RETRACT — "not a real problem": the errata-resolved block with a disposition
+  // (parseDesignResolutions, turn.ts). No inline form exists; the block is the grammar.
+  retract: (id) => ["```errata-resolved", `id: ${id}`, "disposition: false_positive", "reason: why it was never a real problem", "```"].join("\n")
+};
+var P = "Problem";
+var S = "Solution";
+var RC = "RootCause";
+var CITE_LOWERING = [
+  { target: RC, writes: [{ from: P, edge: "CAUSED_BY", to: RC }] },
+  { target: S, writes: [{ from: P, edge: "SOLVED_BY", to: S }] },
+  { target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }, { from: "Pattern", edge: "ANCHORED_AT", to: "File" }], note: "cite-anchor promotion after 2 sessions", decision: "d", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+  { target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }] },
+  { target: "Language", writes: [{ from: P, edge: "OCCURS_IN", to: "Language" }] },
+  { target: "Tool", writes: [{ from: P, edge: "CONCERNS", to: "Tool" }] },
+  { target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] },
+  { target: P, writes: [{ from: P, edge: "RELATES_TO", to: P }, { from: P, edge: "ANCHORED_AT", to: "File" }], note: "corroboration witness + cite-anchor promotion" },
+  { target: "AntiPattern", writes: [{ from: P, edge: "RELATES_TO", to: "AntiPattern" }, { from: "AntiPattern", edge: "ANCHORED_AT", to: "File" }], decision: "e", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+  { target: "Technique", writes: [{ from: P, edge: "RELATES_TO", to: "Technique" }, { from: "Technique", edge: "ANCHORED_AT", to: "File" }], decision: "e", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+  { target: "Weakness", writes: [{ from: P, edge: "RELATES_TO", to: "Weakness" }], decision: "e" },
+  { target: "Domain", writes: [{ from: P, edge: "RELATES_TO", to: "Domain" }], decision: "e" },
+  { target: "Claim", writes: [{ from: P, edge: "RELATES_TO", to: "Claim" }, { from: "Claim", edge: "ANCHORED_AT", to: "File" }] }
+];
+var INSTANCE_LOWERING = [
+  { target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }] },
+  { target: P, writes: [{ from: P, edge: "RELATES_TO", to: P }] },
+  { target: S, writes: [{ from: P, edge: "SOLVED_BY", to: S }], note: "an instance cite on a Solution claims the problem is solved by it", decision: "a" },
+  { target: RC, writes: [{ from: P, edge: "CAUSED_BY", to: RC }] },
+  { target: "AntiPattern", writes: [{ from: P, edge: "RELATES_TO", to: "AntiPattern" }], decision: "e" },
+  { target: "Technique", writes: [{ from: P, edge: "RELATES_TO", to: "Technique" }], decision: "e" },
+  { target: "Weakness", writes: [{ from: P, edge: "RELATES_TO", to: "Weakness" }], decision: "e" },
+  { target: "Domain", writes: [{ from: P, edge: "RELATES_TO", to: "Domain" }], decision: "e" },
+  { target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }] },
+  { target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] }
+];
+var TRIAGE_TO_RC = [
+  { from: P, edge: "TRIAGED_BY", to: "Triage" },
+  { from: "Triage", edge: "INDICATES", to: RC },
+  { from: P, edge: "CAUSED_BY", to: RC }
+];
+var TAG_VERBS = [
+  {
+    verb: "cite",
+    form: "citation",
+    opener: "(",
+    kinds: ["prior"],
+    args: "handles",
+    thread: false,
+    handleRequired: true,
+    lowering: CITE_LOWERING,
+    examples: ["prior"],
+    hint: "cite a shown prior you leaned on: ([its-handle]) \u2014 handles only, no prose inside the parens",
+    taught: "taught"
+  },
+  {
+    verb: "!",
+    form: "flag",
+    opener: "[!",
+    kinds: ["problem", "triage", "vulnerability", "fix", "prior"],
+    args: "flag-body",
+    thread: true,
+    minText: 8,
+    qualifiers: [
+      { name: "vuln", taught: true, note: "[!vuln: \u2026] \u2192 Vulnerability (asserted)" },
+      { name: "fixed", taught: false, note: "[!fixed: X] \u2192 read as a self-found fix" },
+      { name: "resolved", taught: false, note: "[!resolved: X] \u2192 read as a self-found fix" }
+    ],
+    lowering: [
+      { target: P, writes: [], note: "mints a Problem; `@ path[:line]` anchors it (ANCHORED_AT to code)" },
+      { target: RC, writes: [...TRIAGE_TO_RC, { from: RC, edge: "CAUSED_BY", to: RC }], note: "`<-` segments: first \u2192 triage route, later \u2192 RootCause chain" },
+      { target: "Vulnerability", writes: [], note: "[!vuln: \u2026]; `<-` causes stay on the finding (vulnerabilityCauses)" }
+    ],
+    examples: ["problem", "problemThread", "vulnerability", "vulnerabilityThread"],
+    hint: "flag a problem on one line: [!what's wrong @ path:42]; fold causes with <- ; a fix goes in (fix: \u2026), not [!fixed: \u2026]",
+    taught: "taught"
+  },
+  {
+    verb: "?",
+    form: "flag",
+    opener: "[?",
+    kinds: ["todo", "vulnerability"],
+    args: "flag-body",
+    thread: true,
+    minText: 8,
+    qualifiers: [{ name: "vuln", taught: true, note: "[?vuln: \u2026] \u2192 Vulnerability (suspected)" }],
+    lowering: [{ target: P, writes: [], note: "mints a todo Problem; a fix can close it today", decision: "g" }],
+    examples: ["suspectedVulnerability"],
+    hint: "[?\u2026] marks an open question / todo; [?vuln: consequence; missing check] a suspected vulnerability",
+    taught: "untaught",
+    taughtBy: "only the [?vuln:] form is taught; the bare [?todo] form is not",
+    decisions: ["g"]
+  },
+  {
+    verb: "fix",
+    form: "verb",
+    opener: "(fix:",
+    kinds: ["fix"],
+    args: "handles-text",
+    thread: true,
+    minText: 12,
+    lowering: [
+      { target: P, writes: [{ from: P, edge: "SOLVED_BY", to: S }], note: "closes the Problem; a note \u226512 chars mints the Solution" },
+      { target: "Vulnerability", writes: [{ from: "Vulnerability", edge: "SOLVED_BY", to: S }] },
+      { target: RC, writes: [], note: "dropped: 'fix tag went nowhere' (not a Problem); no tag writes FIXED_BY", decision: "f" }
+    ],
+    examples: ["fix", "fixThread"],
+    hint: "one fix per tag: (fix:[its-handle]) or (fix:#thread what you changed) \u2014 put the cause in its own (cause: \u2026)",
+    taught: "taught",
+    decisions: ["f"]
+  },
+  {
+    verb: "cause",
+    form: "verb",
+    opener: "(cause:",
+    kinds: ["triage"],
+    args: "handles-text",
+    thread: true,
+    minText: 8,
+    lowering: [
+      { target: RC, writes: TRIAGE_TO_RC },
+      { target: P, writes: [{ from: P, edge: "TRIAGED_BY", to: "Triage" }, { from: "Triage", edge: "INDICATES", to: RC }, { from: P, edge: "CAUSED_BY", to: RC }], note: "(cause:[problem] mechanism) \u2014 the cited Problem is the symptom; the mechanism mints the RootCause" },
+      { target: S, writes: [{ from: P, edge: "TRIAGED_BY", to: "Triage" }, { from: "Triage", edge: "INDICATES", to: S }], decision: "b", knownViolation: { edge: "INDICATES", finding: "(cause:[solution]) writes a refused INDICATES \u2192 Solution" } }
+    ],
+    examples: ["triage", "triageExplain", "triageMint", "causeThread"],
+    hint: "(cause: the mechanism you'd change) or (cause:[root-cause-handle]); bind a distant symptom with (cause:#thread \u2026)",
+    taught: "taught",
+    decisions: ["b"]
+  },
+  {
+    verb: "constraint",
+    form: "verb",
+    opener: "(constraint:",
+    kinds: ["constraint"],
+    args: "text",
+    thread: false,
+    minText: 8,
+    textRequired: true,
+    lowering: [{ target: P, writes: [], note: "mints a constraint-kind Problem" }],
+    examples: ["constraint"],
+    hint: "(constraint: the limitation that forced the decision)",
+    taught: "taught"
+  },
+  {
+    verb: "tried",
+    form: "verb",
+    opener: "(tried:",
+    kinds: ["attempt"],
+    args: "text",
+    thread: true,
+    minText: 8,
+    textRequired: true,
+    lowering: [{ target: P, writes: [], note: "journals an attempt on the bound problem" }],
+    examples: ["tried"],
+    hint: "(tried: the approach) \u2014 bind with (tried:#thread \u2026)",
+    taught: "taught"
+  },
+  {
+    verb: "failed",
+    form: "verb",
+    opener: "(failed:",
+    kinds: ["failure"],
+    args: "handles-text",
+    thread: true,
+    minText: 8,
+    textRequired: true,
+    lowering: [
+      { target: P, writes: [], note: "journals a failed attempt on the bound problem" },
+      { target: S, writes: [], note: "(failed:[h]) refutes the cited prior (contradictionPressure); skips the label gate today", decision: "j" }
+    ],
+    examples: ["failed", "failedCite"],
+    hint: "(failed: what didn't work); (failed:[solution] what came back) refutes a shown fix",
+    taught: "taught",
+    decisions: ["j"]
+  },
+  {
+    verb: "instance",
+    form: "verb",
+    opener: "(instance:",
+    kinds: ["instance"],
+    args: "handles",
+    thread: false,
+    handleRequired: true,
+    lowering: INSTANCE_LOWERING,
+    examples: ["instance"],
+    hint: "(instance:[h1],[h2],[h3]) \u2014 ~3 DIFFERENT shown priors this problem instantiates; handles only",
+    taught: "taught",
+    decisions: ["a", "e"]
+  },
+  {
+    verb: "pattern",
+    form: "verb",
+    opener: "(pattern:",
+    kinds: ["pattern"],
+    args: "handle-or-text",
+    thread: false,
+    minText: 3,
+    lowering: [{ target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }], note: "a handle must be a Pattern; free text resolves-or-mints one" }],
+    examples: ["pattern"],
+    hint: "(pattern: name the general shape) or (pattern:[shown-pattern])",
+    taught: "taught"
+  },
+  {
+    verb: "domain",
+    form: "verb",
+    opener: "(domain:",
+    kinds: ["domain"],
+    args: "text",
+    thread: false,
+    minText: 2,
+    textRequired: true,
+    lowering: [{ target: "Domain", writes: [{ from: P, edge: "PERTAIN_TO", to: "Domain" }], note: '(domain:#t X) mints a Domain named "#t X" today', decision: "k" }],
+    examples: ["domain"],
+    hint: "(domain: The Area) \u2014 Title Case, no thread",
+    taught: "taught",
+    decisions: ["k"]
+  },
+  {
+    verb: "package",
+    form: "verb",
+    opener: "(package:",
+    kinds: ["package"],
+    args: "text",
+    thread: false,
+    minText: 2,
+    textRequired: true,
+    lowering: [{ target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }], note: "means 'concerns', written as DEPENDS_ON", decision: "c" }],
+    examples: ["package"],
+    hint: "(package: the-package-name) \u2014 the public package it's about",
+    taught: "taught",
+    decisions: ["c"]
+  },
+  {
+    verb: "component",
+    form: "verb",
+    opener: "(component:",
+    kinds: ["component"],
+    args: "text",
+    thread: false,
+    minText: 2,
+    textRequired: true,
+    lowering: [{ target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] }],
+    examples: ["component"],
+    hint: "(component: The Component) \u2014 the framework/product unit",
+    taught: "taught"
+  },
+  {
+    verb: "aids",
+    form: "verb",
+    opener: "(aids:",
+    kinds: ["transfer"],
+    args: "handles",
+    thread: true,
+    handleRequired: true,
+    lowering: [{ target: P, writes: [{ from: S, edge: "MAY_RESOLVE", to: P }], note: "source = the Solution in scope; non-Problem targets are skipped" }],
+    examples: ["aids"],
+    hint: "(aids:[problem-handle],\u2026) \u2014 other shown problems your fix might also resolve",
+    taught: "taught"
+  },
+  {
+    verb: "builds-on",
+    form: "verb",
+    opener: "(builds-on:",
+    kinds: ["builds-on"],
+    args: "handles",
+    thread: true,
+    handleRequired: true,
+    lowering: [{ target: S, writes: [{ from: S, edge: "BUILDS_ON", to: S }] }],
+    examples: ["buildsOn"],
+    hint: "(builds-on:[shown-solution]) \u2014 your fix layers on it",
+    taught: "taught",
+    taughtBy: "linkBullet instruction text"
+  },
+  {
+    verb: "supersedes",
+    form: "verb",
+    opener: "(supersedes:",
+    kinds: ["supersedes"],
+    args: "handles",
+    thread: true,
+    handleRequired: true,
+    lowering: [{ target: S, writes: [{ from: S, edge: "SUPERSEDES", to: S }] }],
+    examples: ["supersedes"],
+    hint: "(supersedes:[shown-solution]) \u2014 your fix replaces it",
+    taught: "taught",
+    taughtBy: "linkBullet instruction text"
+  },
+  {
+    verb: "alternative",
+    form: "verb",
+    opener: "(alternative:",
+    kinds: ["alternative"],
+    args: "handles",
+    thread: true,
+    handleRequired: true,
+    lowering: [{ target: S, writes: [{ from: S, edge: "ALTERNATIVE_TO", to: S }] }],
+    examples: ["alternative"],
+    hint: "(alternative:[shown-solution]) \u2014 a different valid approach",
+    taught: "taught",
+    taughtBy: "linkBullet instruction text"
+  },
+  {
+    verb: "confirm",
+    form: "verb",
+    opener: "(confirm:",
+    kinds: ["confirm"],
+    args: "handles",
+    thread: false,
+    handleRequired: true,
+    lowering: [{ target: S, writes: [], note: "corroboration witness (corroborationCount), no edge" }],
+    examples: ["confirm"],
+    hint: "(confirm:[shown-prior]) \u2014 it held",
+    taught: "taught",
+    taughtBy: "verdictBullet + context render",
+    decisions: ["j"]
+  },
+  {
+    verb: "refute",
+    form: "verb",
+    opener: "(refute:",
+    kinds: ["refute"],
+    args: "handles-text",
+    thread: false,
+    minText: 4,
+    handleRequired: true,
+    textRequired: true,
+    lowering: [{ target: S, writes: [], note: "contradiction witness (contradictionPressure), no edge; reason stays local" }],
+    examples: ["refute"],
+    hint: "(refute:[shown-prior] one line why) \u2014 the reason is required",
+    taught: "taught",
+    taughtBy: "verdictBullet + context render",
+    decisions: ["j"]
+  }
+];
+var TAG_FENCES = [
+  {
+    fence: "errata-problem",
+    fields: ["problem", "cause", "fix", "anchor", "kind"],
+    required: [["problem"]],
+    taught: "untaught",
+    parser: "apps/daemon/src/turn.ts parseDesignFlags",
+    decisions: ["h"],
+    hint: "use an inline [!\u2026] flag instead (errata-problem cause ids never meet inline ids)"
+  },
+  {
+    fence: "errata-resolved",
+    fields: ["id", "problem", "fix", "disposition", "reason"],
+    required: [["id", "problem"]],
+    taught: "taught",
+    taughtBy: "retract form only (TAG_EXAMPLE.retract); the fix form is untaught",
+    parser: "apps/daemon/src/turn.ts parseDesignResolutions",
+    hint: "```errata-resolved with id: and disposition: false_positive | invalid, reason: \u2026"
+  },
+  {
+    fence: "errata-triage",
+    fields: ["presenting", "cause", "test", "fix", "drift", "route"],
+    required: [["presenting", "route"], ["cause", "test"]],
+    taught: "taught",
+    taughtBy: "MCP errata_triage tool copy",
+    parser: "packages/local-graph/src/triage.ts parseTriageFences",
+    hint: "```errata-triage with presenting: and cause: (or route: + test: to answer one)"
+  },
+  {
+    fence: "errata-abstraction",
+    fields: ["candidate", "principle", "covers"],
+    required: [["candidate"], ["principle"], ["covers"]],
+    taught: "taught",
+    taughtBy: "MCP errata_pending_abstractions tool copy",
+    parser: "packages/local-graph/src/abstraction.ts parseAbstractionFences",
+    hint: "```errata-abstraction with candidate:, principle:, covers: (all required)"
+  },
+  {
+    fence: "errata-intent",
+    fields: ["intent"],
+    required: [["intent"]],
+    taught: "taught",
+    parser: "packages/local-graph/src/intent.ts parseIntentFences",
+    hint: "```errata-intent with intent: what you're about to do"
+  },
+  {
+    fence: "errata-share",
+    fields: ["priors"],
+    required: [["priors"]],
+    taught: "taught",
+    taughtBy: "subagent hand-off copy",
+    parser: "packages/local-graph/src/intent.ts parseShareFence",
+    hint: "```errata-share with priors: all | [h1], [h2]"
+  }
+];
+var TAG_VERB_BY_NAME = new Map(
+  TAG_VERBS.filter((v) => v.form === "verb").map((v) => [v.verb, v])
+);
+var TAG_PAREN_VERBS = [...TAG_VERB_BY_NAME.keys()].sort((a, b) => b.length - a.length);
+var TAG_GRAMMAR_OPENERS = [
+  ...new Set(TAG_VERBS.filter((v) => v.form !== "citation").map((v) => v.opener))
+];
+var TAG_QUOTED_PAREN_SOURCE = String.raw`\(\s*(?:${TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|")})\s*:|\(\[`;
+var TAG_QUOTED_RE = new RegExp(String.raw`\[[!?]|` + TAG_QUOTED_PAREN_SOURCE, "i");
+var TAG_QUOTED_PAREN_RE = new RegExp(TAG_QUOTED_PAREN_SOURCE, "i");
+function tagGrammarCopy() {
+  const copy = [];
+  for (const ref of ["its-handle", "its-id", "h", "id"]) {
+    for (const build of Object.values(TAG_EXAMPLES)) copy.push(build(ref));
+  }
+  for (const v of TAG_VERBS) {
+    copy.push(v.hint);
+    if (v.taughtBy) copy.push(v.taughtBy);
+    for (const q of v.qualifiers ?? []) copy.push(q.note);
+    for (const l of v.lowering) {
+      if (l.note) copy.push(l.note);
+      if (l.knownViolation) copy.push(l.knownViolation.finding);
+    }
+  }
+  for (const f of TAG_FENCES) copy.push(f.hint);
+  return copy;
+}
+var TEMPLATE_VERB_GROUP = new RegExp(
+  String.raw`\(\s*(${TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|")})\s*:((?:[^()\n]|\([^()\n]*\))*)\)`,
+  "gi"
+);
+var BRACKET_TOKEN = /\[([^\]\n]{1,80})\]/g;
+var REAL_HANDLE_SHAPE = new RegExp(
+  String.raw`^(?:[a-z0-9]+(?:-[a-z0-9]+)*-(?=[0-9a-f]{0,3}\d)[0-9a-f]{4}|(?:${TAG_CANONICAL_ID_PREFIXES.join("|")})_[0-9a-f]{6,})$`,
+  "i"
+);
+function normalizeTemplateBody(body) {
+  return body.replace(/…|\.{3}/g, " ").replace(/\s+/g, " ").trim().replace(/^[\s,;:—–-]+|[\s,;:.—–-]+$/g, "").toLowerCase();
+}
+function deriveTagTemplates(copy) {
+  const bodies = /* @__PURE__ */ new Set();
+  const handles = new Set([...TAG_PLACEHOLDER_HANDLES].map((h) => h.toLowerCase()));
+  for (const text of copy) {
+    for (const m of text.matchAll(BRACKET_TOKEN)) {
+      const token = m[1].trim().toLowerCase();
+      if (!/^[!?]/.test(token) && !REAL_HANDLE_SHAPE.test(token)) handles.add(token);
+    }
+  }
+  for (const text of copy) {
+    for (const m of text.matchAll(TEMPLATE_VERB_GROUP)) {
+      const body = normalizeTemplateBody(m[2]);
+      bodies.add(body);
+      const unthreaded = normalizeTemplateBody(body.replace(/^#[a-z][\w-]*/i, ""));
+      bodies.add(unthreaded);
+      const rest = normalizeTemplateBody(unthreaded.replace(BRACKET_TOKEN, (t, h) => handles.has(h.trim().toLowerCase()) ? " " : t).replace(/,/g, " "));
+      bodies.add(rest);
+    }
+  }
+  bodies.delete("");
+  return { bodies, handles };
+}
+var TAG_TEMPLATES = deriveTagTemplates(tagGrammarCopy());
+var VERB_WORDS_SOURCE = TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|");
+var JOINED_VERB = new RegExp(String.raw`[,;]\s*(?=(?:${VERB_WORDS_SOURCE})\s*:)`, "i");
+var LEADING_VERB = new RegExp(String.raw`^\s*(${VERB_WORDS_SOURCE})\s*:`, "i");
+var ANY_VERB_WORD = new RegExp(String.raw`\b(?:${VERB_WORDS_SOURCE})\s*:`, "gi");
+var QUOTED_TAG_OPENER = new RegExp(String.raw`\(\s*(?:(${VERB_WORDS_SOURCE})\s*:|(?=\[))`, "gi");
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 var HISTORY_CACHE_FLOOR_KEY = "history-cache-withdrawal-floor-3";
 function installHistoryCacheFloor(db) {
@@ -17247,7 +17783,14 @@ function summaryFromDoc(doc, kind) {
   }
   if (verb !== null) return null;
   const noun = clipped.replace(/^(?:the|a|an)\s+/i, "");
-  return tidy(`${lead(kind)} for ${noun.charAt(0).toLowerCase()}${noun.slice(1)}`);
+  const head = noun.split(/[\s-]/, 1)[0].replace(/[.,;:!?]+$/, "");
+  return tidy(`${lead(kind)} for ${isOrdinaryCapital(head) ? noun.charAt(0).toLowerCase() + noun.slice(1) : noun}`);
+}
+var CONTRACTION_BASES = /* @__PURE__ */ new Set(["it", "that", "this", "there", "here", "what", "who", "where", "when", "why", "how", "let", "he", "she"]);
+function isOrdinaryCapital(word) {
+  const contraction = /^([A-Za-z]+)['’]s$/.exec(word);
+  if (contraction) return CONTRACTION_BASES.has(contraction[1].toLowerCase()) && /^[A-Z][a-z]*$/.test(contraction[1]);
+  return /^[A-Z][a-z]+$/.test(word);
 }
 var VERB_PHRASE_KINDS = /* @__PURE__ */ new Set(["function", "method"]);
 function summaryFromName(name, kind) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.22-dev.4130",
+  "version": "2.0.22-dev.4148",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {