@christang/keel 5.4.0 → 5.5.0

package/README.md

@@ -125,6 +125,36 @@ Set `KEEL_SESSION_PANEL=1` to draw it as a framed panel with the Keel mark inste
 default, and turning it on changes nothing but the presentation — the same status and the same
 next command are in both forms.
 
+### Standing authorization
+
+Keel asks before a repository action it has no authority for, and it asks again next session,
+because a permission granted in conversation does not survive a context reset. Declare it once in
+`keel/config.yaml` instead:
+
+```yaml
+authorize:          # accepted names: commit, push, release, archive
+  - commit
+  - push
+```
+
+A task that authors no `Autonomy boundary:` inherits the declaration, and the compiled capsule
+names `keel/config.yaml` as that entry's source so an inherited authorization is never mistaken
+for one the task decided. A task that authors its own boundary keeps it.
+
+Three things the declaration is not:
+
+- **Not a way past a gate.** It authorizes the action, never the proof. `keel gate task-complete`
+  returns exactly the same verdict, and the same failure text, whether or not you declared
+  anything.
+- **Not a trigger.** It removes a confirmation, not the step that reaches the action. Nothing
+  schedules itself, and no next task is selected for you.
+- **Not open-ended.** The four names above are the whole vocabulary. An unrecognized entry is
+  reported with the accepted names and the declaration authorizes nothing until you fix it — a
+  typo never becomes a silent grant.
+
+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.
+
 ### Full vs Lite
 
 Use **Full mode** (the OpenSpec flow above) for new features, interface or protocol changes,
@@ -160,7 +190,8 @@ Keel splits verification into two layers so a slow suite never blocks your push:
   run at CI or at `keel gate change-close`.
 
 A task's `Verify` checks stay fast; the slow or exhaustive layer belongs to the full gate, not the
