@christang/keel 5.62.0 → 5.64.0

package/README.md

@@ -273,7 +273,27 @@ designed to — resist widening the policy until it stops happening.
 Use **Full mode** (the OpenSpec flow above) for new features, interface or protocol changes,
 cross-module work, or anything over ~3 files / 100 lines. Use **Lite mode** for local fixes,
 small scripts, docs, or tests with no interface change and locally provable impact; Lite does
-not write OpenSpec state.
+not write OpenSpec state. The rule is in the block `keel --init` installs, because routing is
+the first decision of a session and a rule reachable only from this README is reachable only by
+an agent that already went looking.
+
+The size bar is a proxy for risk, not risk itself, and some repositories invert it: an
+append-only record whose schema change is a one-field diff can be the highest-risk change in the
+project, and a mechanical rename across twenty files the lowest. Declare the paths the heuristic
+gets wrong, each with the reason it is wrong:
+
+```yaml
+full_mode_paths:
+  - results/experiments.jsonl: append-only; a one-field diff is not revertible
+```
+
+`keel context` reports what is declared, so the exception arrives at the decision, and
+`keel --doctor` reports the declaration's health. There is deliberately **no key for the
+opposite direction**: every declaration in that file removes a confirmation and never a gate, and
+an entry that held work *out* of the flow would be the first to break that. Keel gates no routing
+decision either — routing decides whether a change exists, so there is nothing for a gate to bind
+to; what Keel does is make sure the rule and your exceptions are in front of the agent when it
+decides.
 
 ## How the agent uses these
 
@@ -283,8 +303,9 @@ command at the right moment. Three things make that happen.
 
 - **The protocol.** `keel --init` writes a bootstrap block into your repo's `AGENTS.md`
   (imported by `CLAUDE.md` on Claude). It states the rules the agent follows: open every
-  session with `keel context`, pass the gates at task boundaries, and stay inside the task's
-  declared write scope. That is how the agent knows *when* to run what.
+  session with `keel context`, route the work Full or Lite, pass the gates at task boundaries,
+  and stay inside the task's declared write scope. That is how the agent knows *when* to run
+  what.
 - **The skills.** The `keel-*` execution skills and the `/opsx:*` command overlays walk the
   agent through align → apply → review → complete, invoking the gates at each step.
 - **The hooks.** A SessionStart hook runs the continuity projection the moment a session
@@ -354,6 +375,45 @@ set — fails `task-start` by name rather than sitting in the contract doing not
 `Fails with:` marker that names no literal. To *write about* the marker in a check without declaring
 one, put it in inline code.
 
+#### A red can be honest and the check still immune
+
+A signature predicts the red of an **absent** feature. It says nothing about the red of a **broken**
+one, and the two can be unrelated. A consistency check asserting two tool outputs agree had a real
+red, a correct signature, a real green — and stayed green through a 1000× unit error, the one thing
+it existed to catch, because its tolerance carried a default absolute floor. The only way to find
+that is to put the defect in and watch.
+
+`Detects:` declares that injection — the mutation, and the failure it must produce:
+
+```
+- M1: `pytest tests/test_fmax.py` asserts synth fmax == sta fmax. Fails with: `AttributeError` Detects: `sed -i s/0.0005/0.5/ run_sta.py` -> `assert 5e-16 == 5e-13`
+```
+
+Completion requires that second literal in the check's `.detects` Evidence. Clauses chain, so a check
+may carry both — the example above is one check, one line.
+
+**Keel does not run the mutation and does not judge it.** It records the claim and puts it where
+review can see it, the same standing every other check result has. You can declare an injection any
+check would catch; what the clause buys is that you decided it before the run, and that editing it
+afterwards moves the fingerprint.
+
+A `(regression)` check **may** declare one, and is the best place for it: such a check has no honest
+red by construction, so an injection is the only thing that can show it is not vacuous.
+
+#### A number can claim to be a measurement
+
+`Basis:`, Evidence prose and `Findings` are free text, and a number in them reads the same whether it
+was measured, estimated, or remembered. `Measured:` binds one to the output behind it:
+
+```
+- M1: `node bench.js` reports the fanout load. Measured: `1799.9`
+```
+
+Completion requires that literal in the check's own `M<n>` Evidence — the entry holding the command
+and its output. Opt-in, and deliberately not a rule over every number: measured against this
+repository's archive, that rule would reach 847 inline-code spans, mostly version strings, counts,
+and quoted references that appear in no command output, and each would be a false stop.
+
 ## Domain lenses
 
 Keel's core is pure process; it ships no domain knowledge and no decisions of its own. Alongside

