@christang/keel 5.6.0 → 5.7.0

package/README.md

@@ -192,6 +192,43 @@ gates, evidence, review, and the write guard are untouched by anything in the st
 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,
@@ -286,6 +323,10 @@ keel guard clear  --json
 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.6.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

@@ -48,6 +48,8 @@ const {
   STANDING_AUTHORIZATION_ACTIONS,
   readPrecedentStore,
   readStandingAuthorization,
+  readTriagePolicy,
+  triageIssue,
 } = require("../src/core/config");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
@@ -177,6 +179,7 @@ function parseArgs(argv) {
     guardSubcommand: null,
     lensesSubcommand: null,
     lensName: null,
+    labels: null,
     openspecArgs: [],
     force: false,
     projectionEvent: null,
@@ -220,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);
@@ -471,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
     )
     && (
@@ -540,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");
   }
@@ -1355,6 +1376,7 @@ function runDoctor(options) {
   printLensSurface(repo, options.target);
   const authorizationOk = printStandingAuthorizationSurface(repo);
   printPrecedentSurface(repo);
+  printTriageSurface(repo);
   printFastPrePushSurface(repo);
   printSourceRepoCliResolution(repo);
 
@@ -1432,6 +1454,19 @@ 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);
@@ -1713,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.6.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.6.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.6.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/skills/keel-align-expectations/SKILL.md

@@ -71,6 +71,27 @@ Three rules govern use:
 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.6.0"
-PROTOCOL_VERSION = "5.6.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
@@ -11522,6 +11522,294 @@ def validate_precedent_store_declaration_scenario() -> int:
     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.
 
@@ -15340,6 +15628,12 @@ SCENARIOS: tuple = (
     ),
     ("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,

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
@@ -97,9 +116,52 @@ function readPrecedentStore(repo) {
   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,
 };