@christang/keel 5.65.0 → 5.67.0

package/README.md

@@ -295,6 +295,34 @@ decision either — routing decides whether a change exists, so there is nothing
 to; what Keel does is make sure the rule and your exceptions are in front of the agent when it
 decides.
 
+### How much guidance the agent loads
+
+Keel's skills carry two kinds of content, and their value moves in opposite directions. *How to do it*
+— how to split a task, what order to run things in — matters less the stronger the executor is. *Make
+yourself falsifiable* — red then green, the failure literal a check predicts, the fingerprint, whether
+a `Durable owner:` reference actually exists — matters more, because a strong executor produces
+confident work and those are the checks that can contradict it.
+
+So the stepwise half of a skill lives in a `guidance.md` beside it, and a repository can say it does
+not need that half:
+
+```yaml
+executor_tier: high
+```
+
+The default is `standard`, which reads the guidance; an absent or misspelled declaration reads it too,
+so the worst an unconfigured repository does is pay for a read. `keel context` and `keel --doctor`
+report the tier.
+
+**The tier reaches guidance and nothing else** — no gate, criterion, evidence requirement, or Review
+changes with it. That is not a promise in this README: a guidance file is checked to contain none of
+the words Keel states criteria in, so a tier can only ever skip a file that decides nothing. Deciding
+what to skip is a declaration rather than the agent's own call on purpose — "do I need this help?" is
+the judgement a weak executor gets most wrong, and it would be answering it about itself.
+
+One skill is split today, `keel-run-single-task-goal`, and its body is 11% smaller for it. The other
+five are almost entirely criteria, so splitting them would move the half that has to stay.
+
 ## How the agent uses these
 
 You rarely type the commands below. The point of Keel is that the discipline runs itself:

package/assets/bootstrap/AGENTS.md

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