package/assets/bootstrap/AGENTS.md

@@ -1,9 +1,10 @@
-<!-- keel:start version=5.62.0 -->
+<!-- keel:start version=5.64.0 -->
 ## Keel Bootstrap
 
 - Start every session with `keel context`; OpenSpec artifacts and Git are the only durable authority — never native memory, goals, or transcripts.
 - Obey the selected task capsule: `keel gate task-start` before implementing, `--record` its fingerprint to Evidence `Contract`, which `task-complete` requires, before checking complete. Touch bounds product writes; the change's own dir is exempt. On Claude a passing `task-start` guards it by default (`--no-guard` opts out).
 - One current agent owns writes; helpers return read-only report/evidence only. No commit, sync, or archive without explicit authorization.
+- Route Full (the OpenSpec flow) for new features, interface or protocol changes, cross-module work, or over ~3 files / 100 lines; Lite for local fixes with no interface change. No gate checks routing; a project corrects the size bar with `full_mode_paths:` in `keel/config.yaml`, which `keel context` reports.
 - Native plugin projections (SessionStart context) are disposable views, never authority; without the plugin or hook, run the commands manually.
 - Keel skills and hooks come from the `keel` native plugin (`codex plugin add` / `claude plugin install`); `keel --init` owns only the OpenSpec schema, overlays, and this bootstrap.
 <!-- keel:end -->

package/bin/keel.js

@@ -48,6 +48,8 @@ const {
   STANDING_AUTHORIZATION_ACTIONS,
   readPrecedentStore,
   readStandingAuthorization,
+  readFullModePaths,
+  fullModePathsUnreadableMessage,
   readTriagePolicy,
   triageIssue,
 } = require("../src/core/config");
@@ -1728,6 +1730,7 @@ function runDoctor(options) {
   const authorizationOk = printStandingAuthorizationSurface(repo);
   printPrecedentSurface(repo);
   printTriageSurface(repo);
+  printRoutingSurface(repo);
   printFastPrePushSurface(repo);
   printSourceRepoCliResolution(repo);
 
@@ -1820,6 +1823,38 @@ function printStandingAuthorizationSurface(repo) {
   return true;
 }
 
+function printRoutingSurface(repo) {
+  process.stdout.write("\nFull/Lite routing:\n");
+  const { paths, unreadable } = readFullModePaths(repo);
+  if (unreadable.length > 0) {
+    // Same verdict the projection reaches, from the same read: a diagnostic
+    // that reported health while `keel context` reported the conservative
+    // state would leave a reader to pick which one to believe.
+    printDoctorLine(
+      "full_mode_paths",
+      "failed",
+      `${fullModePathsUnreadableMessage(unreadable)} Every change routes Full `
+        + "until it is corrected."
+    );
+    return;
+  }
+  if (paths.length === 0) {
+    printDoctorLine(
+      "full_mode_paths",
+      "none",
+      "undeclared; routing follows the size heuristic alone"
+    );
+    return;
+  }
+  printDoctorLine(
+    "full_mode_paths",
+    "ok",
+    `declared in keel/config.yaml: ${paths.length} `
+      + `${paths.length === 1 ? "path always routes" : "paths always route"} Full`
+  );
+  for (const entry of paths) printDoctorLine(entry.path, "Full", entry.reason);
+}
+
 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.62.0",
+  "version": "5.64.0",
   "license": "MIT",
   "repository": {
     "type": "git",

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

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