-local pre-push. Declare your fast check once in `keel/config.yaml`:
+local pre-push. Declare your fast check in `keel/config.yaml`, the same file that holds your
+standing authorization:
 
 ```yaml
 fast_check: npm test -- --fast   # your project's seconds-scale check

package/assets/bootstrap/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- keel:start version=5.4.0 -->
+<!-- keel:start version=5.5.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/assets/openspec/schemas/keel-spec-driven/schema.yaml

@@ -126,8 +126,12 @@ artifacts:
       Keel agent. Keel-managed work executes in the current agent conversation;
       do not hand execution to another agent, subagent, or operator unless the
       selected task or user explicitly authorizes it.
-      Autonomy boundary defaults to hard-stop. A pre-authorized fallback must
-      state an exact reversible bound and the evidence required after use.
+      Autonomy boundary defaults to hard-stop for every action the repository
+      has not standing-authorized in `keel/config.yaml`; a declared action is
+      inherited only by a task that authored no boundary of its own, and the
+      capsule names the declaration as that entry's source. A pre-authorized
+      fallback must state an exact reversible bound and the evidence required
+      after use.
 
       Use `Coupling: none` by default. When `Coupling: required`, define one
       complete candidate, its allowed provisional failures, completion gate,

package/assets/openspec/schemas/keel-spec-driven/templates/tasks.md

@@ -2,10 +2,14 @@
      Record only task-specific authority. Omitted fields inherit versioned
      defaults: Owner is the current Keel agent, Mode is implementation, Read
      is the change proposal/design/specs/tasks plus discovered repository
-     context, Acceptance derives from Covers, autonomy defaults to hard-stop,
-     Coupling defaults to none, helpers stay read-only/evidence-only, and
-     commit, push, sync, archive, and cross-task continuation stay
-     unauthorized. Declare a field only when it differs from these defaults. -->
+     context, Acceptance derives from Covers, Coupling defaults to none, and
+     helpers stay read-only/evidence-only. Autonomy defaults to hard-stop, and
+     commit, push, sync, archive, and cross-task continuation stay unauthorized,
+     EXCEPT where `keel/config.yaml` standing-authorizes an action: a task that
+     authors no `Autonomy boundary:` inherits that declaration, and the capsule
+     names the declaration as the entry's source. A standing authorization
+     removes the confirmation, never the gate, evidence, or Review.
+     Declare a field only when it differs from these defaults. -->
 
 ## 1. <!-- Task Group Name -->
 

package/bin/keel.js

@@ -44,6 +44,10 @@ const {
   renderGuard,
   startGuard,
 } = require("../src/core/guard");
+const {
+  STANDING_AUTHORIZATION_ACTIONS,
+  readStandingAuthorization,
+} = require("../src/core/config");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const PACKAGE_JSON = require(path.join(PACKAGE_ROOT, "package.json"));
@@ -1033,6 +1037,8 @@ function keelOpenSpecOverlay(action) {
           "- When implementation exposes a material expectation, acceptance boundary, or user-owned decision absent from durable authority, stop before implementing that choice, rerun `keel-align-expectations`, and reauthor the affected proposal/design/spec/task authority first.",
           "- A discovered repository fact that does not change accepted behavior or scope may be recorded and execution continues inside the existing task boundary without a product interview.",
           "- Invoke OpenSpec through `keel openspec` (for example `keel openspec validate`); a bare `openspec` command may not be on PATH.",
+          "- Consult the repository's standing authorization in `keel/config.yaml` before asking the user to confirm a repository action: a standing-authorized action proceeds without a per-occurrence confirmation, and an undeclared action still requires the confirmation it requires today.",
+          "- A standing authorization covers the action and never substitutes for a gate, evidence, or Review; it removes the confirmation, not the record, and it is not a trigger to perform the action.",
         ]
       : [
           "- The current agent owns final sync/archive decisions and must verify task evidence, follow-up ownership, and completion gates before proceeding.",
@@ -1043,6 +1049,8 @@ function keelOpenSpecOverlay(action) {
           "- Invoke OpenSpec through `keel openspec` (for example `keel openspec validate`); a bare `openspec` command may not be on PATH.",
           "- When `/opsx:sync` has already promoted the change's spec delta, run the archive with `--skip-specs` so the promoted delta is not re-applied; archive is not idempotent over an already-synced delta.",
           "- After archiving, run `keel guard clear` to drop the change's guard manifest; the read-only gate never clears it for you.",
+          "- A repository that standing-authorizes `archive` in `keel/config.yaml` does not need the per-occurrence archive confirmation; a repository that declares nothing still needs it.",
+          "- The completion gate and follow-up ownership checks still run unchanged under a standing authorization; it removes the confirmation, not the proof.",
         ];
 
   const lines = [
@@ -1344,10 +1352,11 @@ function runDoctor(options) {
 
   printTargetSurface(repo, options.target);
   printLensSurface(repo, options.target);
+  const authorizationOk = printStandingAuthorizationSurface(repo);
   printFastPrePushSurface(repo);
   printSourceRepoCliResolution(repo);
 
-  return checkStatus;
+  return authorizationOk ? checkStatus : 1;
 }
 
 // Only meaningful in Keel's own repository: a bare `keel` resolves to the
@@ -1390,6 +1399,37 @@ function gitConfigHooksPath(repo) {
   return value || null;
 }
 
+function printStandingAuthorizationSurface(repo) {
+  process.stdout.write("\nStanding authorization:\n");
+  const { declared, unknown } = readStandingAuthorization(repo);
+  if (unknown.length > 0) {
+    printDoctorLine(
+      "authorize",
+      "failed",
+      `keel/config.yaml declares unrecognized ${
+        unknown.length === 1 ? "action" : "actions"
+      }: ${unknown.join(", ")}; accepted names are `
+        + `${STANDING_AUTHORIZATION_ACTIONS.join(", ")}. The whole declaration `
+        + "authorizes nothing until it is corrected"
+    );
+    return false;
+  }
+  printDoctorLine(
+    "authorize",
+    declared.length > 0 ? "ok" : "none",
+    declared.length > 0
+      ? `declared in keel/config.yaml: ${declared.join(", ")}`
+      : "undeclared; every action stays hard-stop"
+  );
+  for (const action of STANDING_AUTHORIZATION_ACTIONS) {
+    printDoctorLine(
+      action,
+      declared.includes(action) ? "authorized" : "not authorized"
+    );
+  }
+  return true;
+}
+
 function printFastPrePushSurface(repo) {
   process.stdout.write("\nFast pre-push surface:\n");
   const fastCheck = readFastCheck(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.4.0",
+  "version": "5.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",

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

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.4.0",
+  "version": "5.5.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.4.0",
+  "version": "5.5.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

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.4.0"
-PROTOCOL_VERSION = "5.4.0"
+PACKAGE_VERSION = "5.5.0"
+PROTOCOL_VERSION = "5.5.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
@@ -2087,6 +2087,12 @@ def assert_openspec_overlay(path: Path, action: str) -> str | None:
                 "source expectations",
                 "Rough future slices",
                 "cannot mark tasks complete",
+                # A confirmation the owner already declared is routed to the
+                # declaration; one they did not declare is still asked for, and
+                # neither case touches the proof.
+                "standing-authorized action proceeds without",
+                "undeclared action still requires",
+                "never substitutes for a gate",
             ]
         )
     else:
@@ -2098,6 +2104,8 @@ def assert_openspec_overlay(path: Path, action: str) -> str | None:
                 "durable follow-up owner",
                 "explicit discard reason",
                 "cannot archive, sync, change acceptance, or bypass completion gates",
+                "standing-authorizes `archive`",
+                "completion gate and follow-up ownership checks still run",
             ]
         )
     for snippet in required:
@@ -11111,6 +11119,405 @@ def validate_verification_layering_docs_scenario() -> int:
     return 0
 
 
+STANDING_AUTHORIZATION_ACTIONS = ("commit", "push", "release", "archive")
+
+
+def write_authorize_config(repo: Path, body: str) -> None:
+    (repo / "keel").mkdir(parents=True, exist_ok=True)
+    (repo / "keel" / "config.yaml").write_text(body, encoding="utf-8")
+
+
+def validate_standing_authorization_declaration_scenario() -> int:
+    with tempfile.TemporaryDirectory(prefix="keel-authorize-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — a declared action is authorized; an undeclared one is not.
+        declared = root / "declared"
+        declared.mkdir()
+        write_authorize_config(
+            declared,
+            "fast_check: echo declared-check\n"
+            "authorize:\n"
+            "  - commit\n"
+            "  - push\n",
+        )
+        out = run_keel(declared, "--doctor").stdout
+        if "Standing authorization:" not in out:
+            report("standing-authorization: doctor has no standing authorization surface.")
+            report(out)
+            return 1
+        for needle in ("commit: authorized", "push: authorized"):
+            if needle not in out:
+                report(f"standing-authorization: declared action not reported: {needle}")
+                report(out)
+                return 1
+        for needle in ("release: not authorized", "archive: not authorized"):
+            if needle not in out:
+                report(f"standing-authorization: undeclared action not reported: {needle}")
+                report(out)
+                return 1
+
+        # M2 — absent, blockless, and empty declarations all authorize nothing,
+        # and none of them disturbs the fast_check surface that shares the file.
+        absent = root / "absent"
+        absent.mkdir()
+        blockless = root / "blockless"
+        blockless.mkdir()
+        write_authorize_config(blockless, "fast_check: echo blockless-check\n")
+        empty = root / "empty"
+        empty.mkdir()
+        write_authorize_config(
+            empty, "fast_check: echo empty-check\nauthorize:\n"
+        )
+        for repo, label, fast in (
+            (absent, "absent", None),
+            (blockless, "blockless", "echo blockless-check"),
+            (empty, "empty", "echo empty-check"),
+        ):
+            out = run_keel(repo, "--doctor").stdout
+            if "authorize: none" not in out:
+                report(
+                    f"standing-authorization: {label} repo does not report an "
+                    "undeclared authorization surface."
+                )
+                report(out)
+                return 1
+            if "authorized" in out.replace("not authorized", ""):
+                report(
+                    f"standing-authorization: {label} repo reports an authorized action."
+                )
+                report(out)
+                return 1
+            expected_fast = f"fast_check: ok - declared in keel/config.yaml: {fast}"
+            if fast is not None and expected_fast not in out:
+                report(
+                    f"standing-authorization: {label} repo lost its fast_check line."
+                )
+                report(out)
+                return 1
+            if fast is None and "fast_check: none" not in out:
+                report("standing-authorization: absent repo lost its fast_check line.")
+                report(out)
+                return 1
+
+        # M3 — an unrecognized name is reported with the accepted set, exits
+        # non-zero, and authorizes nothing that sits beside it.
+        unknown = root / "unknown"
+        unknown.mkdir()
+        write_authorize_config(
+            unknown,
+            "authorize:\n  - commit\n  - deploy\n",
+        )
+        result = run_keel(unknown, "--doctor")
+        combined = result.stdout + result.stderr
+        if result.returncode == 0:
+            report("standing-authorization: an unrecognized action name exited zero.")
+            report(combined)
+            return 1
+        if "deploy" not in combined:
+            report("standing-authorization: the error does not name the offending entry.")
+            report(combined)
+            return 1
+        for action in STANDING_AUTHORIZATION_ACTIONS:
+            if action not in combined:
+                report(
+                    "standing-authorization: the error does not name accepted "
+                    f"action {action}."
+                )
+                report(combined)
+                return 1
+        if "commit: authorized" in combined:
+            report(
+                "standing-authorization: a rejected declaration still authorized "
+                "the entry beside the bad one."
+            )
+            report(combined)
+            return 1
+
+    report("standing-authorization-declaration scenario passed.")
+    return 0
+
+
+def standing_authorization_task(boundary: str = "") -> str:
+    return (
+        "- [ ] 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"
+        + boundary
+        + "  - Evidence:\n"
+        "    - Contract: pending\n"
+        "    - M1: pending\n"
+        "    - Review:\n"
+        "      - Status: pending\n"
+        "      - Acceptance check: pending\n"
+        "      - Scope check: pending\n"
+        "      - Findings: pending\n"
+        "    - Blocker: none\n"
+    )
+
+
+def standing_authorization_autonomy(repo: Path) -> list[str] | None:
+    result = run_keel(
+        repo,
+        "gate",
+        "task-start",
+        "--change",
+        "demo",
+        "--task",
+        "1.1",
+        "--json",
+        "--no-guard",
+    )
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    contract = payload.get("contract") or {}
+    capsule = contract.get("capsule") or {}
+    boundaries = capsule.get("boundaries") or {}
+    return boundaries.get("autonomy")
+
+
+def validate_standing_authorization_inheritance_scenario() -> int:
+    with tempfile.TemporaryDirectory(prefix="keel-authinherit-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — a task that authored no boundary inherits the declaration, and
+        # the capsule says where the authorization came from.
+        inherits = root / "inherits"
+        inherits.mkdir()
+        write_gate_fixture(inherits, standing_authorization_task())
+        write_authorize_config(inherits, "authorize:\n  - commit\n")
+        autonomy = standing_authorization_autonomy(inherits)
+        if autonomy is None:
+            report("standing-authorization-inheritance: task-start returned no capsule autonomy.")
+            return 1
+        inherited = [entry for entry in autonomy if "commit" in entry]
+        if not inherited:
+            report(
+                "standing-authorization-inheritance: a declared action did not "
+                f"reach the capsule autonomy boundary: {autonomy}"
+            )
+            return 1
+        if not any("keel/config.yaml" in entry for entry in inherited):
+            report(
+                "standing-authorization-inheritance: the inherited entry does "
+                f"not name the repository declaration as its source: {autonomy}"
+            )
+            return 1
+
+        # M2 — an authored boundary is returned unchanged, with nothing
+        # inherited beside it.
+        authored = root / "authored"
+        authored.mkdir()
+        write_gate_fixture(
+            authored,
+            standing_authorization_task(
+                "  - Autonomy boundary:\n"
+                "    - Default: hard-stop\n"
+                "    - Pre-authorized fallback: revert the fixture file and record M1\n"
+            ),
+        )
+        write_authorize_config(authored, "authorize:\n  - commit\n  - push\n")
+        autonomy = standing_authorization_autonomy(authored)
+        if autonomy is None:
+            report("standing-authorization-inheritance: authored-boundary task did not compile.")
+            return 1
+        if "Pre-authorized fallback: revert the fixture file and record M1" not in autonomy:
+            report(
+                "standing-authorization-inheritance: the authored boundary was "
+                f"not preserved: {autonomy}"
+            )
+            return 1
+        if any("keel/config.yaml" in entry for entry in autonomy):
+            report(
+                "standing-authorization-inheritance: the declaration overrode an "
+                f"authored boundary: {autonomy}"
+            )
+            return 1
+
+        # M3 — an action the declaration does not name still hard-stops.
+        autonomy = standing_authorization_autonomy(inherits)
+        if autonomy is None:
+            report("standing-authorization-inheritance: re-compilation returned no autonomy.")
+            return 1
+        if any("push" in entry or "release" in entry for entry in autonomy):
+            report(
+                "standing-authorization-inheritance: an undeclared action was "
+                f"authorized: {autonomy}"
+            )
+            return 1
+        if not any(entry.startswith("Default: hard-stop") for entry in autonomy):
+            report(
+                "standing-authorization-inheritance: the hard-stop default "
+                f"disappeared for undeclared actions: {autonomy}"
+            )
+            return 1
+
+    report("standing-authorization-inheritance scenario passed.")
+    return 0
+
+
+def validate_standing_authorization_never_weakens_scenario() -> int:
+    """A declaration removes a confirmation. It must not remove a proof.
+
+    Every check here compares an authorizing repository against an identical
+    one that declares nothing. The declaration is proven inert on the gate
+    result, on the failure text, and on continuity selection — the three places
+    a reader might otherwise assume authorization had bought something.
+    """
+
+    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 []
+            ),
+        }
+
+    def pair(root: Path, name: str, tasks: str) -> tuple[Path, Path]:
+        authorizing = root / f"{name}-authorizing"
+        authorizing.mkdir()
+        write_gate_fixture(authorizing, tasks)
+        write_authorize_config(
+            authorizing,
+            "authorize:\n  - commit\n  - push\n  - release\n  - archive\n",
+        )
+        silent = root / f"{name}-silent"
+        silent.mkdir()
+        write_gate_fixture(silent, tasks)
+        # Positive control. Every check below compares these two repositories
+        # and passes when they agree, so a declaration that silently failed to
+        # reach the capsule would make each comparison trivially true and prove
+        # nothing. Assert the difference exists before asserting it is inert.
+        live = standing_authorization_autonomy(authorizing) or []
+        inert = standing_authorization_autonomy(silent) or []
+        if not any("keel/config.yaml" in entry for entry in live):
+            report(
+                f"standing-authorization-inert: the {name} authorizing fixture "
+                f"never actually authorized anything: {live}"
+            )
+            raise AssertionError("authorizing fixture is not authorizing")
+        if any("keel/config.yaml" in entry for entry in inert):
+            report(
+                f"standing-authorization-inert: the {name} silent fixture "
+                f"declared something: {inert}"
+            )
+            raise AssertionError("silent fixture is not silent")
+        return authorizing, silent
+
+    with tempfile.TemporaryDirectory(prefix="keel-authinert-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — completion returns the same status and problem set either way.
+        authorizing, silent = pair(root, "complete", complete_task)
+        for repo in (authorizing, silent):
+            if gate_result(repo, "task-start") is None:
+                report("standing-authorization-inert: task-start produced no JSON.")
+                return 1
+        authorized_result = gate_result(authorizing, "task-complete")
+        silent_result = gate_result(silent, "task-complete")
+        if authorized_result is None or silent_result is None:
+            report("standing-authorization-inert: task-complete produced no JSON.")
+            return 1
+        if authorized_result != silent_result:
+            report(
+                "standing-authorization-inert: a declaration changed the "
+                f"completion gate result: {authorized_result} != {silent_result}"
+            )
+            return 1
+
+        # M2 — a repo authorizing every action still fails for missing evidence,
+        # with unchanged failure text.
+        authorizing, silent = pair(root, "missing", missing_evidence_task)
+        for repo in (authorizing, silent):
+            if gate_result(repo, "task-start") is None:
+                report("standing-authorization-inert: task-start produced no JSON.")
+                return 1
+        authorized_result = gate_result(authorizing, "task-complete")
+        silent_result = gate_result(silent, "task-complete")
+        if authorized_result is None or silent_result is None:
+            report("standing-authorization-inert: task-complete produced no JSON.")
+            return 1
+        if authorized_result.get("status") == "pass":
+            report(
+                "standing-authorization-inert: authorizing every action let a "
+                "task with missing evidence pass completion."
+            )
+            return 1
+        if authorized_result != silent_result:
+            report(
+                "standing-authorization-inert: a declaration changed the failure "
+                f"text: {authorized_result} != {silent_result}"
+            )
+            return 1
+
+        # M3 — a declaration selects nothing and starts nothing.
+        def continuity(repo: Path) -> dict | None:
+            result = run_keel(repo, "context", "--json")
+            try:
+                payload = json.loads(result.stdout)
+            except json.JSONDecodeError:
+                return None
+            return {
+                "status": payload.get("status"),
+                "selection": payload.get("selection"),
+                "nextAction": payload.get("nextAction"),
+            }
+
+        authorizing, silent = pair(root, "context", complete_task)
+        authorized_context = continuity(authorizing)
+        silent_context = continuity(silent)
+        if authorized_context is None or silent_context is None:
+            report("standing-authorization-inert: keel context produced no JSON.")
+            return 1
+        if authorized_context != silent_context:
+            report(
+                "standing-authorization-inert: a declaration changed continuity "
+                f"selection: {authorized_context} != {silent_context}"
+            )
+            return 1
+
+    report("standing-authorization-never-weakens scenario passed.")
+    return 0
+
+
 def validate_fast_check_config_scaffold_scenario() -> int:
     with tempfile.TemporaryDirectory(prefix="keel-fastcfg-") as raw_tmp:
         repo = Path(raw_tmp)
@@ -14491,6 +14898,18 @@ SCENARIOS: tuple = (
     ("update-pack-install", validate_update_pack_install_scenario),
     ("update-default-registry", validate_update_default_registry_scenario),
     ("verification-layering-docs", validate_verification_layering_docs_scenario),
+    (
+        "standing-authorization-declaration",
+        validate_standing_authorization_declaration_scenario,
+    ),
+    (
+        "standing-authorization-inheritance",
+        validate_standing_authorization_inheritance_scenario,
+    ),
+    (
+        "standing-authorization-never-weakens",
+        validate_standing_authorization_never_weakens_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

@@ -0,0 +1,49 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+// The closed vocabulary of actions a repository may standing-authorize. It is
+// closed so an entry outside it can be reported by name: a free-form grant
+// cannot tell a typo from a decision, and silently dropping one leaves the
+// author believing they authorized something they did not.
+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
+// line-oriented rather than pulling in a YAML dependency for a format Keel
+// controls and keeps flat on purpose.
+function readStandingAuthorization(repo) {
+  const configPath = path.join(repo, "keel", "config.yaml");
+  const declared = [];
+  const unknown = [];
+  if (!fs.existsSync(configPath)) return { declared, unknown };
+  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)) {
+      inBlock = true;
+      continue;
+    }
+    if (!inBlock) continue;
+    if (line.trim() === "") continue;
+    const entry = line.match(/^\s+-\s*(\S+)\s*$/);
+    // 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]);
+  }
+  // Fail closed. A declaration Keel cannot fully read authorizes nothing,
+  // because the alternative is granting the entries beside a typo while the
+  // author believes they granted the typo too.
+  if (unknown.length > 0) return { declared: [], unknown };
+  return { declared, unknown };
+}
+
+module.exports = {
+  CONFIG_RELATIVE_PATH,
+  STANDING_AUTHORIZATION_ACTIONS,
+  readStandingAuthorization,
+};

package/src/core/task-contract.js

@@ -4,6 +4,11 @@ const crypto = require("crypto");
 const fs = require("fs");
 const path = require("path");
 
+const {
+  CONFIG_RELATIVE_PATH,
+  readStandingAuthorization,
+} = require("./config");
+
 const SUPPORTED_MODES = new Set([
   "implementation",
   "diagnose-only",
@@ -844,6 +849,20 @@ function compileTaskContract(repo, change, task) {
   if (!autonomy.some((item) => /^Default:/i.test(item))) {
     autonomy.unshift("Default: hard-stop");
   }
+  // A repository declaration supplies the default a task did not author; it
+  // never edits one the task did, because a repository-wide default that could
+  // override a task's stated boundary would make the capsule unreadable on its
+  // own. The entry names its source so an inherited authorization is never
+  // mistaken for one this task decided.
+  if (explicitAutonomy.length === 0) {
+    const { declared } = readStandingAuthorization(repo);
+    if (declared.length > 0) {
+      autonomy.push(
+        `Standing authorization (${CONFIG_RELATIVE_PATH.split(path.sep).join("/")}): `
+          + declared.join(", ")
+      );
+    }
+  }
   if (!autonomy.some((item) => /^Pre-authorized fallback:/i.test(item))) {
     autonomy.push("Pre-authorized fallback: none");
   }