canon-ai 3.6.0 → 3.8.0

package/CHANGELOG.md

@@ -4,6 +4,23 @@
 
 ## [Unreleased]
 
+## [3.8.0] — 2026-10-07
+
+### Changed
+
+- **`/canon-spec-review`'s factual reviewer now runs on Haiku.** The reviewer that checks a spec's paths, symbols, and signatures against the code now runs on `haiku`. Its work is lookups, so the smaller model is enough and costs less. The shape and spec-quality reviewers still use your session's model. Run `canon upgrade`, then start a new Claude Code session to pick it up.
+
+## [3.7.0] — 2026-10-06
+
+### Added
+
+- **`canon task set <id> human_spec_gate true|false` arms or disarms the human spec gate.** You no longer need to hand-edit `status.json`. Arming the gate on a full-send task also clears `full_send`, because the gate never fires on a full-send task, and prints how to turn full-send back on (`canon run --full-send <id>`). If the task's `spec_review` is already done, it prints a note that the gate fires again only after a full-tier `canon run --reroute <id>`. Disarming is refused on delicate tasks; `canon run --full-send --force <id>` is still the only way to skip the gate there. `canon task new` now points at `canon task set` instead of telling you to edit `status.json`.
+
+### Changed
+
+- **The `full_send` refusal message now says how the flag clears.** It stays in `status.json` until `--reroute` or arming the spec gate clears it.
+- **The npm package's homepage now links to <https://timothystraub.com/canon>.**
+
 ## [3.6.0] — 2026-10-04
 
 ### Changed

package/dist/cli/index.js

@@ -1224,7 +1224,7 @@ function checkTemplates(cwd) {
 }
 function checkCanonVersion(cwd) {
   const versionPath = join(cwd, ".canon", "version");
-  const installedVersion = "3.6.0";
+  const installedVersion = "3.8.0";
   if (!existsSync(versionPath)) {
     return { label: ".canon/version", status: "warn", detail: "missing \u2014 run `canon upgrade`" };
   }
@@ -1721,7 +1721,7 @@ function initCmd(_args) {
 }
 function writeCanonVersion(cwd) {
   const versionPath = join2(cwd, ".canon", "version");
-  const version = "3.6.0";
+  const version = "3.8.0";
   mkdirSync(dirname2(versionPath), { recursive: true });
   writeFileSync(versionPath, version + "\n");
 }
@@ -2731,7 +2731,7 @@ function isInstalledSourcePath(sourcePath) {
   return sourcePath.includes("/node_modules/") || sourcePath.includes("\\node_modules\\") || sourcePath.includes("/_npx/") || sourcePath.includes("\\_npx\\");
 }
 function resolveCanonVersion(explicit) {
-  return explicit ?? "3.6.0" ?? "dev";
+  return explicit ?? "3.8.0" ?? "dev";
 }
 function resolveOrchestratorCommit(repoRoot, upstreamCommit, runGitAt) {
   const ownToplevel = captureGitOutput(repoRoot, ["rev-parse", "--show-toplevel"], runGitAt);
@@ -3447,17 +3447,21 @@ function rescaffoldReview(taskDir, identity) {
   }
 }
 
+// src/lib/pipeline-policy.ts
+function isPlanCombined(task) {
+  return task.task_size === "XS" && !(task.delicate ?? false);
+}
+
 // src/task/index.ts
 var VALID_PHASES = new Set(PHASE_ORDER);
 var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "done", "changes_requested", "blocked"]);
 var VALID_VERDICTS = /* @__PURE__ */ new Set(["approved", "approved_with_nits", "changes_requested", "needs_re_review", "spec_gap", "sanctioned"]);
 var REVIEW_PHASES = /* @__PURE__ */ new Set(["spec_review", "code_review"]);