@@ -49,6 +49,7 @@ const {
   readPrecedentStore,
   readStandingAuthorization,
   readFullModePaths,
+  readExecutorTier,
   fullModePathsUnreadableMessage,
   readTriagePolicy,
   triageIssue,
@@ -1731,6 +1732,7 @@ function runDoctor(options) {
   printPrecedentSurface(repo);
   printTriageSurface(repo);
   printRoutingSurface(repo);
+  printExecutorTierSurface(repo);
   printFastPrePushSurface(repo);
   printSourceRepoCliResolution(repo);
 
@@ -1855,6 +1857,24 @@ function printRoutingSurface(repo) {
   for (const entry of paths) printDoctorLine(entry.path, "Full", entry.reason);
 }
 
+// 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.
+function printExecutorTierSurface(repo) {
+  process.stdout.write("\nExecutor tier:\n");
+  const { declared, tier, unknown, message } = readExecutorTier(repo);
+  if (unknown.length > 0) {
+    printDoctorLine("executor_tier", "unreadable", message);
+    return;
+  }
+  printDoctorLine(
+    "executor_tier",
+    tier,
+    (declared ? "declared in keel/config.yaml" : "undeclared; the default")
+      + " - affects which skill guidance is read and nothing else"
+  );
+}
+
 function printTriageSurface(repo) {
   process.stdout.write("\nUnattended triage:\n");
   const { labels, issues, unreadable } = readTriagePolicy(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.65.0",
+  "version": "5.67.0",
   "license": "MIT",
   "repository": {
     "type": "git",

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

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.65.0",
+  "version": "5.67.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.65.0",
+  "version": "5.67.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-run-single-task-goal/SKILL.md

@@ -13,16 +13,13 @@ metadata:
 
 Activate a native goal or subagent runtime to execute exactly one authorized OpenSpec task end to end, while OpenSpec, Git, the task-capsule fingerprint, and deterministic Keel gates stay the only durable authority. The current agent remains the sole holder of write authority and owns Review, gate invocation, the task checkbox, and completion. Where delegation is declared, an authorized delegate may write inside the `Touch` boundary that authority already defined and acquires none of those decisions; the current agent re-runs each `M<n>` check itself before recording Evidence, because a delegate's reported result is a claim and the byte-identity check that validates a read-only helper cannot apply to a writer. A native evaluator declaring success never marks or reports the task complete.
 
-## Authoritative sources and provenance
+## Guidance
 
-These official runtime docs are linked as authoritative references, not copied. Their text and trademarks belong to their owners; Keel paraphrases only the activation semantics it needs and bundles none of their prose.
+Read `guidance.md` beside this file before proceeding, unless `keel/config.yaml` declares `executor_tier: high` — it holds the runtime references, the manual sequence, and the per-target detail. Every criterion is here, so an absent or unreadable declaration costs a read and nothing else.
 
-- Codex goal-following: https://learn.chatgpt.com/use-cases/follow-goals
-- Codex subagents: https://developers.openai.com/codex/subagents
-- Claude goal execution: https://code.claude.com/docs/en/goal
-- Claude subagents: https://code.claude.com/docs/en/sub-agents
+## License
 
-License note: this skill is distributed under the Keel package license (UNLICENSED, all rights reserved by the author). Linking the official docs does not relicense them; do not paste their content into Keel artifacts.
+License note: the Keel package license (UNLICENSED, all rights reserved by the author). Linking the official runtime docs relicenses nothing; their provenance is recorded beside the links and their content is never pasted into Keel artifacts.
 
 ## When to activate
 
@@ -60,9 +57,8 @@ Helpers are optional, read-only evidence producers and never a second writer. Co
 
 ## Manual fallback
 
-When native activation is unavailable — no plugin, disabled hooks, managed policy, missing trust, or an unsupported surface — do not fake activation. Run the same lifecycle by hand: `keel gate task-start`, `keel project goal ... --json` for the view, implement, surface evidence, `keel gate task-complete`, then check the box. The manual loop preserves the identical single-task lifecycle and stop boundary.
+When native activation is unavailable, do not fake activation: run the identical lifecycle by hand. The manual loop preserves the same single-task boundary and the same stop boundary; its steps are in `guidance.md`.
 
 ## Target activation
 
-- Codex: where a callable goal/subagent surface exists, activate one bounded goal for the selected task and use subagents only as bounded read-only helpers. Without a callable surface, paste the exact `keel project goal` command and treat the capability as advisory.
-- Claude: activate one `/goal` whose condition stays within the 4,000-character budget; the evaluator is transcript-only, so surface command and gate evidence explicitly. If hooks are disabled, policy blocks activation, or trust is missing, report the manual fallback.
+Claude and Codex only. Activate exactly one bounded goal for the selected task; a native evaluator declaring success never marks or reports the task complete. The per-target detail is in `guidance.md`.

package/plugins/keel/skills/keel-run-single-task-goal/guidance.md

@@ -0,0 +1,30 @@
+# keel-run-single-task-goal — guidance
+
+How to carry out the lifecycle. Every criterion is in `SKILL.md`; nothing here decides whether a task
+may start, pass, or complete.
+
+## Authoritative runtime references
+
+Provenance: linked, not copied. Their text and trademarks belong to their owners, and Keel paraphrases
+only the activation semantics it needs. License note: see `SKILL.md`.
+
+- Codex goal-following: https://learn.chatgpt.com/use-cases/follow-goals
+- Codex subagents: https://developers.openai.com/codex/subagents
+- Claude goal execution: https://code.claude.com/docs/en/goal
+- Claude subagents: https://code.claude.com/docs/en/sub-agents
+
+## Running the lifecycle by hand
+
+Native activation can be unavailable — no plugin, disabled hooks, managed policy, missing trust, or an
+unsupported surface. Type the same numbered steps `SKILL.md` lists, in the same order: `keel gate task-start`, record the
+fingerprint, `keel project goal … --json` for the view, implement inside `Touch`, surface every result
+in the transcript, `keel gate task-complete`, check the box. What changes is who types them.
+
+## Per-target activation notes
+
+- **Codex**: where a callable goal or subagent surface exists, activate one bounded goal for the
+  selected task and use subagents only as bounded read-only helpers. Without a callable surface, paste
+  the exact `keel project goal` command and treat the capability as advisory.
+- **Claude**: activate one `/goal` whose condition fits the 4,000-character budget. The evaluator sees
+  the transcript only, so command and gate evidence has to appear there explicitly. If hooks are
+  disabled, policy blocks activation, or trust is missing, the manual sequence above applies.

package/scripts/validate_plugin.py

@@ -38,8 +38,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.65.0"
-PROTOCOL_VERSION = "5.65.0"
+PACKAGE_VERSION = "5.67.0"
+PROTOCOL_VERSION = "5.67.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
@@ -14396,6 +14396,27 @@ def validate_native_plugin_manifests_scenario() -> int:
                 f"source: {skill_name}"
             )
             return 1
+        # A referenced `guidance.md` travels with the body that names it. The
+        # host reads the plugin copy directly, so a guidance file the parity
+        # check ignored could drift from the criteria it was split out of, and
+        # the drift would be invisible to everything except a reader.
+        canonical_guidance = canonical_skill.parent / "guidance.md"
+        plugin_guidance = plugin_skill.parent / "guidance.md"
+        if canonical_guidance.is_file() and not plugin_guidance.is_file():
+            report(
+                "native-plugin-manifests guidance file diverges from canonical "
+                f"source: {skill_name} has guidance.md that the plugin does not "
+                "ship, so the body's reference resolves to nothing"
+            )
+            return 1
+        if canonical_guidance.is_file() and plugin_guidance.read_text(
+            encoding="utf-8"
+        ) != canonical_guidance.read_text(encoding="utf-8"):
+            report(
+                "native-plugin-manifests guidance file diverges from canonical "
+                f"source: {skill_name}"
+            )
+            return 1
     lenses_root = ROOT / "assets/lenses"
     for template in ("web.md", "hardware.md", "hardware-dsl.md"):
         if not (lenses_root / template).is_file():
@@ -17027,6 +17048,42 @@ STANDING_AUTHORIZATION_ACTIONS = (
 )
 
 
+def run_node_expression(root: Path, expression: str) -> str:
+    """Evaluate a Node expression with `root` as the working directory.
+
+    The declaration set is read from the module that defines it rather than by
+    regexing its source: a regex over the source would be a second copy of the
+    same literal the check exists to remove, one level down (issue #143).
+    """
+    result = subprocess.run(
+        ["node", "-e", expression],
+        cwd=root,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        capture_output=True,
+        check=False,
+    )
+    return result.stdout
+
+
+def config_header_problem(names: list, flat_header: 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.
+    """
+    for name in names:
+        if name not in flat_header:
+            return (
+                f"keel/config.yaml's header does not name the `{name}` "
+                "declaration, so a project reading it would never learn it may "
+                "write one. Add it to the header's list."
+            )
+    return ""
+
+
 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")
@@ -18117,11 +18174,27 @@ def validate_delegation_resident_text_scenario() -> int:
     # M1 — the config header counts its declarations correctly.
     config = ROOT / "keel/config.yaml"
     cfg = flat(config)
-    if re.sub(r"\s+", " ", "Five independent declarations") in cfg:
-        report("delegation-resident-text: the config header still says five declarations.")
+    # Derived from the module that reads the declarations, not restated here. The
+    # literal this replaces had been hand-bumped twice, and the second bump was
+    # found by a red suite run in a scenario named for something else (#143).
+    declarations = [
+        name
+        for name in run_node_expression(
+            ROOT,
+            "process.stdout.write("
+            "require('./src/core/config.js').CONFIG_DECLARATIONS.join(','))",
+        ).strip().split(",")
+        if name
+    ]
+    if not declarations:
+        report(
+            "delegation-resident-text: src/core/config.js exports no declaration "
+            "list, so the header cannot be checked against what Keel reads."
+        )
         return 1
-    if re.sub(r"\s+", " ", "Six independent declarations") not in cfg:
-        report("delegation-resident-text: the config header does not name six declarations.")
+    header_problem = config_header_problem(declarations, cfg)
+    if header_problem:
+        report(f"delegation-resident-text: {header_problem}")
         return 1
     if "delegation" not in cfg:
         report("delegation-resident-text: the config header does not document delegation.")
@@ -20640,6 +20713,15 @@ def validate_native_goal_capabilities_scenario() -> int:
     return 0
 
 
+# The referenced half of a split skill. Returns "" for a skill with one body, so
+# every assertion about a skill's content reads the same shape whether or not it
+# was split — a split must not be able to drop a required statement, and a
+# scenario must not have to know which skills were split to stay correct.
+def skill_guidance_text(skill_md: Path) -> str:
+    guidance = skill_md.parent / "guidance.md"
+    return guidance.read_text(encoding="utf-8") if guidance.is_file() else ""
+
+
 SINGLE_TASK_GOAL_SKILL = "keel-run-single-task-goal"
 OFFICIAL_GOAL_SOURCES = (
     "https://learn.chatgpt.com/use-cases/follow-goals",
@@ -20659,7 +20741,13 @@ def validate_single_task_goal_skill_scenario() -> int:
     if canonical_bytes != projection.read_bytes():
         report("single-task-goal-skill projection is not byte-equal to the canonical source.")
         return 1
-    text = canonical_bytes.decode("utf-8")
+    # A skill split into a body and a referenced `guidance.md` carries its
+    # content across both files. What these assertions require is that the skill
+    # states the thing, not that SKILL.md does, so the split must not be able to
+    # drop a required statement by moving it — and must not be able to keep one
+    # only in a file the plugin does not ship, which `native-plugin-manifests`
+    # checks byte-for-byte alongside the body.
+    text = canonical_bytes.decode("utf-8") + skill_guidance_text(canonical)
 
     # Authoritative official sources are linked, and provenance/license is recorded.
     for source in OFFICIAL_GOAL_SOURCES:
@@ -20864,8 +20952,9 @@ def _goal_target_surface(target: str) -> int:
             return 1
 
         # The skill carries the target-specific fallback guidance.
-        skill_text = (ROOT / "plugins/keel/skills" / SINGLE_TASK_GOAL_SKILL / "SKILL.md").read_text(
-            encoding="utf-8"
+        skill_body = ROOT / "plugins/keel/skills" / SINGLE_TASK_GOAL_SKILL / "SKILL.md"
+        skill_text = skill_body.read_text(encoding="utf-8") + skill_guidance_text(
+            skill_body
         )
         if target == "claude" and "disabled hooks" not in skill_text.lower():
             report("native-goal-claude skill lacks the disabled-hooks fallback.")
@@ -28591,6 +28680,368 @@ def validate_a_negation_is_not_a_marker_scenario() -> int:
     return 0
 
 
+def validate_a_count_is_derived_from_what_it_counts_scenario() -> int:
+    """Issue #143: the header assertion restated a set as an English numeral.
+
+    It had been hand-bumped twice, and the second bump was discovered by a red
+    suite run in a scenario whose name has nothing to do with what was changed.
+    An assertion about a set belongs to the set: read it from the module that
+    defines it, and name the member that is missing rather than a count.
+    """
+    label = "a-count-is-derived-from-what-it-counts"
+
+    def declared_names(root: Path) -> list[str]:
+        result = run_node_expression(
+            root,
+            "process.stdout.write("
+            "require('./src/core/config.js').CONFIG_DECLARATIONS.join(','))",
+        )
+        return [name for name in result.strip().split(",") if name]
+
+    names = declared_names(ROOT)
+    if not names:
+        report(
+            f"{label}: the assertion is a literal — `src/core/config.js` exports "
+            "no declaration list, so nothing the header is checked against comes "
+            "from the code that reads it."
+        )
+        return 1
+    for expected in (
+        "fast_check",
+        "authorize",
+        "precedents",
+        "triage",
+        "delegation",
+        "full_mode_paths",
+    ):
+        if expected not in names:
+            report(
+                f"{label}: the exported declaration list omits {expected!r}, so "
+                f"the header is not checked for it; got {names!r}."
+            )
+            return 1
+
+    header = (ROOT / "keel/config.yaml").read_text(encoding="utf-8")
+    flat_header = re.sub(r"\s+", " ", header)
+    for name in names:
+        if name not in flat_header:
+            report(
+                f"{label}: keel/config.yaml's header does not name {name!r}, "
+                "which is the declaration a new project would never learn it may "
+                "write."
+            )
+            return 1
+
+    # 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)
+    if not missing:
+        report(
+            f"{label}: the assertion is a literal — a declaration absent from "
+            "the header produced no failure, so the check is not reading the "
+            "exported list."
+        )
+        return 1
+    if "invented_declaration" not in missing:
+        report(
+            f"{label}: the failure does not name the missing declaration; got "
+            f"{missing!r}."
+        )
+        return 1
+    if re.search(r"\b(?:four|five|six|seven)\b", missing, re.IGNORECASE):
+        report(
+            f"{label}: still says six declarations — the failure reports a "
+            f"count rather than the missing name; got {missing!r}."
+        )
+        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
+    # word here would reintroduce the literal this scenario exists to remove,
+    # one level down: adding `executor_tier` moved the header to "Seven" and the
+    # mutation stopped finding anything to vary.
+    miscounted, varied = re.subn(
+        r"\b\w+ independent declarations\b",
+        "Zero independent declarations",
+        flat_header,
+        count=1,
+    )
+    if not varied:
+        report(f"{label}: the header's prose count could not be located to vary it.")
+        return 1
+    if config_header_problem(names, miscounted):
+        report(
+            f"{label}: still says six declarations — a header naming all of them "
+            "while miscounting them in prose was refused."
+        )
+        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 validate_a_tier_declares_what_is_skipped_scenario() -> int:
+    """Issue #135: which guidance an executor skips is a declaration, not a judgement.
+
+    A strong executor gets no value from stepwise how-to prose and pays for it on
+    every activation. The report's own argument against letting the executor
+    decide is that "do I need this?" is the judgement it is worst at, so the skip
+    is written down by the repository. The tier reaches guidance and nothing else:
+    a reader who takes it for a relaxation of the gates is worse off than one who
+    never saw it, which is why every surface that reports it says so.
+    """
+    label = "a-tier-declares-what-is-skipped"
+
+    with tempfile.TemporaryDirectory(prefix="keel-tier-") 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 context(repo: Path) -> str:
+            return run_keel(repo, "context").stdout
+
+        # M1 — the declared tier is reported, an absent one reports the default,
+        # and both say guidance is all the tier reaches.
+        for name, body, expected in (
+            ("high", "fast_check: echo high\nexecutor_tier: high\n", "high"),
+            ("absent", "fast_check: echo absent\n", "standard"),
+        ):
+            repo = fixture(name, body)
+            out = context(repo)
+            line = next(
+                (l for l in out.splitlines() if l.startswith("Executor tier:")), None
+            )
+            if line is None:
+                report(
+                    f"{label}: no executor tier reported — the {name} repository "
+                    "is told nothing about which guidance its skills load."
+                )
+                report(out)
+                return 1
+            if expected not in line:
+                report(
+                    f"{label}: the {name} repository reports {line!r} rather than "
+                    f"the {expected!r} tier."
+                )
+                return 1
+            if "guidance" not in line:
+                report(
+                    f"{label}: no executor tier reported as affecting guidance "
+                    f"only; {line!r} leaves a reader free to take it for a "
+                    "relaxation of the gates."
+                )
+                return 1
+
+        # M2 — a value Keel cannot read fails closed to reading the guidance.
+        # The author of a typo believes they declared what they typed, so a
+        # misspelling must not silently buy the skip it asked for, and the
+        # refusal names the value and the alternatives rather than the key.
+        typo = fixture("typo", "fast_check: echo typo\nexecutor_tier: aggressive\n")
+        out = context(typo)
+        line = next(
+            (l for l in out.splitlines() if l.startswith("Executor tier:")), None
+        )
+        if line is None:
+            report(
+                f"{label}: accepted a tier outside the set — the projection "
+                "reported no tier at all for an unreadable value, so the "
+                "fallback is invisible."
+            )
+            report(out)
+            return 1
+        if "standard" not in line:
+            report(
+                f"{label}: accepted a tier outside the set — an unreadable value "
+                f"did not fall back to reading the guidance; got {line!r}."
+            )
+            report(out)
+            return 1
+        if "aggressive" not in out:
+            report(
+                f"{label}: the rejected value is not named, so the author is "
+                "left believing they declared what they typed."
+            )
+            report(out)
+            return 1
+        if "high" not in out:
+            report(
+                f"{label}: the refusal does not name the accepted tiers, so the "
+                "reader learns their value is wrong and not what is right."
+            )
+            report(out)
+            return 1
+        doctor = run_keel(typo, "--doctor").stdout
+        if "executor_tier" not in doctor or "aggressive" not in doctor:
+            report(
+                f"{label}: the doctor does not report the declaration as failed "
+                "and name the entry, so it reports health the projection "
+                "contradicts."
+            )
+            report(doctor)
+            return 1
+        healthy = run_keel(fixture("ok", "executor_tier: high\n"), "--doctor").stdout
+        if "executor_tier: high" not in healthy:
+            report(
+                f"{label}: the doctor does not report a readable declaration, so "
+                "the only tier it ever mentions is a broken one."
+            )
+            report(healthy)
+            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
+
+
+# The words Keel states a criterion in. A guidance file is asserted to contain
+# none of them, which is what makes "the executor tier removes no criterion" a
+# property of the repository rather than a promise in a design document: a tier
+# can only skip a file that decides nothing.
+CRITERION_VOCABULARY = ("MUST", "SHOULD", "refuses", "rejects", "hard-stops")
+
+
+def guidance_criterion_problem(name: str, text: str) -> str | None:
+    """Return the problem a guidance file's text has, or None.
+
+    Takes the text rather than reading the path, so the rule can be exercised on
+    a planted copy. A rule that could only ever see files already known to be
+    clean would pass forever without anyone learning whether it fires.
+    """
+    for word in CRITERION_VOCABULARY:
+        if word in text:
+            return (
+                f"{name}'s guidance.md states a criterion — it contains "
+                f"{word!r}, and a criterion in the file the executor tier skips "
+                "would let `executor_tier: high` relax a rule rather than skip "
+                "an explanation. Move the sentence back into SKILL.md."
+            )
+    return None
+
+
+def validate_guidance_is_referenced_and_carries_no_criterion_scenario() -> int:
+    """Issue #135: stepwise guidance is referenced, and it decides nothing.
+
+    Keel is not on the delivery path for a skill body — the host reads
+    `plugins/keel/skills/*/SKILL.md` directly — so the only way the resident cost
+    falls is for the body to be smaller. What leaves it is how-to prose; every
+    criterion stays, and that is checked here by planting one rather than
+    promised, because a tier that could remove a criterion would be a relaxation
+    of the gates wearing a capability label.
+    """
+    label = "guidance-is-referenced-and-carries-no-criterion"
+    skills_root = ROOT / "src/skills"
+    guidance_files = sorted(skills_root.glob("*/guidance.md"))
+
+    # D4 splits exactly one skill today. An empty glob would satisfy every loop
+    # below without reading anything, so the count is asserted first.
+    if not guidance_files:
+        report(
+            f"{label}: no skill has a guidance.md, so every assertion below is "
+            "vacuous — the split this scenario checks did not happen."
+        )
+        return 1
+
+    for guidance in guidance_files:
+        skill = guidance.parent / "SKILL.md"
+        body = skill.read_text(encoding="utf-8")
+        text = guidance.read_text(encoding="utf-8")
+        if "guidance.md" not in body:
+            report(
+                f"{label}: guidance file is not referenced — "
+                f"{guidance.parent.name}'s SKILL.md never names guidance.md, so "
+                "the prose that left the body is unreachable from it."
+            )
+            return 1
+        if "executor_tier" not in body:
+            report(
+                f"{label}: {guidance.parent.name}'s SKILL.md names guidance.md "
+                "without the condition under which it is read, which leaves the "
+                "skip to the executor's own judgement — the judgement #135 says "
+                "it gets most wrong."
+            )
+            return 1
+        if "high" not in body:
+            report(
+                f"{label}: {guidance.parent.name}'s SKILL.md does not name the "
+                "tier that skips the read, so the condition it states cannot be "
+                "evaluated."
+            )
+            return 1
+        # "Measurably smaller than before the split" is checkable only as a
+        # property of what is on disk now: the guidance carries real content,
+        # and that content is no longer duplicated in the body it left.
+        if len(text) < 500:
+            report(
+                f"{label}: {guidance.parent.name}'s guidance.md holds "
+                f"{len(text)} bytes, too few for the split to have moved "
+                "anything; a pointer to an almost-empty file costs a read and "
+                "saves nothing."
+            )
+            return 1
+        criterion = guidance_criterion_problem(guidance.parent.name, text)
+        if criterion:
+            report(f"{label}: {criterion}")
+            return 1
+        for heading in [
+            line for line in text.splitlines() if line.startswith("## ")
+        ]:
+            if heading in body:
+                report(
+                    f"{label}: {guidance.parent.name}'s body still carries "
+                    f"{heading!r}, so the section was copied rather than moved "
+                    "and the resident cost did not fall."
+                )
+                return 1
+
+    # M2 — the property is held by the suite, not promised by the design. A
+    # guidance file that stated a criterion would let the tier skip one, which
+    # would make `executor_tier: high` a relaxation of the gates wearing a
+    # capability label. Planting one is the only way to know the rule fires.
+    sample = guidance_files[0]
+    planted = (
+        sample.read_text(encoding="utf-8")
+        + "\nAn executor MUST record the fingerprint before implementing.\n"
+    )
+    problem = guidance_criterion_problem(sample.parent.name, planted)
+    if not problem:
+        report(
+            f"{label}: states a criterion — a guidance file carrying `MUST` was "
+            "accepted, so nothing stops a criterion from moving into the file "
+            "the tier skips."
+        )
+        return 1
+    if sample.parent.name not in problem:
+        report(
+            f"{label}: the refusal does not name the file that states the "
+            f"criterion; got {problem!r}."
+        )
+        return 1
+    if "MUST" not in problem:
+        report(
+            f"{label}: the refusal does not name the word it objected to, so the "
+            f"author has to guess which sentence to move; got {problem!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
+
+
 SCENARIOS: tuple = (
     ("stateless-continuity", validate_stateless_continuity_scenario),
     ("core-gates", validate_core_gates_scenario),
@@ -28953,6 +29404,18 @@ SCENARIOS: tuple = (
         "a-negation-is-not-a-marker",
         validate_a_negation_is_not_a_marker_scenario,
     ),
+    (
+        "guidance-is-referenced-and-carries-no-criterion",
+        validate_guidance_is_referenced_and_carries_no_criterion_scenario,
+    ),
+    (
+        "a-tier-declares-what-is-skipped",
+        validate_a_tier_declares_what_is_skipped_scenario,
+    ),
+    (
+        "a-count-is-derived-from-what-it-counts",
+        validate_a_count_is_derived_from_what_it_counts_scenario,
+    ),
 )
 
 

package/src/core/config.js

@@ -68,6 +68,22 @@ function classifyAuthorizationEntry(entry) {
 // and the declaration must still be correct after both.
 const DELEGATION_TIERS = ["routine", "standard", "deep"];
 
+// Every declaration this module reads, in the order the file documents them. One
+// list, so an assertion about the set can be derived from the set instead of
+// restating it: the header check used to pin an English numeral and had been
+// hand-bumped twice, each time discovered by a red suite run in a scenario named
+// for something else (issue #143). Adding a declaration now costs a header line
+// and an entry here, and nothing has to agree about a number.
+const CONFIG_DECLARATIONS = [
+  "fast_check",
+  "authorize",
+  "precedents",
+  "triage",
+  "delegation",
+  "full_mode_paths",
+  "executor_tier",
+];
+
 const CONFIG_RELATIVE_PATH = path.join("keel", "config.yaml");
 
 // The declarations share keel/config.yaml with fast_check, so the reader stays
@@ -387,6 +403,55 @@ function readDelegationPolicy(repo) {
   return { declared: true, tier, unknown: [], accepted };
 }
 
+// Which guidance an executor loads, declared by the repository rather than
+// judged by the executor. #135's argument is that "do I need this help?" is the
+// judgement a weak executor gets most wrong, so the skip is written down; the
+// absent default therefore reads the guidance, and the worst an unconfigured
+// repository does is pay for a read.
+const EXECUTOR_TIERS = ["standard", "high"];
+const EXECUTOR_TIER_DEFAULT = "standard";
+
+// The tier reaches guidance and nothing else. It is a separate key from
+// `delegation:`'s tier on purpose: that one names who runs a *delegated* task,
+// and a repository may hand routine work to a weak delegate while its own
+// session is strong, so one field cannot answer both without lying about one.
+function readExecutorTier(repo) {
+  const declared = configScalar(repo, "executor_tier");
+  const accepted = [...EXECUTOR_TIERS];
+  if (!declared) {
+    return {
+      declared: false,
+      tier: EXECUTOR_TIER_DEFAULT,
+      unknown: [],
+      accepted,
+    };
+  }
+  // Fail closed, the same rule `delegation:` and `authorize:` follow — except
+  // that closed here means *reading* the guidance rather than skipping it. A
+  // misspelling must not silently buy the reduction it asked for.
+  if (!EXECUTOR_TIERS.includes(declared)) {
+    return {
+      declared: true,
+      tier: EXECUTOR_TIER_DEFAULT,
+      unknown: [declared],
+      accepted,
+      message: executorTierUnreadableMessage(declared, accepted),
+    };
+  }
+  return { declared: true, tier: declared, unknown: [], accepted };
+}
+
+// Names the value and the alternatives, never just the key: a reader told their
+// declaration is wrong without being told what is right has to go find the
+// documentation the declaration was supposed to replace.
+function executorTierUnreadableMessage(value, accepted) {
+  return (
+    `keel/config.yaml declares executor_tier: ${value}, which is not one of `
+    + `${accepted.join(", ")}; the ${EXECUTOR_TIER_DEFAULT} tier applies until `
+    + "it is corrected, so skill guidance is read rather than skipped"
+  );
+}
+
 function configScalar(repo, key) {
   const configPath = path.join(repo, "keel", "config.yaml");
   if (!fs.existsSync(configPath)) return null;
@@ -533,11 +598,16 @@ function triageIssue(repo, labels, issue = null) {
 module.exports = {
   CONFIG_RELATIVE_PATH,
   DELEGATION_TIERS,
+  EXECUTOR_TIERS,
+  EXECUTOR_TIER_DEFAULT,
+  CONFIG_DECLARATIONS,
   STANDING_AUTHORIZATION_ACTIONS,
   SCOPED_AUTHORIZATION_ACTIONS,
   readFullModePaths,
   fullModePathsUnreadableMessage,
   readDelegationPolicy,
+  readExecutorTier,
+  executorTierUnreadableMessage,
   readPrecedentStore,
   readStandingAuthorization,
   readTriagePolicy,

package/src/core/context.js

@@ -15,6 +15,7 @@ const {
   readStandingAuthorization,
   readFullModePaths,
   fullModePathsUnreadableMessage,
+  readExecutorTier,
 } = require("./config");
 
 const NEXT_ACTIONS = new Set([
@@ -696,6 +697,14 @@ function resolveContext(repo, options) {
   } else {
     context.routing = routing.paths;
   }
+  // Reported every session, declared or not, unlike `full_mode_paths` above:
+  // 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.
+  const executor = readExecutorTier(repo);
+  context.executorTier = executor.tier;
+  if (executor.unknown.length > 0) context.warnings.push(executor.message);
+
   // Set here rather than by the caller, so every consumer of the projection —
   // text, JSON, and any host reading it — carries the version without having
   // to know to add it.
@@ -748,6 +757,13 @@ function renderContext(result) {
   for (const entry of result.routing || []) {
     lines.push(`Routing: ${entry.path} always routes Full — ${entry.reason}`);
   }
+  if (result.executorTier) {
+    lines.push(
+      `Executor tier: ${result.executorTier} — affects which skill guidance is `
+        + "read and nothing else; no gate, criterion, evidence requirement, or "
+        + "Review changes with it"
+    );
+  }
   for (const reason of result.reasons) lines.push(`Reason: ${reason}`);
   for (const warning of result.warnings) lines.push(`Warning: ${warning}`);
   return `${lines.join("\n")}\n`;