@christang/keel 5.70.0 → 5.72.0

package/README.md

@@ -268,6 +268,28 @@ material choice, every gate still runs, and the write guard still binds. In part
 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.
 
+### Who merges
+
+Keel never lets the agent merge — an unattended run opens a pull request and stops. A repository can
+still merge without a person, on a rule of its own: GitHub auto-merge behind a required status check,
+or a workflow job that merges what passed. Keel's own repository does the second — the `land` job in
+`.github/workflows/publish.yml` merges the owner's pull request once `full-gate` passed on its head
+commit, then publishes and releases the version in the same run, with no stored secret. If your
+repository merges on its own, say so:
+
+```yaml
+merge: repository:full-gate
+```
+
+`keel context` then reports that the default branch merges when `full-gate` passes and that **no human
+reviews before merge**. Without it, a reader of your protocol concludes a person looked at every change,
+because the only thing the protocol says about merging is that the agent may not.
+
+`merge: human` says the opposite. A bare `repository` is refused — "nobody reviews this" is only honest
+beside what replaced the reviewer. It is not a permission: `authorize:` has no `merge` entry and should
+not gain one. Keel reads the declaration and never GitHub, so it cannot check that auto-merge is really
+on; it reports what you declared.
+
 ### Full vs Lite
 
 Use **Full mode** (the OpenSpec flow above) for new features, interface or protocol changes,

package/assets/bootstrap/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- keel:start version=5.70.0 -->
+<!-- keel:start version=5.72.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