-var SETTABLE_FIELDS = ["title", "task_size", "delicate", "worktree", "base_branch"];
+var SETTABLE_FIELDS = ["title", "task_size", "delicate", "worktree", "base_branch", "human_spec_gate"];
 var SETTABLE_FIELD_SET = new Set(SETTABLE_FIELDS);
 var IMMUTABLE_FIELDS = /* @__PURE__ */ new Set(["id", "created", "updated"]);
 var REDIRECT_MESSAGES = {
-  full_send: "a per-run stance, not durable metadata. Use `canon run --full-send <id>`, which also clears the spec gate and enforces the delicate\u2192`--force` guard.",
-  human_spec_gate: "the spec gate is self-clearing. Re-run `canon run <id>` to proceed past it, or use `canon run --full-send <id>` to skip it entirely.",
+  full_send: "persisted in status.json until `canon run --reroute` clears it or arming the gate with `canon task set <id> human_spec_gate true` does. Use `canon run --full-send <id>` to enable it; the delicate-task guard requires `--force`.",
   status: "derived from phase states. Use `canon task phase <id> <phase> <status>`.",
   branch: "load-bearing git identity; retargeting it desyncs the worktree. Not settable via `canon task set`.",
   phases: "nested orchestrator-owned state. Use `canon task phase`, `canon task reset-spec-review`, `canon task reset-code-review`, or `canon task accept` instead.",
@@ -3568,7 +3572,7 @@ function listTemplateFiles() {
   }
   return fs14.readdirSync(root).filter((name) => name.endsWith(".md") || name.endsWith(".json")).sort();
 }
