@christang/keel 5.5.0 → 5.7.0

package/README.md

@@ -155,6 +155,80 @@ Three things the declaration is not:
 The block is absent by default, and a repository that declares nothing behaves exactly as it did
 before this feature existed. `keel --doctor` reports what is declared.
 
+### Decision precedents
+
+A decision you make in conversation is spent at the next context reset, and the reasoning that
+settled it — the part that would generalise to a decision you have not met yet — goes with it.
+Point Keel at a directory of precedents and it consults them instead of asking you again:
+
+```yaml
+precedents: ../my-decisions   # any path; it may live outside this repository
+```
+
+Keel ships no precedent and creates no store. It reads that directory and nothing else — it never
+clones, pulls, or reaches the network — so one directory outside your repositories can serve all of
+them, and a path that is not there behaves exactly as no declaration at all.
+
+Each precedent is a markdown file carrying an `Applies when:` header, the materiality category it
+belongs to, a status of `recorded` or `authorized`, the decision, and **the rationale**. The last is
+load-bearing: *"chose A"* applies only to the situation literally recorded, while *"chose A because
+B fails offline"* can be applied to a case nobody has seen — and recognised as not applying when the
+new case is online. A precedent with no rationale is reported incomplete and is never applied.
+
+Three rules govern how they are used:
+
+- **A precedent is cited exactly where it replaced a question.** If applying it meant you were not
+  asked something you would have been asked, the reply names it. Routine decisions are not cited,
+  so a citation always marks a decision made in your place.
+- **Only you promote one.** A precedent enters as `recorded` and is offered as a recommendation
+  while the question is still asked. It becomes `authorized` when you accept a promotion that was
+  proposed to you — never by a usage count, which would cross with nobody watching.
+- **A precedent answers a recurrence; it never reclassifies.** It can shorten a decision inside its
+  category. It cannot move a decision out of the categories that require asking you, and no
+  accumulation of precedents makes a category stop mattering.
+
+As with standing authorization, a precedent informs a decision and never substitutes for a proof:
+gates, evidence, review, and the write guard are untouched by anything in the store. The session
+start line reports the store's size and freshness only — precedent bodies load when a decision is
+actually being made.
+
+### Unattended runs
+
+The last thing a loop needs is permission to *start*. Declare which issues may begin work without
+being asked about:
+
+```yaml
+triage:             # issue labels that admit work; absent means nothing does
+  - auto
+```
+
+```bash
+gh issue view 42 --json labels --jq '[.labels[].name]|join(",")' | xargs keel triage --labels
+```
+
+**Keel never fetches the issue.** You pass what `gh` returned, and the evaluation stays local,
+offline and deterministic — the same properties that make every other Keel answer worth trusting.
+
+A **label** is the unit on purpose. A person applies one to one issue, so the policy admits a class
+you curate one issue at a time — not a guess about which issues look easy, which is exactly the
+judgement that should not be automated. Keel cannot check that a human applied the label; if your
+automation can label issues, this declaration is wider than it looks.
+
+**Admission answers "may this begin" and nothing after it.** Alignment still escalates every
+material choice, every gate still runs, and the write guard still binds. In particular:
+
+- An unattended run **may** triage, author, implement, verify, push where `authorize:` permits, and
+  **open a pull request**.
+- It **may not merge**. Merging is where an unreviewed decision becomes your project's history, and
+  no declaration in Keel authorizes one.
+- Admission comes from this declaration and **never from a precedent**, however much triage history
+  the store accumulates — whether an issue becomes work is a decision that stays yours to delegate
+  explicitly.
+
+**Keel schedules nothing.** `/loop`, cron, and CI triggers are your runtime's; Keel's part is making
+each step decidable with authority. And a run that stops at a real decision has ended the way it was
+designed to — resist widening the policy until it stops happening.
+
 ### Full vs Lite
 
 Use **Full mode** (the OpenSpec flow above) for new features, interface or protocol changes,
@@ -210,7 +284,9 @@ is repo-local and reversible.
 
 ## Domain lenses
 
-Keel's core is pure process; it ships no domain knowledge of its own. Domain guidance lives in
+Keel's core is pure process; it ships no domain knowledge and no decisions of its own. Alongside
+the precedent store above, the other user-authored surface Keel loads on demand is domain guidance,
+which lives in
 **lenses** you author under `keel/lenses/*.md` in your repo. Each lens is self-describing: it
 opens with an `Applies when:` line stating the signals that trigger it (file extensions, artifact
 shapes) and carries an `Execution and review checks` section. When a change's artifacts or Touch
@@ -243,9 +319,14 @@ keel guard status --json
 keel guard clear  --json
 
 # Domain lenses — user-authored guidance in keel/lenses/
+# (the other user-authored surface is the precedent store; see above)
 keel lenses list
 keel lenses add <name> [--force]
 
+# Unattended triage — may this issue start work without asking?
+# Keel never fetches the issue; pass what gh returned.
+keel triage --labels <l1,l2> [--json]
+
 # Install / maintenance
 keel --init | --install | --check | --doctor | --uninstall  [--target <t>] [--dry-run]
 keel --update [--dry-run]

package/assets/bootstrap/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- keel:start version=5.5.0 -->
+<!-- keel:start version=5.7.0 -->
 ## Keel Bootstrap
 
 - Start every session with `keel context`; OpenSpec artifacts and Git are the only durable authority — never native memory, goals, or transcripts.

package/bin/keel.js

@@ -46,7 +46,10 @@ const {
 } = require("../src/core/guard");
 const {
   STANDING_AUTHORIZATION_ACTIONS,
+  readPrecedentStore,
   readStandingAuthorization,
+  readTriagePolicy,
+  triageIssue,
 } = require("../src/core/config");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