@@ -50,6 +50,7 @@ const {
   readStandingAuthorization,
   readFullModePaths,
   readExecutorTier,
+  readMergeDeclaration,
   fullModePathsUnreadableMessage,
   readTriagePolicy,
   triageIssue,
@@ -1733,6 +1734,7 @@ function runDoctor(options) {
   printTriageSurface(repo);
   printRoutingSurface(repo);
   printExecutorTierSurface(repo);
+  printMergeSurface(repo);
   printFastPrePushSurface(repo);
   printSourceRepoCliResolution(repo);
 
@@ -1860,6 +1862,29 @@ function printRoutingSurface(repo) {
 // Reported whether or not it is declared, because the default is the state a
 // reader most needs to see: a repository that declared nothing is loading every
 // skill's guidance and has no other surface that says so.
+// Reported whether or not it is declared: the doctor is where a reader goes to
+// learn what is and is not declared, and "undeclared" is itself the answer to
+// "does anything here claim merges are reviewed".
+function printMergeSurface(repo) {
+  process.stdout.write("\nMerge:\n");
+  const merge = readMergeDeclaration(repo);
+  if (!merge.declared) {
+    printDoctorLine("merge", "undeclared", "nothing here claims how merges happen");
+    return;
+  }
+  if (merge.unknown.length > 0) {
+    printDoctorLine("merge", "unreadable", merge.message);
+    return;
+  }
+  printDoctorLine(
+    "merge",
+    merge.kind === "repository" ? `repository:${merge.check}` : merge.kind,
+    merge.kind === "repository"
+      ? `declared in keel/config.yaml - the default branch merges when ${merge.check} passes, with no human review; the agent still never merges`
+      : "declared in keel/config.yaml - a person merges"
+  );
+}
+
 function printExecutorTierSurface(repo) {
   process.stdout.write("\nExecutor tier:\n");
   const { declared, tier, unknown, message } = readExecutorTier(repo);

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.70.0",
+  "version": "5.72.0",
   "license": "MIT",
   "repository": {
     "type": "git",

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

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.70.0",
+  "version": "5.72.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.70.0",
+  "version": "5.72.0",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/scripts/validate_plugin.py

@@ -38,8 +38,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.70.0"
-PROTOCOL_VERSION = "5.70.0"
+PACKAGE_VERSION = "5.72.0"
+PROTOCOL_VERSION = "5.72.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
@@ -17219,15 +17219,46 @@ def run_node_expression(root: Path, expression: str) -> str:
     return result.stdout
 
 
-def config_header_problem(names: list, flat_header: str) -> str:
+def config_header_paragraph(config_text: str) -> str:
+    """The opening paragraph that lists the declarations, whitespace-collapsed.
+
+    The header, not the file. Both callers used to pass the whole of
+    `keel/config.yaml`, so a declaration name appearing anywhere in the body — a
+    comment elsewhere that happened to use the word — satisfied "the header names
+    it". `merge` did exactly that in 5.71.0, through the triage section's "never
+    authorizes a merge", before the header said anything about it (#155).
+    """
+    lines = config_text.splitlines()
+    start = next(
+        (i for i, line in enumerate(lines) if "independent declarations live here" in line),
+        None,
+    )
+    if start is None:
+        return ""
+    paragraph = []
+    for line in lines[start:]:
+        if not line.startswith("#") or line.strip() == "#":
+            break
+        paragraph.append(line.lstrip("#").strip())
+    return re.sub(r"\s+", " ", " ".join(paragraph))
+
+
+def config_header_problem(names: list, config_text: str) -> str:
     """The one rule for "the header names every declaration", or "" when it does.
 
     Returns the diagnostic naming the missing declaration. Deliberately reports
     no count: a count tells an author that two numbers differ, and the name tells
     them which line to write.
     """
+    header = config_header_paragraph(config_text)
+    if not header:
+        return (
+            "keel/config.yaml has no header paragraph listing its declarations "
+            "(the one containing `independent declarations live here`), so "
+            "nothing tells a project which keys it may write."
+        )
     for name in names:
-        if name not in flat_header:
+        if name not in header:
             return (
                 f"keel/config.yaml's header does not name the `{name}` "
                 "declaration, so a project reading it would never learn it may "
@@ -28874,7 +28905,7 @@ def validate_a_count_is_derived_from_what_it_counts_scenario() -> int:
             return 1
 
     header = (ROOT / "keel/config.yaml").read_text(encoding="utf-8")
-    flat_header = re.sub(r"\s+", " ", header)
+    flat_header = config_header_paragraph(header)
     for name in names:
         if name not in flat_header:
             report(
@@ -28887,7 +28918,7 @@ def validate_a_count_is_derived_from_what_it_counts_scenario() -> int:
     # The derivation is proved by feeding the check a member the header cannot
     # contain. Without this the whole scenario is satisfied by a list that
     # happens to agree with a header nobody compared it to.
-    missing = config_header_problem(names + ["invented_declaration"], flat_header)
+    missing = config_header_problem(names + ["invented_declaration"], header)
     if not missing:
         report(
             f"{label}: the assertion is a literal — a declaration absent from "
@@ -28908,6 +28939,23 @@ def validate_a_count_is_derived_from_what_it_counts_scenario() -> int:
         )
         return 1
 
+    # The header is the opening paragraph, not the file. A declaration name that
+    # appears only in the body — a comment elsewhere happening to use the word —
+    # does not tell a new project it may write that key. Found when `merge` was
+    # added in 5.71.0: the triage section's "never authorizes a merge" satisfied
+    # the rule before the header said anything (#155).
+    body_only = header.replace(
+        "# delegation, which names who runs a task;",
+        "# delegation, which names who runs a task;",
+    ) + "\n# a body comment that mentions body_only_declaration in passing\n"
+    if not config_header_problem(names + ["body_only_declaration"], body_only):
+        report(
+            f"{label}: a declaration named only in the file body was accepted as "
+            "named in the header — the rule reads the whole file, so any common "
+            "word used anywhere satisfies it."
+        )
+        return 1
+
     # A header naming every declaration while miscounting them in prose passes:
     # membership is the checkable property, and a count is a lossy restatement.
     # The numeral is located by shape, not by its current value. Pinning the
@@ -28917,7 +28965,7 @@ def validate_a_count_is_derived_from_what_it_counts_scenario() -> int:
     miscounted, varied = re.subn(
         r"\b\w+ independent declarations\b",
         "Zero independent declarations",
-        flat_header,
+        header,
         count=1,
     )
     if not varied:
@@ -29729,6 +29777,13 @@ def publish_serialization_problem(workflow: str) -> str | None:
             "release would cancel a publish still waiting to run, losing that "
             "version outright rather than appearing to."
         )
+    if not re.search(r"^[ \t]+queue:\s*max\s*$", body, re.M):
+        return (
+            "a pending publish would be cancelled by the next one — the group "
+            "declares no `queue: max`, and the default `queue: single` keeps one "
+            "pending run and cancels it when a newer one arrives, so a burst of "
+            "three releases drops the middle version (#157)."
+        )
     group = re.search(r"^[ \t]+group:\s*(\S.*?)\s*$", body, re.M)
     if not group:
         return (
@@ -29787,6 +29842,25 @@ def validate_a_publish_waits_for_the_one_before_it_scenario() -> int:
         )
         return 1
 
+    # The pending half (#157). `cancel-in-progress: false` protects the running
+    # publish; the default `queue: single` still cancels a pending one when a
+    # newer run arrives, so a burst of three releases drops the middle version.
+    # A copy without `queue: max` is exactly what 5.70.0 shipped.
+    unqueued = workflow.replace("  queue: max\n", "")
+    if unqueued == workflow:
+        report(
+            f"{label}: a pending publish would be cancelled by the next one — "
+            "`queue: max` could not be located to remove, so the real file keeps "
+            "at most one pending run and cancels the rest."
+        )
+        return 1
+    if not publish_serialization_problem(unqueued):
+        report(
+            f"{label}: a pending publish would be cancelled by the next one — a "
+            "group without `queue: max` was accepted."
+        )
+        return 1
+
     # M2 — the option whose default is wrong for this job. A check satisfied by
     # the block alone would pass on the configuration that loses a version
     # outright, which is worse than the one being fixed here.
@@ -29829,6 +29903,297 @@ def validate_a_publish_waits_for_the_one_before_it_scenario() -> int:
     return 0
 
 
+def validate_a_merge_names_who_makes_it_scenario() -> int:
+    """Issue #155: the protocol says the agent may not merge, and stops there.
+
+    Once a repository merges on its own rule — auto-merge behind a required
+    check — that sentence is literally true and misleading: a reader concludes
+    every change reaching the default branch was looked at by a person. The
+    declaration says who merges, so the projection can say it too.
+    """
+    label = "a-merge-names-who-makes-it"
+
+    with tempfile.TemporaryDirectory(prefix="keel-merge-") as raw:
+        root = Path(raw)
+
+        def fixture(name: str, body: str) -> Path:
+            repo = root / name
+            repo.mkdir()
+            (repo / "keel").mkdir()
+            (repo / "keel" / "config.yaml").write_text(body, encoding="utf-8")
+            return repo
+
+        def merge_lines(out: str) -> list[str]:
+            return [l for l in out.splitlines() if l.startswith("Merge:")]
+
+        # M1 — a repository merge is reported with its consequence.
+        repo = fixture("repository", "fast_check: echo r\nmerge: repository:full-gate\n")
+        out = run_keel(repo, "context").stdout
+        lines = merge_lines(out)
+        if not lines:
+            report(
+                f"{label}: no merge declaration reported — a repository that "
+                "declared its default branch merges on `full-gate` is told "
+                "nothing about it where the session starts."
+            )
+            report(out)
+            return 1
+        if "full-gate" not in lines[0]:
+            report(f"{label}: the Merge line does not name the check; got {lines[0]!r}.")
+            return 1
+        if "no human" not in lines[0].lower():
+            report(
+                f"{label}: the Merge line echoes the value without its "
+                f"consequence — that no human reviews before merge; got {lines[0]!r}."
+            )
+            return 1
+
+        human = fixture("human", "fast_check: echo h\nmerge: human\n")
+        lines = merge_lines(run_keel(human, "context").stdout)
+        if not lines:
+            report(f"{label}: no merge declaration reported for `merge: human`.")
+            return 1
+        if "human" not in lines[0]:
+            report(f"{label}: the `merge: human` line does not say human; got {lines[0]!r}.")
+            return 1
+
+        absent = fixture("absent", "fast_check: echo a\n")
+        out = run_keel(absent, "context").stdout
+        if merge_lines(out):
+            report(
+                f"{label}: an undeclared repository was given a Merge line — "
+                "Keel cannot know how it merges and must not claim it."
+            )
+            report(out)
+            return 1
+
+        # M2 — a claim without its basis claims nothing. A bare `repository`
+        # says no person reviews without naming what does, which is the claim
+        # that misleads most; an unknown value is a typo its author believes.
+        for name, value in (("bare", "repository"), ("unknown", "robots")):
+            bad = fixture(name, f"fast_check: echo b\nmerge: {value}\n")
+            out = run_keel(bad, "context").stdout
+            if merge_lines(out):
+                report(
+                    f"{label}: accepted a merge claim with no basis — "
+                    f"`merge: {value}` produced {merge_lines(out)!r}."
+                )
+                return 1
+            if value not in out:
+                report(f"{label}: the refusal does not name `{value}`.")
+                report(out)
+                return 1
+            if "repository:<check>" not in out:
+                report(f"{label}: the refusal does not name the accepted forms.")
+                report(out)
+                return 1
+
+        # M3 — the declaration is not a permission. `merge` under `authorize:`
+        # stays an unrecognized action, so nobody can read the new key as leave
+        # for the agent to merge.
+        perm = fixture("perm", "fast_check: echo p\nauthorize:\n  - merge\n")
+        doctor = run_keel(perm, "--doctor").stdout
+        if "unrecognized action: merge" not in doctor:
+            report(
+                f"{label}: `authorize: merge` is not reported as an unrecognized "
+                "action, so the new declaration could be read as permission."
+            )
+            report(doctor)
+            return 1
+
+        for name, repo_, expected in (
+            ("repository", repo, "full-gate"),
+            ("human", human, "human"),
+            ("absent", absent, "undeclared"),
+        ):
+            doctor = run_keel(repo_, "--doctor").stdout
+            merge_doctor = [l for l in doctor.splitlines() if l.startswith("merge:")]
+            if not merge_doctor:
+                report(
+                    f"{label}: no merge declaration reported by the doctor for the "
+                    f"{name} fixture — it has no `merge:` line at all."
+                )
+                return 1
+            if expected not in merge_doctor[0]:
+                report(
+                    f"{label}: the doctor's merge line for the {name} fixture does "
+                    f"not name {expected!r}; got {merge_doctor[0]!r}."
+                )
+                return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
+def workflow_job_block(workflow: str, job: str) -> str:
+    """The text of one job under `jobs:`, up to the next job at the same indent."""
+    match = re.search(
+        r"^  " + re.escape(job) + r":\n((?:(?:    [^\n]*|[ \t]*)\n)*)",
+        workflow,
+        re.M,
+    )
+    return match.group(1) if match else ""
+
+
+def landing_problem(workflow: str) -> str | None:
+    """Return the problem the landing path in `publish.yml` has, or None.
+
+    Takes text so each broken shape can be planted. The workflow runs only on
+    GitHub from the default branch; the repository's copy is the one input
+    guaranteed to be correct, so a rule that only read it would never be seen to
+    fire.
+    """
+    land = workflow_job_block(workflow, "land")
+    if not land:
+        return (
+            f"merges without confirming full-gate — {PUBLISH_WORKFLOW} has no "
+            "`land` job."
+        )
+    if "check_name=full-gate" not in land:
+        return (
+            "merges without confirming full-gate — the `land` job never reads "
+            "the `full-gate` check-run on the head commit before merging."
+        )
+    if "--match-head-commit" not in land:
+        return (
+            "merges without confirming full-gate — the merge is not pinned to the "
+            "tested head commit, so a push after the check could land untested."
+        )
+    if "actions/checkout" in land:
+        return (
+            "pull request code could run with a write token — the `land` job "
+            "checks out code, and it runs in the base repository's context with "
+            "write permission."
+        )
+    if '.user.login == \\"$OWNER\\"' not in land:
+        return (
+            "pull request code could run with a write token — the `land` job "
+            "does not restrict itself to the repository owner's pull requests."
+        )
+    if '.head.repo.full_name == \\"$REPO\\"' not in land:
+        return (
+            "pull request code could run with a write token — the `land` job "
+            "does not refuse pull requests from forks."
+        )
+    publish = workflow_job_block(workflow, "publish")
+    published_at = publish.find("npm publish")
+    released_at = publish.find("gh release create")
+    if published_at < 0 or released_at < 0:
+        return (
+            "a failed publish would be left tagged and never retried — the "
+            "`publish` job lacks `npm publish` or `gh release create`."
+        )
+    if released_at < published_at:
+        return (
+            "a failed publish would be left tagged and never retried — the "
+            "`publish` job creates the tag and release before `npm publish`, and "
+            "a tag is what tells the next run the version is already released."
+        )
+    return None
+
+
+def validate_the_repository_lands_what_passed_scenario() -> int:
+    """#155 follow-up: the repository merges, not the agent, with no stored secret.
+
+    Events made with `GITHUB_TOKEN` start no new workflow runs, so a chain of
+    workflows (merge, then release, then publish) needs a personal token at every
+    hand-off. One run that merges, publishes and releases has no hand-off. The
+    price is that the landing job runs with write permission in the base
+    repository's context — so it must run no pull-request code, land only the
+    owner's own pull requests, and merge only the commit `full-gate` passed.
+    """
+    label = "the-repository-lands-what-passed"
+    workflow = (ROOT / PUBLISH_WORKFLOW).read_text(encoding="utf-8")
+
+    problem = landing_problem(workflow)
+    if problem:
+        report(f"{label}: {problem}")
+        return 1
+    land = workflow_job_block(workflow, "land")
+    if not land:
+        report(
+            f"{label}: merges without confirming full-gate — {PUBLISH_WORKFLOW} "
+            "has no `land` job, so nothing lands a pull request that passed."
+        )
+        return 1
+
+    # M1 — the check is read and the tested commit is what merges.
+    for needle, why in (
+        ("check_name=full-gate", "without reading the `full-gate` check-run"),
+        ("--match-head-commit", "without pinning the merge to the tested head commit"),
+    ):
+        planted = workflow.replace(needle, "")
+        if planted == workflow:
+            report(f"{label}: merges without confirming full-gate — `{needle}` is absent.")
+            return 1
+        if not landing_problem(planted):
+            report(
+                f"{label}: merges without confirming full-gate — a landing job "
+                f"that merges {why} was accepted."
+            )
+            return 1
+
+    # M2 — no pull-request code under a write token, and only the owner's own
+    # pull requests from this repository. `workflow_run` and
+    # `pull_request_target` run in the base repository's context with the
+    # permissions the job asks for, so a checkout there hands the token to
+    # whatever the pull request contains.
+    checkout = workflow.replace(
+        "      - name: Land an owner's pull request whose head passed full-gate\n",
+        "      - uses: actions/checkout@v4\n"
+        "      - name: Land an owner's pull request whose head passed full-gate\n",
+    )
+    if checkout == workflow:
+        report(f"{label}: pull request code could run with a write token — the land step could not be located.")
+        return 1
+    if not landing_problem(checkout):
+        report(
+            f"{label}: pull request code could run with a write token — a "
+            "`land` job with a checkout step was accepted."
+        )
+        return 1
+    for needle, why in (
+        ('.user.login == \\"$OWNER\\"', "any author's pull request"),
+        ('.head.repo.full_name == \\"$REPO\\"', "a pull request from a fork"),
+    ):
+        planted = workflow.replace(" and " + needle, "")
+        if planted == workflow:
+            report(f"{label}: pull request code could run with a write token — `{needle}` is absent.")
+            return 1
+        if not landing_problem(planted):
+            report(
+                f"{label}: pull request code could run with a write token — a "
+                f"`land` job that would land {why} was accepted."
+            )
+            return 1
+
+    # M3 — publish before tagging. A tag is what tells the next run "already
+    # released", so a tag created before a publish that then fails marks a version
+    # released that never reached npm, and nothing would ever retry it.
+    publish_step = workflow[workflow.index("      - name: Publish\n"):workflow.index("      - name: Tag and release the landed version\n")]
+    tag_step = workflow[workflow.index("      - name: Tag and release the landed version\n"):]
+    swapped = workflow.replace(publish_step + tag_step, tag_step.rstrip("\n") + "\n\n" + publish_step.rstrip("\n") + "\n")
+    if swapped == workflow:
+        report(f"{label}: a failed publish would be left tagged and never retried — the two steps could not be swapped.")
+        return 1
+    if not landing_problem(swapped):
+        report(
+            f"{label}: a failed publish would be left tagged and never retried — "
+            "a `publish` job that creates the release before `npm publish` was "
+            "accepted."
+        )
+        return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
 SCENARIOS: tuple = (
     ("stateless-continuity", validate_stateless_continuity_scenario),
     ("core-gates", validate_core_gates_scenario),
@@ -30195,6 +30560,14 @@ SCENARIOS: tuple = (
         "an-equivalence-claim-names-its-base",
         validate_an_equivalence_claim_names_its_base_scenario,
     ),
+    (
+        "the-repository-lands-what-passed",
+        validate_the_repository_lands_what_passed_scenario,
+    ),
+    (
+        "a-merge-names-who-makes-it",
+        validate_a_merge_names_who_makes_it_scenario,
+    ),
     (
         "a-publish-waits-for-the-one-before-it",
         validate_a_publish_waits_for_the_one_before_it_scenario,

package/src/core/config.js

@@ -82,6 +82,7 @@ const CONFIG_DECLARATIONS = [
   "delegation",
   "full_mode_paths",
   "executor_tier",
+  "merge",
 ];
 
 const CONFIG_RELATIVE_PATH = path.join("keel", "config.yaml");
@@ -452,6 +453,43 @@ function executorTierUnreadableMessage(value, accepted) {
   );
 }
 
+// Who merges into the default branch. Not an `authorize:` entry: that list says
+// what the *agent* may do without asking, and merging stays out of it — both the
+// host's classifier and this protocol refuse an agent merge. This key describes
+// the repository instead. Once a repository merges on its own rule, "the agent
+// may not merge" is literally true and misleading, because a reader concludes a
+// person looked at every change (#155). Keel reads the claim and never GitHub:
+// it stays local and offline, so the declaration is the owner's statement,
+// reported where Review can see it.
+function readMergeDeclaration(repo) {
+  const declared = configScalar(repo, "merge");
+  if (!declared) return { declared: false, kind: null, check: null, unknown: [] };
+  if (declared === "human") {
+    return { declared: true, kind: "human", check: null, unknown: [] };
+  }
+  const scoped = declared.match(/^repository:(\S+)$/);
+  if (scoped) {
+    return { declared: true, kind: "repository", check: scoped[1], unknown: [] };
+  }
+  // A bare `repository` is refused like a bare `issue`: "no person reviews this"
+  // without naming what does is the claim that misleads most. An unreadable value
+  // claims nothing — neither human review nor its absence.
+  return {
+    declared: true,
+    kind: null,
+    check: null,
+    unknown: [declared],
+    message:
+      `keel/config.yaml declares merge: ${declared}, which is not one of `
+      + "human, repository:<check>; nothing is claimed about how merges happen "
+      + "until it is corrected"
+      + (declared === "repository"
+        ? " — name the required check the repository merges on, because a claim "
+          + "that no person reviews is only honest beside what replaced them"
+        : ""),
+  };
+}
+
 function configScalar(repo, key) {
   const configPath = path.join(repo, "keel", "config.yaml");
   if (!fs.existsSync(configPath)) return null;
@@ -607,6 +645,7 @@ module.exports = {
   fullModePathsUnreadableMessage,
   readDelegationPolicy,
   readExecutorTier,
+  readMergeDeclaration,
   executorTierUnreadableMessage,
   readPrecedentStore,
   readStandingAuthorization,

package/src/core/context.js

@@ -16,6 +16,7 @@ const {
   readFullModePaths,
   fullModePathsUnreadableMessage,
   readExecutorTier,
+  readMergeDeclaration,
 } = require("./config");
 
 const NEXT_ACTIONS = new Set([
@@ -701,6 +702,12 @@ function resolveContext(repo, options) {
   // the default is the one a reader most needs to see, because a repository
   // that declared nothing is loading guidance it may not want and has no other
   // surface that would tell it so.
+  // Reported only when declared, like `full_mode_paths`: an absent declaration
+  // changes nothing, and Keel cannot know how an undeclared repository merges,
+  // so it must not print a line that implies it does.
+  const merge = readMergeDeclaration(repo);
+  if (merge.declared && merge.unknown.length === 0) context.merge = merge;
+  if (merge.unknown.length > 0) context.warnings.push(merge.message);
   const executor = readExecutorTier(repo);
   context.executorTier = executor.tier;
   if (executor.unknown.length > 0) context.warnings.push(executor.message);
@@ -757,6 +764,14 @@ function renderContext(result) {
   for (const entry of result.routing || []) {
     lines.push(`Routing: ${entry.path} always routes Full — ${entry.reason}`);
   }
+  if (result.merge) {
+    lines.push(
+      result.merge.kind === "repository"
+        ? `Merge: repository — the default branch merges when ${result.merge.check} `
+          + "passes; no human reviews before merge, so that check is the last gate"
+        : `Merge: ${result.merge.kind} — a person merges into the default branch`
+    );
+  }
   if (result.executorTier) {
     lines.push(
       `Executor tier: ${result.executorTier} — affects which skill guidance is `