-function printCreatedTask(taskDir, baseBranch) {
+function printCreatedTask(taskId, taskDir, baseBranch) {
   console.log(`Created task: ${taskDir}`);
   console.log("Files:");
   for (const file of fs14.readdirSync(taskDir).sort()) {
@@ -3578,7 +3582,7 @@ function printCreatedTask(taskDir, baseBranch) {
   console.log(`Next: Write the spec in ${taskDir}/spec.md`);
   console.log("");
   console.log(`  Defaults: task_size=M, delicate=false, human_spec_gate=true, base_branch=${baseBranch}`);
-  console.log(`  Edit ${taskDir}/status.json to adjust before running the pipeline.`);
+  console.log(`  Adjust with: canon task set ${taskId} <field> <value>`);
 }
 function taskNew(args2) {
   let id = "";
@@ -3634,7 +3638,7 @@ function taskNew(args2) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`Warning: created task without canon snapshot refresh: ${message}`);
   }
-  printCreatedTask(taskDir, baseBranch);
+  printCreatedTask(id, taskDir, baseBranch);
 }
 function derivePhase(status) {
   return deriveTopLevelStatus(status);
@@ -4470,13 +4474,13 @@ function taskSetValue(taskId, field, value, status) {
         throw new Error("Error: title must be single-line (no embedded newlines).");
       }
       status.title = value;
-      return;
+      return [];
     case "task_size":
       if (!TASK_SIZE_VALUES.has(value)) {
         throw new Error(`Error: invalid task_size '${value}'. Must be one of: XS, S, M, L, XL.`);
       }
       status.task_size = value;
-      return;
+      return [];
     case "delicate":
     case "worktree": {
       const normalized = value.toLowerCase();
@@ -4484,7 +4488,26 @@ function taskSetValue(taskId, field, value, status) {
         throw new Error(`Error: invalid ${field} '${value}'. Must be true or false.`);
       }
       status[field] = normalized === "true";
-      return;
+      return [];
+    }
+    case "human_spec_gate": {
+      const normalized = value.toLowerCase();
+      if (normalized !== "true" && normalized !== "false") {
+        throw new Error(`Error: invalid ${field} '${value}'. Must be true or false.`);
+      }
+      if (normalized === "false") {
+        if (status.delicate === true) {
+          throw new Error(`Error: human_spec_gate cannot be disarmed on delicate task ${taskId}. Use \`canon run --full-send --force ${taskId}\` to skip the spec gate on a delicate task, or re-run \`canon run ${taskId}\` to proceed past a gate that already halted.`);
+        }
+        status.human_spec_gate = false;
+        return [];
+      }
+      status.human_spec_gate = true;
+      if (status.full_send === true) {
+        status.full_send = false;
+        return [`Note: full-send was cleared on task ${taskId} because arming the spec gate re-introduces a human checkpoint. Run \`canon run --full-send ${taskId}\` to re-enable it.`];
+      }
+      return [];
     }
     case "base_branch": {
       const trimmed = value.trim();
@@ -4493,7 +4516,7 @@ function taskSetValue(taskId, field, value, status) {
       }
       validateBranchField(trimmed, taskId, "base_branch");
       status.base_branch = trimmed;
-      return;
+      return [];
     }
     default:
       throw new Error(`Error: internal error \u2014 unsupported settable field '${field}'.`);
@@ -4502,6 +4525,16 @@ function taskSetValue(taskId, field, value, status) {
 function taskSetRedirectMessage(field) {
   return REDIRECT_MESSAGES[field] ?? "nested orchestrator-owned state. Use the owning canon task command instead.";
 }
+var REROUTE_ADMITTED_PHASES = /* @__PURE__ */ new Set(["code_review", "qa", "human_review"]);
+function specGateDoneNote(id, status) {
+  if (isPlanCombined(status)) {
+    return `Note: spec_review is already done on task ${id}. A fast-tier reroute skips spec_review, so the armed gate fires again only if this task is rerouted in a bundle with a full-tier task.`;
+  }
+  if (REROUTE_ADMITTED_PHASES.has(deriveTopLevelStatus(status))) {
+    return `Note: spec_review is already done on task ${id}. The armed gate fires after the next spec_review, which a full-tier reroute runs: add an amendment to the spec, then run \`canon run --reroute ${id}\`.`;
+  }
+  return `Note: spec_review is already done on task ${id}, so the armed gate will not fire on this pass. On a full-tier task it can fire again only if an amendment is rerouted once the task reaches code_review, qa, or human_review.`;
+}
 function taskHasStarted(status) {
   return Object.values(status.phases).some((entry) => (entry?.status ?? "pending") !== "pending");
 }
@@ -4527,10 +4560,16 @@ function taskSet(args2) {
     );
   }
   if (SETTABLE_FIELD_SET.has(field)) {
-    taskSetValue(id, field, value, status);
+    const notes = taskSetValue(id, field, value, status);
     status.updated = today();
     writeStatusAtomic(statusPath, status);
-    if (taskHasStarted(status)) {
+    for (const note of notes) console.log(note);
+    const specReviewDone = status.phases.spec_review?.status === "done";
+    if (field === "human_spec_gate" && specReviewDone) {
+      if (status.human_spec_gate === true) {
+        console.log(specGateDoneNote(id, status));
+      }
+    } else if (taskHasStarted(status)) {
       console.log(`Warning: ${field} on task ${id} takes effect on the next canon run.`);
     }
     return;
@@ -4538,9 +4577,6 @@ function taskSet(args2) {
   if (field === "full_send") {
     throw new Error(`Error: full_send is ${taskSetRedirectMessage(field)}`);
   }
-  if (field === "human_spec_gate") {
-    throw new Error(`Error: human_spec_gate is ${taskSetRedirectMessage(field)}`);
-  }
   if (field === "status") {
     throw new Error(`Error: status is ${taskSetRedirectMessage(field)}`);
   }
@@ -4857,7 +4893,7 @@ function currentPinFromManifest(manifest) {
   return "unknown";
 }
 function bakedVersion() {
-  return "3.6.0";
+  return "3.8.0";
 }
 function ownPackageName(pkgDir) {
   try {
@@ -5334,7 +5370,7 @@ function runUpgrade(cwd, pkgDir, options = {}) {
     cutoverWarnings.push(docsRefsCheckRel);
   }
   const versionPath = join5(cwd, ".canon", "version");
-  const newVersion = "3.6.0";
+  const newVersion = "3.8.0";
   const currentVersion = existsSync5(versionPath) ? readFileSync4(versionPath, "utf8").trim() : null;
   if (currentVersion !== newVersion) {
     pending.push({ rel: ".canon/version", projectPath: versionPath, content: newVersion + "\n" });
@@ -5642,7 +5678,7 @@ Global:
 `);
 }
 function printVersion() {
-  console.log("3.6.0");
+  console.log("3.8.0");
 }
 switch (command) {
   case "doctor":

package/dist/orchestrator/run-task.js

@@ -5205,7 +5205,7 @@ function isInstalledSourcePath(sourcePath) {
   return sourcePath.includes("/node_modules/") || sourcePath.includes("\\node_modules\\") || sourcePath.includes("/_npx/") || sourcePath.includes("\\_npx\\");
 }
 function resolveCanonVersion(explicit) {
-  return explicit ?? "3.6.0" ?? "dev";
+  return explicit ?? "3.8.0" ?? "dev";
 }
 function resolveOrchestratorCommit(repoRoot, upstreamCommit, runGitAt) {
   const ownToplevel = captureGitOutput(repoRoot, ["rev-parse", "--show-toplevel"], runGitAt);
@@ -5592,7 +5592,7 @@ var VALID_PHASES = new Set(PHASE_ORDER);
 var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "done", "changes_requested", "blocked"]);
 var VALID_VERDICTS = /* @__PURE__ */ new Set(["approved", "approved_with_nits", "changes_requested", "needs_re_review", "spec_gap", "sanctioned"]);
 var REVIEW_PHASES = /* @__PURE__ */ new Set(["spec_review", "code_review"]);
-var SETTABLE_FIELDS = ["title", "task_size", "delicate", "worktree", "base_branch"];
+var SETTABLE_FIELDS = ["title", "task_size", "delicate", "worktree", "base_branch", "human_spec_gate"];
 var SETTABLE_FIELD_SET = new Set(SETTABLE_FIELDS);
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canon-ai",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "type": "module",
   "description": "A spec-first, multi-agent AI coding pipeline you drop into any repo. The law your agents work under.",
   "engines": {
@@ -41,7 +41,7 @@
   },
   "license": "MIT",
   "author": "Tim Straub",
-  "homepage": "https://github.com/tstraub89/canon-ai#readme",
+  "homepage": "https://timothystraub.com/canon",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tstraub89/canon-ai.git"

package/templates/.claude/agents/spec-review-lens.md

@@ -10,7 +10,7 @@ Review the spec yourself and spawn no sub-agents.
 Invoke no skills.
 Write no files. Run no `canon` commands and ask the user nothing.
 Bash is read-only: search, list, print file ranges, and inspect read-only git history. Use no redirects, in-place edits, or state-changing git.
-Inherit the session's model and effort.
+Inherit the session's model and effort unless the dispatching call sets a model.
 
 Every finding cites `file:line` or an AC number. Re-open the current file before making any claim about code; do not rely on memory.
 

package/templates/.claude/skills/canon-spec/SKILL.md

@@ -128,13 +128,13 @@ After scope is approved:
    canon task new TASK-ID "Title"
    ```
 
-2. Edit `tasks/TASK-ID/status.json`: set `task_size`, `delicate`, and `human_spec_gate: true`.
+2. Set metadata with `canon task set TASK-ID task_size <XS|S|M|L|XL>` and `canon task set TASK-ID delicate <true|false>`. The spec gate defaults to armed for new tasks.
 
 3. Write `tasks/TASK-ID/spec.md` using `.canon/templates/spec.md` as structure. Fill every section — no placeholders, no "TBD".
    - If full-send mode is active, prepend this line immediately after the title block and before `## Problem`:
      `> **Full-send mode**: This spec was produced in full-send mode.`
 
-4. Set `spec.status` to `"done"` in `status.json`.
+4. Run `canon task phase TASK-ID spec done`.
 
 Self-check before presenting:
 - [ ] Every AC states exactly how to verify it (not just "it works")
@@ -184,7 +184,7 @@ Self-check before presenting:
    canon task phase TASK-ID spec_review done approved
    canon task phase TASK-ID plan done
    ```
-   Then set `human_spec_gate: false` in `status.json` (already cleared by the human's conversational approval).
+   Then run `canon task set TASK-ID human_spec_gate false` (already cleared by the human's conversational approval).
 4. Invoke the pipeline:
    ```bash
    canon run TASK-ID

package/templates/.claude/skills/canon-spec-review/SKILL.md

@@ -39,7 +39,7 @@ State briefly: task ID, size, delicate flag, "dispatching 3 parallel sub-agents.
 
 ### 2. Dispatch 3 sub-agents in one message
 
-Send a SINGLE message with three Agent tool calls so they run concurrently. Every call uses `subagent_type: spec-review-lens` and carries the full spec text inline, its angle, scope and rubric. Each lens returns cited findings in its own format. If the Agent tool rejects `spec-review-lens`, stop and tell the human to run `canon upgrade`, then start a new Claude Code session; do not fall back to another agent type.
+Send a SINGLE message with three Agent tool calls so they run concurrently. Every call uses `subagent_type: spec-review-lens` and carries the full spec text inline, its angle, scope and rubric. Agent B's call also passes `model: haiku`; its lookups are mechanical, while A and C need judgment and inherit the session model. Each lens returns cited findings in its own format. If the Agent tool rejects `spec-review-lens`, stop and tell the human to run `canon upgrade`, then start a new Claude Code session; do not fall back to another agent type.
 
 #### Agent A — Structural / shape
 

package/templates/docs/pipeline-orchestrator.md

@@ -117,7 +117,7 @@ canon task <subcommand> [args]
 | `status` | `<id>` | Print full `status.json` detail for a task. |
 | `phase` | `<id> <phase> <status> [verdict]` | Update a task phase and re-derive the top-level `status` pointer. Phases: `spec spec_review plan implement code_review qa human_review`. Status: `pending in_progress done changes_requested blocked`. |
 | `accept` | `<id...> <phase> [--reason "<text>"] [--force]` | Operator accept supports `implement`, `spec_review`, and `code_review`. For `implement`, it is the escape hatch for already-committed work: it marks implement done and sets `operator_accepted` so post-implement auto-commit is skipped when the recorded HEAD still matches. For `spec_review` and `code_review`, `--reason` is required; accept writes a `sanctioned` verdict for non-advancing review verdicts, preserves already-advancing verdicts in a blocked bundle, records `operator_accepted*`, and appends the audit reason to `notes.md`. Review accept intentionally skips the implement-only diff/handoff guards. |
-| `set` | `<id> <field> <value>` | Set flat task metadata with validation. Metadata fields `title`, `task_size`, and `delicate` remain settable whenever the task is reachable. Topology fields `worktree` and `base_branch` are only settable before `status.branch` is recorded; once branched, `set` rejects them and points operators at recreating the task or migrating `status.json` manually. Redirected: `full_send` → `canon run --full-send`; `human_spec_gate` → re-run `canon run`; `status` → `canon task phase`; `branch` → git identity, not `canon task set`; `phases`/`sessions`/`canon`/`escalations` → their owning canon task commands. Immutable: `id`, `created`, `updated`, and `_`-prefixed inline-doc keys. Writes warn after dispatch has started because metadata changes take effect on the next `canon run`. |
+| `set` | `<id> <field> <value>` | Set flat task metadata with validation. Metadata fields `title`, `task_size`, `delicate`, and `human_spec_gate` remain settable whenever the task is reachable; setting `human_spec_gate true` clears `full_send` with a note, while setting it `false` is refused on delicate tasks (use `canon run --full-send --force`). Topology fields `worktree` and `base_branch` are only settable before `status.branch` is recorded; once branched, `set` rejects them and points operators at recreating the task or migrating `status.json` manually. Redirected: `full_send` → `canon run --full-send` to enable it (it persists until `--reroute` clears it or arming the spec gate does); `status` → `canon task phase`; `branch` → git identity, not `canon task set`; `phases`/`sessions`/`canon`/`escalations` → their owning canon task commands. Immutable: `id`, `created`, `updated`, and `_`-prefixed inline-doc keys. Writes warn after dispatch has started because metadata changes take effect on the next `canon run`. |
 | `reset-spec-review` | `<id>` | Clear router-relevant state for a fresh spec-review pass after an auto-block. Zeroes iterations, clears verdict, archives the prior `spec-review.md`, and drops the stored `sessions.claude_spec` ID so the next pass runs against a fresh Claude spec session. |
 | `reset-code-review` | `<id>` | Clear router-relevant state for a fresh code-review pass after an auto-block. Zeroes the loop-local review counters, clears verdict, archives the prior `review.md` and re-scaffolds a fresh one from the task templates, and drops the stored `sessions.claude_review` ID so the next pass runs against a fresh Claude review session. |
 | `post-merge-sync` | `[<branch>]` | After a squash-merge PR, reconcile local branch with origin. Hard-resets if the only divergence is pipeline telemetry; refuses if real new work exists. |
@@ -185,7 +185,7 @@ Set in `status.json` at task creation:
 |---|---|---|
 | `task_size` | `XS \| S \| M \| L \| XL` | Drives the pipeline tier and effective-size model/effort cells for Codex and Claude. XS is fast-tier; S+ runs the full pipeline (including Codex spec review). |
 | `delicate` | `true \| false` | Forces the XL bucket (full Codex model and high Claude spec/plan/code-review effort) regardless of nominal size. Set when an undetected bug has materially harder-to-recover blast radius than a normal bug — common examples: auth, payments, premium gating, persistent storage migrations, security-sensitive cryptography. Project-specific surfaces also qualify (medical PHI, scientific reproducibility, regulated data). The bar is *blast radius*, not difficulty. |
-| `human_spec_gate` | `true \| false` | **Single-use latch**, not a persistent toggle. `true` arms a one-time halt after `spec_review`, before planning (default: `true`). The orchestrator flips it to `false` *at the moment it halts* — so `false` means "the gate already fired (or was pre-cleared)," not "review was skipped." See [Spec gate is a single-use latch](#spec-gate-is-a-single-use-latch). |
+| `human_spec_gate` | `true \| false` | **Single-use latch**, not a persistent toggle. `true` arms a one-time halt after `spec_review`, before planning (default: `true`). A human can re-arm it with `canon task set <id> human_spec_gate true`; setting it `false` on a delicate task is refused. The orchestrator flips it to `false` *at the moment it halts*, but a human can also disarm it, so `false` means "fired, pre-cleared, or disarmed," not proof the gate fired. See [Spec gate is a single-use latch](#spec-gate-is-a-single-use-latch). |
 | `worktree` | `true \| false` | Worktree isolation. `canon task new` scaffolds this to `true`, so worktree mode is the effective default for every scaffolded task — set it to `false` to opt out and run in the main checkout. The orchestrator treats an *absent* field as `false`, but that fallback only applies to hand-rolled `status.json` files. See Worktree Isolation below. |
 | `base_branch` | string (default `"main"`) | Branch the task branches off and PRs against. Auto-set by `canon task new` from the current git checkout at task creation. |
 
@@ -356,7 +356,7 @@ For projects that version their releases, changelog and version bump remain a ma
 
 `human_spec_gate` confuses operators because it looks like a persistent on/off setting and isn't. It is a **one-shot latch the orchestrator consumes the first time the pipeline reaches the gate.**
 
-The flip to `false` *is the gate firing* — it happens at the halt, **before** the human has reviewed, not after. Concretely, when the pipeline reaches the gate point with the latch armed, the orchestrator does three things in one step: (1) sets `human_spec_gate = false`, (2) prints the `✋ SPEC GATE` banner, (3) `process.exit(0)`. The reason it burns the latch *at* the halt is so the **next** `canon run <id>` — the one the human types after approving the spec — passes straight through instead of halting on the same gate forever.
+When the pipeline reaches the gate point with the latch armed, the orchestrator does three things in one step: (1) sets `human_spec_gate = false`, (2) prints the `✋ SPEC GATE` banner, (3) `process.exit(0)`. A human can also re-arm or disarm the latch with `canon task set`; disarming it on a delicate task is refused. The orchestrator consumes the latch at the halt so the **next** `canon run <id>` — the one the human types after approving the spec — passes straight through instead of halting on the same gate forever.
 
 Where the gate fires by tier:
 
@@ -364,7 +364,9 @@ Where the gate fires by tier:
 - **Full tier (S/M/L/XL/delicate)**: after Codex `spec_review` completes, before planning.
 - **`--full-send`**: pre-clears the latch to `false` at launch, so the gate never fires.
 
-So when you inspect `status.json` mid-pipeline and see `human_spec_gate: false`, read it as **"the gate already fired (or was pre-cleared) — review was *not* skipped"**, not "the halt was lost." There is no separate "gate satisfied" field; the consumed latch *is* the record that the gate fired. Re-running `canon run <id>` after the banner is the intended next move — it does not re-arm or re-fire the gate.
+On a full-tier reroute, an armed latch halts after the amendment's `spec_review`, unless that `spec_review` is closed with `canon task accept`, which is itself the human sign-off and skips the gate. A fast-tier reroute re-enters at `implement`, so it never reaches the gate. A reroute does not re-arm a consumed latch by itself; to halt after the amendment's review, run `canon task set <id> human_spec_gate true` before rerouting.
+
+So when you inspect `status.json` mid-pipeline and see `human_spec_gate: false`, read it as **"fired, pre-cleared, or disarmed"**; the value alone does not prove the gate fired or that review was not skipped. Re-running `canon run <id>` after the banner proceeds past the consumed latch.
 
 **Bundle rule**: the gate skip is all-or-nothing. One task in the bundle with the latch still armed re-engages the halt for the whole invocation; `--full-send` must apply to every task in the bundle to skip it.
 
@@ -470,7 +472,7 @@ The Stage 1 AC table is redone on round 2+. Earlier AC tables were snapshots of
 
 Write the new requirements into **`tasks/<id>/spec.md` in the active task directory** for every named task as an Amendment section — except on a spec_gap-entry reroute (every named task blocked at `code_review` with at least one `spec_gap` verdict), where only the `spec_gap` tasks need an Amendment section; approved or other non-gap siblings in the same bundle do not. If a worktree exists for the task, edit the worktree copy; edit REPO_ROOT only before the task has a worktree. `review.md` alone is not sufficient — Codex reads `spec.md` as the contract.
 
-Full-tier reroute (any S/M/L/XL task or any `delicate` task) re-enters at the same review altitude as the original spec — `spec_review` → `plan` → `implement` — regardless of which admitted phase (`code_review`, `qa`, or `human_review`) the task was rerouted from. Codex reviews the amendment in the context of the previously approved ACs and prior `spec-review.md`, without auditing `handoff.md`, `review.md`, or `done.md`. If the amendment is approved, the pipeline flows through to `plan` without re-arming the human spec gate; Claude appends a reroute plan section (`## Reroute Plan` or `## Reroute Plan Round N`) to `plan.md`; Codex then implements from the amendment plus that reroute plan.
+Full-tier reroute (any S/M/L/XL task or any `delicate` task) re-enters at the same review altitude as the original spec — `spec_review` → `plan` → `implement` — regardless of which admitted phase (`code_review`, `qa`, or `human_review`) the task was rerouted from. Codex reviews the amendment in the context of the previously approved ACs and prior `spec-review.md`, without auditing `handoff.md`, `review.md`, or `done.md`. If the amendment is approved, the pipeline flows through to `plan` unless the operator re-armed the human spec gate first, in which case it halts at the gate. Once past `spec_review`, Claude appends a reroute plan section (`## Reroute Plan` or `## Reroute Plan Round N`) to `plan.md`; Codex then implements from the amendment plus that reroute plan.
 
 Rerouting from `code_review` or a `qa` `pending`/`in_progress` entry happens before the QA-end commit, so task artifacts may still be uncommitted in the worktree. `--reroute` performs no git operation itself, so nothing is destroyed by the reroute. Do not run a manual git command that can discard uncommitted state (`reset --hard`, `checkout HEAD~N`, `stash drop`, or equivalent) in that window.