@@ -176,6 +179,7 @@ function parseArgs(argv) {
     guardSubcommand: null,
     lensesSubcommand: null,
     lensName: null,
+    labels: null,
     openspecArgs: [],
     force: false,
     projectionEvent: null,
@@ -219,6 +223,14 @@ function parseArgs(argv) {
       parsed.action = "lenses";
       continue;
     }
+    if (arg === "triage" && parsed.action === null && parsed.repo === null) {
+      parsed.action = "triage";
+      continue;
+    }
+    if (arg === "--labels" && parsed.action === "triage") {
+      parsed.labels = argv[++index] || "";
+      continue;
+    }
     if (arg === "openspec" && parsed.action === null && parsed.repo === null) {
       parsed.action = "openspec";
       parsed.openspecArgs = argv.slice(index + 1);
@@ -470,7 +482,7 @@ function parseArgs(argv) {
     fail(`invalid target: ${parsed.target}`);
   }
   if (
-    !["context", "gate", "capabilities", "project", "guard"].includes(
+    !["context", "gate", "capabilities", "project", "guard", "triage"].includes(
       parsed.action
     )
     && (
@@ -539,6 +551,16 @@ function parseArgs(argv) {
   } else if (parsed.lensesSubcommand !== null || parsed.lensName !== null) {
     fail("lens subcommands apply only to keel lenses");
   }
+  if (parsed.action === "triage") {
+    if (parsed.labels === null) {
+      fail(
+        "keel triage requires --labels; Keel never fetches the issue, so pass "
+          + "what `gh issue view --json labels` returned"
+      );
+    }
+  } else if (parsed.labels !== null) {
+    fail("--labels applies only to keel triage");
+  }
   if (parsed.noGuard && parsed.action !== "gate") {
     fail("--no-guard applies only to keel gate task-start");
   }
@@ -1353,6 +1375,8 @@ function runDoctor(options) {
   printTargetSurface(repo, options.target);
   printLensSurface(repo, options.target);
   const authorizationOk = printStandingAuthorizationSurface(repo);
+  printPrecedentSurface(repo);
+  printTriageSurface(repo);
   printFastPrePushSurface(repo);
   printSourceRepoCliResolution(repo);
 
@@ -1430,6 +1454,55 @@ function printStandingAuthorizationSurface(repo) {
   return true;
 }
 
+function printTriageSurface(repo) {
+  process.stdout.write("\nUnattended triage:\n");
+  const { labels } = readTriagePolicy(repo);
+  printDoctorLine(
+    "triage",
+    labels.length > 0 ? "ok" : "none",
+    labels.length > 0
+      ? `issues labelled ${labels.join(", ")} may start work unattended; `
+        + "admission decides nothing after it, and no declaration authorizes a merge"
+      : "undeclared; no issue starts work unattended"
+  );
+}
+
+function printPrecedentSurface(repo) {
+  process.stdout.write("\nPrecedent store:\n");
+  const store = readPrecedentStore(repo);
+  if (store.precedents.length === 0) {
+    printDoctorLine(
+      "precedents",
+      "none",
+      store.declared
+        ? `declared at ${store.declared}, which holds no precedents here; `
+          + "an absent store behaves exactly as an undeclared one"
+        : "undeclared; no precedent informs any decision"
+    );
+    return;
+  }
+  const authorized = store.precedents.filter(
+    (item) => item.status === "authorized"
+  ).length;
+  printDoctorLine("precedents", String(store.precedents.length), store.declared);
+  printDoctorLine(
+    "authorized",
+    String(authorized),
+    `${store.precedents.length - authorized} recorded, offered as a `
+      + "recommendation rather than applied"
+  );
+  const incomplete = store.precedents.filter((item) => !item.complete);
+  printDoctorLine(
+    "incomplete",
+    String(incomplete.length),
+    incomplete.length > 0
+      ? `missing a Rationale, so not applicable to any decision: ${incomplete
+        .map((item) => item.name)
+        .join(", ")}`
+      : "every precedent states why, which is the part that transfers"
+  );
+}
+
 function printFastPrePushSurface(repo) {
   process.stdout.write("\nFast pre-push surface:\n");
   const fastCheck = readFastCheck(repo);
@@ -1675,6 +1748,31 @@ function runAction(options) {
       : 3;
   }
 
+  if (options.action === "triage") {
+    const repo = path.resolve(options.repo || process.cwd());
+    const labels = String(options.labels || "")
+      .split(",")
+      .map((label) => label.trim())
+      .filter(Boolean);
+    const verdict = triageIssue(repo, labels);
+    const payload = {
+      schemaVersion: 1,
+      command: "triage",
+      ...verdict,
+      warnings: [
+        "Admission starts work and authorizes nothing after it; every gate, "
+          + "evidence requirement, Review, and the write guard still apply.",
+        "An unattended run may open a pull request and may not merge one.",
+        "Keel schedules nothing; the loop belongs to the host runtime.",
+      ],
+    };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    } else {
+      process.stdout.write(`Triage: ${verdict.status}\n${verdict.reason}\n`);
+    }
+    return 0;
+  }
   if (options.action === "lenses") {
     if (options.dryRun || options.forceTemplateUpdate || options.updateSource) {
       fail("lenses does not accept install or update options");

package/package.json

@@ -2,7 +2,7 @@
   "name": "@christang/keel",
   "displayName": "Keel",
   "description": "Keel OpenSpec execution discipline CLI for Claude Code, Codex, and OpenCode.",
-  "version": "5.5.0",
+  "version": "5.7.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/plugins/keel/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.5.0",
+  "version": "5.7.0",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/plugins/keel/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.5.0",
+  "version": "5.7.0",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/plugins/keel/scripts/session-start.js

@@ -53,6 +53,61 @@ function emit(context, humanMessage) {
 // at session start is the one who must not mistake a projection for authority.
 const DISPOSABLE = "Disposable projection; OpenSpec and Git are the authority.";
 
+// A pointer, never a body. The store grows without bound while the precedents
+// relevant to any one session are a small subset, and this hook pays its cost
+// on every session including post-compaction reinjection. Counts and freshness
+// tell the agent the store exists and how stale it is; the precedents
+// themselves load when a decision is actually being made.
+//
+// The reader is inlined rather than required from src/core because this script
+// ships inside the plugin and must run without the CLI package resolvable.
+function precedentPointer(cwd) {
+  let declared = null;
+  try {
+    const configPath = path.join(cwd, "keel", "config.yaml");
+    if (!fs.existsSync(configPath)) return null;
+    for (const line of fs.readFileSync(configPath, "utf8").split(/\r?\n/)) {
+      const stripped = line.trim();
+      if (stripped.startsWith("#")) continue;
+      const match = stripped.match(/^precedents\s*:\s*(.+?)\s*$/);
+      if (match) {
+        declared = match[1];
+        break;
+      }
+    }
+    if (!declared) return null;
+    const resolved = path.isAbsolute(declared)
+      ? declared
+      : path.resolve(cwd, declared);
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+      return `precedent store declared at ${declared} but absent here; `
+        + "no precedent informs any decision.";
+    }
+    const files = fs
+      .readdirSync(resolved)
+      .filter((name) => name.endsWith(".md") && name !== "README.md");
+    let authorized = 0;
+    let newest = 0;
+    for (const name of files) {
+      const full = path.join(resolved, name);
+      if (/^-\s*Status:\s*authorized/mi.test(fs.readFileSync(full, "utf8"))) {
+        authorized += 1;
+      }
+      const mtime = fs.statSync(full).mtimeMs;
+      if (mtime > newest) newest = mtime;
+    }
+    const synced = newest
+      ? new Date(newest).toISOString().slice(0, 10)
+      : "never";
+    return `precedents: ${files.length} (${authorized} authorized, `
+      + `last synced ${synced}); bodies load at the decision, not here.`;
+  } catch {
+    // The projection never blocks a session. An unreadable store is the same
+    // as no store for this hook's purposes.
+    return null;
+  }
+}
+
 // The Keel mark. A keel is the carina, the ridge on a bird's sternum, so the
 // animal that literally has one is a bird. Every cell is drawn from
 // U+2580–U+259F — the same block-element family as the host's own startup
@@ -238,6 +293,8 @@ function main() {
         + "does not guess among candidates."
     );
   }
+  const pointer = precedentPointer(cwd);
+  if (pointer) lines.push(`- ${pointer}`);
   lines.push(`- report this state ${DISCLOSURE}; it authorizes nothing.`);
   emit(lines.join("\n"), panel(human));
   return 0;

package/plugins/keel/skills/keel-align-expectations/SKILL.md

@@ -40,6 +40,58 @@ Accepted alignment routes to existing OpenSpec owners; create no separate alignm
 - specs own observable requirements and positive/negative/edge/failure scenarios.
 - tasks.md owns Covers, verification strategy and checks, scope, and stop boundaries that reference the accepted authority instead of duplicating chat prose.
 
+## Decision precedents
+
+When the repository declares a precedent store, consult the precedent matching a decision before
+escalating it, and record a new precedent when the user decides something the store does not cover.
+A precedent store is user-authored and never bundled; a repository that declares none behaves
+exactly as one without this section.
+
+Record the reasoning, not only the conclusion. "Chose A" applies only to the situation literally
+recorded; "chose A because B fails offline" can be applied to a case nobody has seen yet, and — just
+as important — recognised as *not* applying when the new case is online. Only the reasoning transfers.
+A precedent with no rationale is incomplete and is not applied.
+
+Three rules govern use:
+
+- **Cite only where you replaced a question.** Name the precedent you applied exactly when, without
+  it, you would otherwise have interrupted the user. Decisions that would not have interrupted them
+  are not cited, so that a citation always marks a decision made in the user's place rather than
+  running commentary.
+- **Promotion is the user's act.** A precedent enters as `recorded` and is offered as a
+  recommendation while the question is still asked. To make one applicable without asking, propose
+  the promotion and name the precedent; it changes only when the user accepts. There is no usage
+  count, age, or other threshold that promotes anything, because a threshold crosses with nobody
+  watching.
+- **A precedent answers a recurrence; it never reclassifies.** It may shorten a decision inside its
+  materiality category by supplying the recorded answer and its reasoning. It never moves a decision
+  out of the categories that require asking, and no accumulation of precedents makes a category
+  immaterial. A decision that resembles a precedent but sits in a different category is not a match.
+
+A precedent informs a decision and never substitutes for a proof: gates, evidence, Review, and the
+write guard are untouched by anything in the store.
+
+## Unattended runs
+
+Work enters an unattended run only by the repository's declared triage policy — an issue carrying a
+label listed under `triage:` in `keel/config.yaml`, evaluated with `keel triage --labels <labels>`.
+Pass what `gh` returned; Keel never fetches the issue. Admission comes from that declaration and
+never from a precedent, however much triage history the store accumulates: whether an issue becomes
+work is a materiality decision, and a precedent may not move one out of that list.
+
+Admission answers "may this begin" and decides nothing after it. Alignment still escalates material
+choices, the gates still run, and the write guard still binds.
+
+An unattended run may triage, author, implement, verify, push where `authorize:` permits, and
+**open a pull request**. It **may not merge** one — merging is where an unreviewed decision becomes
+the project's history, and no declaration in Keel authorizes it.
+
+Stopping at a decision the user must make is the **designed boundary rather than a failure**.
+Report where the run stopped and why. Do not widen the triage policy to stop it happening.
+
+**Keel schedules nothing.** `/loop`, cron, and CI triggers belong to the host runtime; Keel's part
+is making each step decidable with authority.
+
 ## Domain lenses
 
 When the change signals a specific domain, look in `keel/lenses/` for a lens whose `Applies when:` header matches, and read only that lens before asking domain questions; do not load unrelated lenses. When no lens matches, or the repo defines none, proceed on the domain-agnostic path. Lenses are user-authored; scaffold the bundled starting points with `keel lenses add` (web, hardware, hardware-dsl).

package/scripts/validate_plugin.py

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.5.0"
-PROTOCOL_VERSION = "5.5.0"
+PACKAGE_VERSION = "5.7.0"
+PROTOCOL_VERSION = "5.7.0"
 LEGACY_MANAGED_START = "<!-- keel:start version=2.1 -->"
 OPENSPEC_SCHEMA_NAME = "keel-spec-driven"
 # Mirrors KEEL_PACKAGE_NAME in scripts/install_to_repo.py, one of the two
@@ -11363,6 +11363,718 @@ def validate_standing_authorization_inheritance_scenario() -> int:
     return 0
 
 
+def write_precedent(
+    store: Path,
+    name: str,
+    *,
+    category: str = "external interface",
+    status: str = "recorded",
+    decision: str = "Return 404 rather than 200 with an empty body.",
+    rationale: str | None = "A 200 teaches every caller to parse the body to learn it failed.",
+) -> None:
+    store.mkdir(parents=True, exist_ok=True)
+    body = (
+        f"# {name}\n\n"
+        f"Applies when: a handler must report that a resource is absent.\n\n"
+        f"- Category: {category}\n"
+        f"- Status: {status}\n\n"
+        "## Decision\n\n"
+        f"{decision}\n"
+    )
+    if rationale is not None:
+        body += f"\n## Rationale\n\n{rationale}\n"
+    (store / f"{name}.md").write_text(body, encoding="utf-8")
+
+
+def validate_precedent_store_declaration_scenario() -> int:
+    with tempfile.TemporaryDirectory(prefix="keel-precedent-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # A store deliberately placed OUTSIDE every repository that reads it.
+        shared = root / "shared-store"
+        write_precedent(shared, "absent-resource-status")
+        write_precedent(shared, "irreversible-cost", status="authorized")
+
+        def declare(repo: Path, store: str | None) -> None:
+            (repo / "keel").mkdir(parents=True, exist_ok=True)
+            body = "fast_check: echo check\n"
+            if store is not None:
+                body += f"precedents: {store}\n"
+            (repo / "keel" / "config.yaml").write_text(body, encoding="utf-8")
+
+        # M1 — a declared, existing store is reported with its counts.
+        declared = root / "declared"
+        declared.mkdir()
+        declare(declared, str(shared).replace("\\", "/"))
+        out = run_keel(declared, "--doctor").stdout
+        if "Precedent store:" not in out:
+            report("precedent-store: doctor has no precedent surface.")
+            report(out)
+            return 1
+        for needle in ("precedents: 2", "authorized: 1"):
+            if needle not in out:
+                report(f"precedent-store: doctor does not report {needle}.")
+                report(out)
+                return 1
+
+        # M1 (continued) — an undeclared store leaves every surface alone.
+        silent = root / "silent"
+        silent.mkdir()
+        declare(silent, None)
+        silent_out = run_keel(silent, "--doctor").stdout
+        if "precedents: none" not in silent_out:
+            report("precedent-store: an undeclared store is not reported as none.")
+            report(silent_out)
+            return 1
+        if "fast_check: ok - declared in keel/config.yaml: echo check" not in silent_out:
+            report("precedent-store: the fast_check surface changed.")
+            report(silent_out)
+            return 1
+
+        # M2 — two repositories declaring the same out-of-tree path read the
+        # same precedents, which is the whole point of a declarable path.
+        second = root / "second"
+        second.mkdir()
+        declare(second, str(shared).replace("\\", "/"))
+        second_out = run_keel(second, "--doctor").stdout
+        if "precedents: 2" not in second_out or "authorized: 1" not in second_out:
+            report("precedent-store: a second repo did not read the shared store.")
+            report(second_out)
+            return 1
+
+        # M2 (continued) — a declared path that does not exist degrades to the
+        # no-store behavior. This is the state CI and every clone land in.
+        missing = root / "missing"
+        missing.mkdir()
+        declare(missing, str(root / "not-here").replace("\\", "/"))
+        missing_result = run_keel(missing, "--doctor")
+        if "precedents: none" not in missing_result.stdout:
+            report("precedent-store: a missing store path did not degrade to none.")
+            report(missing_result.stdout)
+            return 1
+        if missing_result.returncode != run_keel(silent, "--doctor").returncode:
+            report("precedent-store: a missing store path changed the doctor exit code.")
+            return 1
+
+        # M3 — completeness is a presence check, not a judgement.
+        incomplete_store = root / "incomplete-store"
+        write_precedent(incomplete_store, "no-reason", rationale=None)
+        incomplete = root / "incomplete"
+        incomplete.mkdir()
+        declare(incomplete, str(incomplete_store).replace("\\", "/"))
+        out = run_keel(incomplete, "--doctor").stdout
+        if "incomplete: 1" not in out or "no-reason" not in out:
+            report("precedent-store: a precedent with no rationale was not named incomplete.")
+            report(out)
+            return 1
+
+        opaque_store = root / "opaque-store"
+        write_precedent(opaque_store, "unevaluable", rationale="qqq")
+        opaque = root / "opaque"
+        opaque.mkdir()
+        declare(opaque, str(opaque_store).replace("\\", "/"))
+        out = run_keel(opaque, "--doctor").stdout
+        if "incomplete: 0" not in out:
+            report(
+                "precedent-store: a rationale Keel cannot evaluate was reported "
+                "incomplete; the check must be presence, not judgement."
+            )
+            report(out)
+            return 1
+
+        # M4 — reading a store performs no network access.
+        #
+        # Proxy environment variables do NOT prove this: Node's fetch ignores
+        # HTTP_PROXY entirely, so a run under them passes whether or not the
+        # code reaches the network. Instead, preload a module that makes every
+        # network primitive throw. Then a passing run is evidence that none was
+        # called, and any added network call fails loudly.
+        guard = root / "no-network.cjs"
+        guard.write_text(
+            "const fail = (what) => {\n"
+            "  throw new Error('network attempted: ' + what);\n"
+            "};\n"
+            "require('net').Socket.prototype.connect = () => fail('net.connect');\n"
+            "const http = require('http');\n"
+            "http.request = () => fail('http.request');\n"
+            "http.get = () => fail('http.get');\n"
+            "const https = require('https');\n"
+            "https.request = () => fail('https.request');\n"
+            "https.get = () => fail('https.get');\n"
+            "const dns = require('dns');\n"
+            "dns.lookup = () => fail('dns.lookup');\n"
+            "dns.resolve = () => fail('dns.resolve');\n"
+            "globalThis.fetch = () => fail('fetch');\n",
+            encoding="utf-8",
+        )
+        env = dict(os.environ)
+        env["NODE_OPTIONS"] = f"--require {str(guard).replace(chr(92), '/')}"
+        offline = run_keel(declared, "--doctor", env=env)
+        if "precedents: 2" not in offline.stdout:
+            report(
+                "precedent-store: reading the store attempted network access, "
+                "or failed under the no-network guard."
+            )
+            report((offline.stderr or offline.stdout).strip())
+            return 1
+
+    report("precedent-store-declaration scenario passed.")
+    return 0
+
+
+def validate_triage_declaration_scenario() -> int:
+    """Which work may start without asking is a declaration, never an inference.
+
+    The command must evaluate what it is handed. Keel does not fetch the issue,
+    because a gate that reaches the network trades the local, offline,
+    deterministic evaluation that makes its answer worth anything.
+    """
+
+    def declare(repo: Path, body: str | None) -> None:
+        (repo / "keel").mkdir(parents=True, exist_ok=True)
+        text = "fast_check: echo check\n"
+        if body is not None:
+            text += body
+        (repo / "keel" / "config.yaml").write_text(text, encoding="utf-8")
+
+    def triage(repo: Path, labels: str, env: dict | None = None) -> dict | None:
+        result = run_keel(repo, "triage", ".", "--labels", labels, "--json", env=env)
+        try:
+            return json.loads(result.stdout)
+        except json.JSONDecodeError:
+            return None
+
+    with tempfile.TemporaryDirectory(prefix="keel-triage-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — a declared label admits; anything else is refused by name.
+        declared = root / "declared"
+        declared.mkdir()
+        declare(declared, "triage:\n  - auto\n")
+        admitted = triage(declared, "auto,bug")
+        if admitted is None or admitted.get("status") != "admit":
+            report(f"triage: a declared label did not admit: {admitted}")
+            return 1
+        if "auto" not in (admitted.get("reason") or ""):
+            report(f"triage: the admission does not name the label: {admitted}")
+            return 1
+        refused = triage(declared, "bug,docs")
+        if refused is None or refused.get("status") != "refuse":
+            report(f"triage: an undeclared label was admitted: {refused}")
+            return 1
+        reason = refused.get("reason") or ""
+        for needle in ("bug", "docs", "auto"):
+            if needle not in reason:
+                report(
+                    "triage: the refusal must name both the labels carried and "
+                    f"the labels accepted; missing {needle}: {reason}"
+                )
+                return 1
+
+        # M2 — no policy refuses everything, and says so in those words.
+        for label, body in (("absent", None), ("empty", "triage:\n")):
+            silent = root / label
+            silent.mkdir()
+            declare(silent, body)
+            result = triage(silent, "auto")
+            if result is None or result.get("status") != "refuse":
+                report(f"triage: the {label} policy admitted an issue: {result}")
+                return 1
+            reason = result.get("reason") or ""
+            if "no triage policy" not in reason.lower():
+                report(
+                    f"triage: the {label} refusal does not distinguish an "
+                    f"undeclared policy from an unsuitable issue: {reason}"
+                )
+                return 1
+            out = run_keel(silent, "--doctor").stdout
+            if "triage: none" not in out:
+                report(f"triage: doctor does not report the {label} triage surface.")
+                report(out)
+                return 1
+        out = run_keel(declared, "--doctor").stdout
+        if "Unattended triage:" not in out or "triage: ok" not in out:
+            report("triage: doctor does not report a declared triage surface.")
+            report(out)
+            return 1
+
+        # M3 — no network, and the same inputs give the same answer.
+        guard = root / "no-network.cjs"
+        guard.write_text(
+            "const fail = (what) => {\n"
+            "  throw new Error('network attempted: ' + what);\n"
+            "};\n"
+            "require('net').Socket.prototype.connect = () => fail('net.connect');\n"
+            "const http = require('http');\n"
+            "http.request = () => fail('http.request');\n"
+            "http.get = () => fail('http.get');\n"
+            "const https = require('https');\n"
+            "https.request = () => fail('https.request');\n"
+            "https.get = () => fail('https.get');\n"
+            "const dns = require('dns');\n"
+            "dns.lookup = () => fail('dns.lookup');\n"
+            "globalThis.fetch = () => fail('fetch');\n",
+            encoding="utf-8",
+        )
+        env = dict(os.environ)
+        env["NODE_OPTIONS"] = f"--require {str(guard).replace(chr(92), '/')}"
+        # Two distinct failures, reported distinctly. Collapsing them would let
+        # a wrong verdict be reported as a network attempt, which sends the
+        # reader to the wrong place — the exact diagnostic failure this repo
+        # already has a rule against.
+        offline = triage(declared, "auto", env=env)
+        if offline is None:
+            report(
+                "triage: no JSON under the no-network guard, so evaluation "
+                "attempted network access or crashed."
+            )
+            return 1
+        if offline.get("status") != "admit":
+            report(
+                "triage: the offline run reached a different verdict than the "
+                f"online one: {offline}"
+            )
+            return 1
+        again = triage(declared, "auto", env=env)
+        if offline != again:
+            report(f"triage: the same inputs gave different answers: {offline} != {again}")
+            return 1
+
+    report("triage-declaration scenario passed.")
+    return 0
+
+
+def validate_unattended_boundary_scenario() -> int:
+    """The boundary must be readable where an unattended run will read it.
+
+    Phrases, not keywords: "unattended" appearing somewhere would satisfy a
+    keyword check while stating none of what a run may and may not do.
+    """
+
+    required = [
+        # What a run may do, and the one thing it may not.
+        "open a pull request",
+        "may not merge",
+        # Where the loop comes from.
+        "Keel schedules nothing",
+        # Stopping is the design, not a fault.
+        "designed boundary rather than a failure",
+        # Admission comes from a declaration, never from accumulated history.
+        "never from a precedent",
+    ]
+    canonical = ROOT / "src/skills/keel-align-expectations/SKILL.md"
+    distributed = ROOT / PLUGIN_ROOT / "skills/keel-align-expectations/SKILL.md"
+    protocol = ROOT / "AGENTS.md"
+
+    for label, path in (
+        ("protocol", protocol),
+        ("canonical skill", canonical),
+        ("distributed skill", distributed),
+    ):
+        if not path.is_file():
+            report(f"unattended-boundary: missing {label}: {path}")
+            return 1
+        # Collapse whitespace: these are multi-word phrases in hard-wrapped
+        # prose, so raw matching would assert the line layout, not the wording.
+        content = re.sub(r"\s+", " ", path.read_text(encoding="utf-8"))
+        for phrase in required:
+            if phrase not in content:
+                report(f"unattended-boundary: {label} omits: {phrase}")
+                return 1
+
+    if canonical.read_bytes() != distributed.read_bytes():
+        report("unattended-boundary: the canonical and distributed skills diverged.")
+        return 1
+
+    report("unattended-boundary scenario passed.")
+    return 0
+
+
+def validate_triage_admits_only_a_start_scenario() -> int:
+    """Admission answers "may this begin". It answers nothing after that.
+
+    Same two-repository shape as the standing-authorization and precedent
+    inertness scenarios, and for the same reason: a comparison that passes when
+    two repositories agree also passes when the declaration silently failed to
+    load, so the difference is asserted before it is asserted to be inert.
+    """
+
+    complete_task = (
+        "- [ ] 1.1 Behavior\n"
+        "  - Covers:\n"
+        "    - E1: public behavior\n"
+        "  - Touch:\n"
+        "    - src/feature.js\n"
+        "  - Verify:\n"
+        "    - Strategy: evidence-first\n"
+        "    - M1: node test.js proves the public behavior\n"
+        "  - Evidence:\n"
+        "    - Contract: pending\n"
+        "    - M1: node test.js printed ok\n"
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: reviewed\n"
+        "      - Scope check: reviewed\n"
+        "      - Findings: none\n"
+        "    - Blocker: none\n"
+    )
+    missing_evidence_task = complete_task.replace(
+        "    - M1: node test.js printed ok\n", "    - M1: pending\n"
+    )
+
+    def gate_result(repo: Path, stage: str) -> dict | None:
+        result = run_keel(
+            repo, "gate", stage, "--change", "demo", "--task", "1.1", "--json"
+        )
+        try:
+            payload = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            return None
+        return {
+            "status": payload.get("status"),
+            "problems": sorted(
+                (problem.get("code", ""), problem.get("message", ""))
+                for problem in payload.get("problems") or []
+            ),
+        }
+
+    with tempfile.TemporaryDirectory(prefix="keel-triage-inert-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        def pair(name: str, tasks: str) -> tuple[Path, Path]:
+            declaring = root / f"{name}-declaring"
+            declaring.mkdir()
+            write_gate_fixture(declaring, tasks)
+            (declaring / "keel").mkdir(parents=True, exist_ok=True)
+            (declaring / "keel" / "config.yaml").write_text(
+                "triage:\n  - auto\n", encoding="utf-8"
+            )
+            silent = root / f"{name}-silent"
+            silent.mkdir()
+            write_gate_fixture(silent, tasks)
+            # Positive control: the two repositories must actually differ on the
+            # triage surface, or every comparison below is trivially true.
+            live = run_keel(declaring, "--doctor").stdout
+            inert = run_keel(silent, "--doctor").stdout
+            if "triage: ok" not in live:
+                report(
+                    f"triage-inert: the {name} declaring fixture never loaded a "
+                    "triage policy; the comparisons below would be vacuous."
+                )
+                raise AssertionError("declaring fixture is not declaring")
+            if "triage: none" not in inert:
+                report(f"triage-inert: the {name} silent fixture declared a policy.")
+                raise AssertionError("silent fixture is not silent")
+            return declaring, silent
+
+        # M1 — every gate stage agrees across the pair.
+        declaring, silent = pair("complete", complete_task)
+        for stage in ("task-start", "task-complete"):
+            live = gate_result(declaring, stage)
+            inert = gate_result(silent, stage)
+            if live is None or inert is None:
+                report(f"triage-inert: {stage} produced no JSON.")
+                return 1
+            if live != inert:
+                report(
+                    f"triage-inert: a triage policy changed the {stage} result: "
+                    f"{live} != {inert}"
+                )
+                return 1
+
+        # M2 — missing evidence still fails, with unchanged failure text.
+        declaring, silent = pair("missing", missing_evidence_task)
+        for repo in (declaring, silent):
+            if gate_result(repo, "task-start") is None:
+                report("triage-inert: task-start produced no JSON.")
+                return 1
+        live = gate_result(declaring, "task-complete")
+        inert = gate_result(silent, "task-complete")
+        if live is None or inert is None:
+            report("triage-inert: task-complete produced no JSON.")
+            return 1
+        if live.get("status") == "pass":
+            report(
+                "triage-inert: a declared triage policy let a task with missing "
+                "evidence pass completion."
+            )
+            return 1
+        if live != inert:
+            report(
+                f"triage-inert: a triage policy changed the failure text: "
+                f"{live} != {inert}"
+            )
+            return 1
+
+    report("triage-admits-only-a-start scenario passed.")
+    return 0
+
+
+def validate_precedent_rules_scenario() -> int:
+    """The three rules the owner accepted must be in the skill, not in a chat.
+
+    Each is asserted by the phrase that carries its distinguishing content, not
+    by a keyword: "precedent" appearing somewhere would satisfy a keyword check
+    while saying none of what was decided.
+    """
+
+    required = [
+        # Citation: the trigger, and its negative half.
+        "would otherwise have interrupted",
+        "not cited",
+        # Promotion: who does it, and what does not.
+        "propose the promotion",
+        "no usage count",
+        # No reclassification, and the reason it is a fixed point.
+        "never moves a decision out of",
+        "recurrence",
+        # Recording: the rationale is the load-bearing field.
+        "reasoning transfers",
+    ]
+    canonical = ROOT / "src/skills/keel-align-expectations/SKILL.md"
+    distributed = ROOT / PLUGIN_ROOT / "skills/keel-align-expectations/SKILL.md"
+
+    for label, path in (("canonical", canonical), ("distributed", distributed)):
+        if not path.is_file():
+            report(f"precedent-rules: missing {label} skill: {path}")
+            return 1
+        # Collapse whitespace before matching. These are multi-word phrases and
+        # the file is hard-wrapped, so matching raw text would assert the line
+        # layout rather than the wording — and would fail on any later reflow
+        # that changed nothing.
+        content = re.sub(r"\s+", " ", path.read_text(encoding="utf-8"))
+        for phrase in required:
+            if phrase not in content:
+                report(f"precedent-rules: {label} skill omits: {phrase}")
+                return 1
+
+    if canonical.read_bytes() != distributed.read_bytes():
+        report("precedent-rules: the canonical and distributed skills diverged.")
+        return 1
+
+    report("precedent-rules scenario passed.")
+    return 0
+
+
+def validate_precedent_projection_pointer_scenario() -> int:
+    """SessionStart may say how big the store is. It may not say what is in it.
+
+    The store grows monotonically while the precedents relevant to any one
+    session are a small subset, and the hook pays its cost on every session
+    including post-compaction reinjection. So the projection carries counts and
+    freshness; bodies load when a decision is actually being made.
+    """
+
+    def projection(repo: Path) -> tuple[str, str]:
+        result = run_session_start_hook(
+            repo,
+            {"hook_event_name": "SessionStart", "source": "startup"},
+            keel_cli=f'node "{ROOT / "bin/keel.js"}"',
+        )
+        payload = json.loads(result.stdout.strip().splitlines()[-1])
+        return (
+            payload["hookSpecificOutput"]["additionalContext"],
+            payload.get("systemMessage", ""),
+        )
+
+    with tempfile.TemporaryDirectory(prefix="keel-precproj-") as raw_tmp:
+        root = Path(raw_tmp)
+        store = root / "store"
+        # Text that must never reach the projection. If any of it appears, a
+        # body leaked where only a pointer belongs.
+        write_precedent(
+            store,
+            "leak-canary",
+            status="authorized",
+            decision="NEVERAPPEARSINPROJECTION-decision",
+            rationale="NEVERAPPEARSINPROJECTION-rationale",
+        )
+        write_precedent(store, "second")
+
+        # The hook is silent outside a Keel repository, so both fixtures need
+        # an openspec tree before the projection exists at all.
+        declaring = root / "declaring"
+        declaring.mkdir()
+        write_text(declaring / "openspec/changes/demo/tasks.md", task_contract_fixture())
+        (declaring / "keel").mkdir(parents=True)
+        (declaring / "keel" / "config.yaml").write_text(
+            f"precedents: {str(store).replace(chr(92), '/')}\n", encoding="utf-8"
+        )
+        # Two ways to declare nothing, and they reach different branches: no
+        # config file at all, and a config file that declares other things.
+        silent = root / "silent"
+        silent.mkdir()
+        write_text(silent / "openspec/changes/demo/tasks.md", task_contract_fixture())
+        other_keys = root / "other-keys"
+        other_keys.mkdir()
+        write_text(
+            other_keys / "openspec/changes/demo/tasks.md", task_contract_fixture()
+        )
+        (other_keys / "keel").mkdir(parents=True)
+        (other_keys / "keel" / "config.yaml").write_text(
+            "fast_check: echo check\nauthorize:\n  - commit\n", encoding="utf-8"
+        )
+
+        # M1 — counts and freshness, never a body.
+        context, message = projection(declaring)
+        combined = f"{context}\n{message}"
+        if "precedents: 2" not in combined or "1 authorized" not in combined:
+            report(
+                "precedent-projection: the projection does not state the "
+                f"precedent counts: {combined!r}"
+            )
+            return 1
+        if "last synced" not in combined:
+            report("precedent-projection: the projection does not state store freshness.")
+            report(combined)
+            return 1
+        if "NEVERAPPEARSINPROJECTION" in combined:
+            report(
+                "precedent-projection: a precedent body reached the projection; "
+                "only a pointer belongs there."
+            )
+            report(combined)
+            return 1
+
+        # M2 — an undeclared store adds nothing at all, by either route.
+        for repo, label in ((silent, "no config file"), (other_keys, "other keys only")):
+            quiet_context, quiet_message = projection(repo)
+            if "precedent" in f"{quiet_context}\n{quiet_message}".lower():
+                report(
+                    f"precedent-projection: with {label}, an undeclared store "
+                    "still added text to the projection."
+                )
+                report(quiet_context)
+                return 1
+
+    report("precedent-projection-pointer scenario passed.")
+    return 0
+
+
+def validate_precedent_never_weakens_scenario() -> int:
+    """A precedent informs a decision. It must not stand in for a proof.
+
+    Same shape as the standing-authorization inertness scenario, and for the
+    same reason: every check passes when two repositories agree, so a store
+    that silently failed to load would make each comparison trivially true.
+    The positive control asserts the difference exists before asserting it is
+    inert.
+    """
+
+    complete_task = (
+        "- [ ] 1.1 Behavior\n"
+        "  - Covers:\n"
+        "    - E1: public behavior\n"
+        "  - Touch:\n"
+        "    - src/feature.js\n"
+        "  - Verify:\n"
+        "    - Strategy: evidence-first\n"
+        "    - M1: node test.js proves the public behavior\n"
+        "  - Evidence:\n"
+        "    - Contract: pending\n"
+        "    - M1: node test.js printed ok\n"
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: reviewed\n"
+        "      - Scope check: reviewed\n"
+        "      - Findings: none\n"
+        "    - Blocker: none\n"
+    )
+    missing_evidence_task = complete_task.replace(
+        "    - M1: node test.js printed ok\n", "    - M1: pending\n"
+    )
+
+    def gate_result(repo: Path, stage: str) -> dict | None:
+        result = run_keel(
+            repo, "gate", stage, "--change", "demo", "--task", "1.1", "--json"
+        )
+        try:
+            payload = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            return None
+        return {
+            "status": payload.get("status"),
+            "problems": sorted(
+                (problem.get("code", ""), problem.get("message", ""))
+                for problem in payload.get("problems") or []
+            ),
+        }
+
+    with tempfile.TemporaryDirectory(prefix="keel-precinert-") as raw_tmp:
+        root = Path(raw_tmp)
+        store = root / "store"
+        for name in ("first", "second", "third"):
+            write_precedent(store, name, status="authorized")
+
+        def pair(name: str, tasks: str) -> tuple[Path, Path]:
+            declaring = root / f"{name}-declaring"
+            declaring.mkdir()
+            write_gate_fixture(declaring, tasks)
+            (declaring / "keel").mkdir(parents=True, exist_ok=True)
+            (declaring / "keel" / "config.yaml").write_text(
+                f"precedents: {str(store).replace(chr(92), '/')}\n", encoding="utf-8"
+            )
+            silent = root / f"{name}-silent"
+            silent.mkdir()
+            write_gate_fixture(silent, tasks)
+            # Positive control: prove the two repositories actually differ
+            # before proving the difference changes nothing.
+            live = run_keel(declaring, "--doctor").stdout
+            inert = run_keel(silent, "--doctor").stdout
+            if "precedents: 3" not in live or "authorized: 3" not in live:
+                report(
+                    f"precedent-inert: the {name} declaring fixture never loaded "
+                    "its store; every comparison below would be vacuous."
+                )
+                raise AssertionError("declaring fixture is not declaring")
+            if "precedents: none" not in inert:
+                report(f"precedent-inert: the {name} silent fixture declared a store.")
+                raise AssertionError("silent fixture is not silent")
+            return declaring, silent
+
+        # M1 — every gate stage agrees across the pair.
+        declaring, silent = pair("complete", complete_task)
+        for stage in ("task-start", "task-complete"):
+            live = gate_result(declaring, stage)
+            inert = gate_result(silent, stage)
+            if live is None or inert is None:
+                report(f"precedent-inert: {stage} produced no JSON.")
+                return 1
+            if live != inert:
+                report(
+                    f"precedent-inert: a declared store changed the {stage} "
+                    f"result: {live} != {inert}"
+                )
+                return 1
+
+        # M2 — missing evidence still fails, with unchanged failure text.
+        declaring, silent = pair("missing", missing_evidence_task)
+        for repo in (declaring, silent):
+            if gate_result(repo, "task-start") is None:
+                report("precedent-inert: task-start produced no JSON.")
+                return 1
+        live = gate_result(declaring, "task-complete")
+        inert = gate_result(silent, "task-complete")
+        if live is None or inert is None:
+            report("precedent-inert: task-complete produced no JSON.")
+            return 1
+        if live.get("status") == "pass":
+            report(
+                "precedent-inert: a store of authorized precedents let a task "
+                "with missing evidence pass completion."
+            )
+            return 1
+        if live != inert:
+            report(
+                "precedent-inert: a declared store changed the failure text: "
+                f"{live} != {inert}"
+            )
+            return 1
+
+    report("precedent-never-weakens scenario passed.")
+    return 0
+
+
 def validate_standing_authorization_never_weakens_scenario() -> int:
     """A declaration removes a confirmation. It must not remove a proof.
 
@@ -14910,6 +15622,22 @@ SCENARIOS: tuple = (
         "standing-authorization-never-weakens",
         validate_standing_authorization_never_weakens_scenario,
     ),
+    (
+        "precedent-store-declaration",
+        validate_precedent_store_declaration_scenario,
+    ),
+    ("precedent-never-weakens", validate_precedent_never_weakens_scenario),
+    ("precedent-rules", validate_precedent_rules_scenario),
+    ("triage-declaration", validate_triage_declaration_scenario),
+    (
+        "triage-admits-only-a-start",
+        validate_triage_admits_only_a_start_scenario,
+    ),
+    ("unattended-boundary", validate_unattended_boundary_scenario),
+    (
+        "precedent-projection-pointer",
+        validate_precedent_projection_pointer_scenario,
+    ),
     ("fast-check-config-scaffold", validate_fast_check_config_scaffold_scenario),
     ("fast-pre-push-hooks", validate_fast_pre_push_hooks_scenario),
     ("fast-pre-push-doctor", validate_fast_pre_push_doctor_scenario),

package/src/core/config.js

@@ -11,18 +11,18 @@ const STANDING_AUTHORIZATION_ACTIONS = ["commit", "push", "release", "archive"];
 
 const CONFIG_RELATIVE_PATH = path.join("keel", "config.yaml");
 
-// The declaration shares keel/config.yaml with fast_check, so the reader stays
+// The declarations share keel/config.yaml with fast_check, so the reader stays
 // line-oriented rather than pulling in a YAML dependency for a format Keel
 // controls and keeps flat on purpose.
-function readStandingAuthorization(repo) {
+function configList(repo, key) {
   const configPath = path.join(repo, "keel", "config.yaml");
-  const declared = [];
-  const unknown = [];
-  if (!fs.existsSync(configPath)) return { declared, unknown };
+  const entries = [];
+  if (!fs.existsSync(configPath)) return entries;
+  const opener = new RegExp(`^${key}\\s*:\\s*$`);
   let inBlock = false;
   for (const line of fs.readFileSync(configPath, "utf8").split(/\r?\n/)) {
     if (/^\s*#/.test(line)) continue;
-    if (/^authorize\s*:\s*$/.test(line)) {
+    if (opener.test(line)) {
       inBlock = true;
       continue;
     }
@@ -32,8 +32,27 @@ function readStandingAuthorization(repo) {
     // Anything that is not a list item closes the block; the next top-level
     // key belongs to the rest of the file.
     if (!entry) break;
-    if (STANDING_AUTHORIZATION_ACTIONS.includes(entry[1])) declared.push(entry[1]);
-    else unknown.push(entry[1]);
+    entries.push(entry[1]);
+  }
+  return entries;
+}
+
+// Which issues may start work without asking. This is a declaration and never
+// an inference: "should this issue be done" sits in the materiality categories
+// that require asking, and a precedent may never move a decision out of them.
+// A label is the unit because a human applies one to a specific issue, so the
+// policy authorizes a class the owner curates one issue at a time rather than a
+// guess about which issues look easy.
+function readTriagePolicy(repo) {
+  return { labels: configList(repo, "triage") };
+}
+
+function readStandingAuthorization(repo) {
+  const declared = [];
+  const unknown = [];
+  for (const entry of configList(repo, "authorize")) {
+    if (STANDING_AUTHORIZATION_ACTIONS.includes(entry)) declared.push(entry);
+    else unknown.push(entry);
   }
   // Fail closed. A declaration Keel cannot fully read authorizes nothing,
   // because the alternative is granting the entries beside a typo while the
@@ -42,8 +61,107 @@ function readStandingAuthorization(repo) {
   return { declared, unknown };
 }
 
+function configScalar(repo, key) {
+  const configPath = path.join(repo, "keel", "config.yaml");
+  if (!fs.existsSync(configPath)) return null;
+  const pattern = new RegExp(`^${key}\\s*:\\s*(.+?)\\s*$`);
+  for (const line of fs.readFileSync(configPath, "utf8").split(/\r?\n/)) {
+    const stripped = line.trim();
+    if (stripped.startsWith("#")) continue;
+    const match = stripped.match(pattern);
+    if (match) return match[1];
+  }
+  return null;
+}
+
+// Keel reads a local directory and nothing else. How that directory came to
+// exist — a clone, an installed plugin, hand-authored files — is outside Keel,
+// because a surface that reaches the network trades the local, offline,
+// deterministic properties that make it trustworthy.
+function readPrecedentStore(repo) {
+  const declared = configScalar(repo, "precedents");
+  if (!declared) return { declared: null, path: null, precedents: [] };
+  const resolved = path.isAbsolute(declared)
+    ? declared
+    : path.resolve(repo, declared);
+  // A declared path that is not there degrades to the no-store behavior rather
+  // than to an error: a private store is exactly what a fresh clone and CI will
+  // not have, and a repository declaring one must still be usable by them.
+  if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+    return { declared, path: resolved, precedents: [] };
+  }
+  const precedents = fs
+    .readdirSync(resolved)
+    .filter((name) => name.endsWith(".md") && name !== "README.md")
+    .sort()
+    .map((name) => {
+      const content = fs.readFileSync(path.join(resolved, name), "utf8");
+      const status = (content.match(/^-\s*Status:\s*(\S+)/mi) || [])[1] || "";
+      // Presence, never judgement. Keel cannot tell a good reason from a bad
+      // one and must not imply it can; it can tell a reason from no reason,
+      // and a conclusion with no reason cannot be carried to a situation that
+      // is not literally the recorded one.
+      const rationale = content
+        .split(/^##\s+/m)
+        .find((section) => /^Rationale\s*$/i.test(section.split(/\r?\n/)[0]));
+      return {
+        name: name.replace(/\.md$/, ""),
+        status: status.toLowerCase(),
+        complete: Boolean(
+          rationale
+          && rationale.split(/\r?\n/).slice(1).join("\n").trim()
+        ),
+      };
+    });
+  return { declared, path: resolved, precedents };
+}
+
+// Evaluate a declared policy against labels handed in. Keel never fetches the
+// issue: the agent reads it with `gh` and passes what it found, which keeps this
+// local, offline, deterministic, and testable without a network.
+function triageIssue(repo, labels) {
+  const { labels: accepted } = readTriagePolicy(repo);
+  const carried = labels.filter((label) => label);
+  if (accepted.length === 0) {
+    return {
+      status: "refuse",
+      accepted,
+      labels: carried,
+      reason:
+        "this repository declares no triage policy, so no issue starts work "
+        + "unattended; declare accepted labels under `triage:` in "
+        + "keel/config.yaml to change that. This is not a judgement about the "
+        + "issue.",
+    };
+  }
+  const matched = carried.filter((label) => accepted.includes(label));
+  if (matched.length > 0) {
+    return {
+      status: "admit",
+      accepted,
+      labels: carried,
+      matched,
+      reason:
+        `admitted by declared label ${matched.join(", ")}; admission starts `
+        + "work and decides nothing after it — every later gate still applies "
+        + "and a material decision still stops for the owner.",
+    };
+  }
+  return {
+    status: "refuse",
+    accepted,
+    labels: carried,
+    reason:
+      `the issue carries ${carried.length > 0 ? carried.join(", ") : "no labels"}`
+      + ` and this repository accepts ${accepted.join(", ")}.`,
+  };
+}
+
 module.exports = {
   CONFIG_RELATIVE_PATH,
   STANDING_AUTHORIZATION_ACTIONS,
+  readPrecedentStore,
   readStandingAuthorization,
+  readTriagePolicy,
+  triageIssue,
 };