@alphazede/bearing-lite 0.1.9 → 0.1.11

package/README.md

@@ -8,9 +8,11 @@ planning, routing, bounded execution, and independent review of repository work.
 It ships portable skills, references, templates, and optional client hooks.
 
 An agent cannot certify its own work. The stateful Router owns the planning
-conversation and visible Journey state, then dispatches fresh bounded sessions.
-Independent assurance runs at the owner's selected cadence: per slice, per
-execution/correction round, or once at the end. Owner Authority remains human-only.
+conversation, visible Journey state, and Expedition sequencing. Crewmate and
+Explorer may continue in-wave when the envelope is unchanged. Independent
+assurance runs once at the end on the final integrated candidate. One repair
+may follow; it is verified deterministically without another review. Owner
+Authority remains human-only.
 
 Bearing Lite was created by William Rumph.
 
@@ -27,9 +29,10 @@ Then give your agent a real task:
 > Use Bearing Lite to add rate limiting to this API without changing its public
 > responses. Require one independent review at the end.
 
-Bearing Lite asks whether the work is an Explorer Journey or an Expedition,
-fills only the missing planning stages, confirms the agent lineup and review
-cadence, and dispatches bounded sessions with visible Markdown state.
+Bearing Lite fills missing planning stages, then Map the Route creates the
+complete five-artifact package with proposed route, lineup, role states,
+reasoning, and at-end cadence. One integrated owner review approves or changes
+that package before bounded sessions dispatch with visible Markdown state.
 
 If Bearing Lite helps keep a long agent task scoped and reviewable,
 [star the repository](https://github.com/alphazede/bearing-lite). It helps other
@@ -65,13 +68,25 @@ agy plugin install /path/to/bearing-lite/.agy
 
 # Pi — skills package, no command hooks
 pi install npm:@alphazede/bearing-lite
+
+# DeepCode — discover the packaged skills through ~/.deepcode/skills or ~/.agents/skills;
+# DeepCode has no plugin-install or command-hook surface
 ```
 
 Claude Code, Codex, Grok Build, Cursor, and Kimi Code are **partial** hook
 clients: session start runs the activation advisory and stop runs the closeout
-advisory. AGY and Pi are **skills-only**. Transition-order and protected-action
-checks stay in the skills on every host. Node.js must be on `PATH` for the
-hook adapters.
+advisory. AGY, Pi, and DeepCode are **skills-only**. Transition-order and
+protected-action checks stay in the skills on every host. Node.js must be on
+`PATH` for the hook adapters.
+
+Planning-review constraints live only in
+[`skills/bearing-lite/references/review-policy.md`](skills/bearing-lite/references/review-policy.md);
+the shared evaluator is `hooks/planning-review.cjs`. Journey-specific abstract
+slot IDs and owner-selected primary/ordered fallback route references belong
+only in the approved `lineup_snapshot`. Existing host mappings cannot safely
+derive the nested record from session events, so they preserve partial or
+skills-only coverage and apply this gate procedurally. Planning review is a
+pre-dispatch plan gate; implementation `max_assurance_rounds` remains separate.
 
 **Skills-only copy** of `skills/` into a host skills directory does not
 register hooks. That path remains first-class. See
@@ -79,11 +94,14 @@ register hooks. That path remains first-class. See
 
 ## What it does
 
-1. **Ask** whether the Journey is an Explorer Journey or an Expedition.
-2. **Fill only missing planning stages:** Repository Fit → Set Bearings → Gather
-   Supplies → Map the Route.
-3. **Confirm** the user-owned primary/fallback lineup and review cadence.
-4. **Dispatch fresh sessions** with bounded context, authority, and return types.
+1. **Fill only missing planning stages:** Repository Fit → Set Bearings → Gather
+   Supplies.
+2. **Invoke Map the Route** after material intent is settled. It creates
+   specification, design, SEIT, implementation, and `review.html` together.
+3. **Review once:** approve or change the proposed route, user-owned
+   primary/fallback lineup, role states, reasoning, at-end cadence, and plan.
+4. **Dispatch bounded sessions** with compact receipts. Crewmate and Explorer may
+   continue in-wave; assurance always starts fresh at the end.
 5. **Record state visibly** in human-readable Markdown artifacts only.
 
 Bearing Lite never selects models, providers, credentials, or launchers. The
@@ -96,11 +114,11 @@ the applicable Journey snapshot before implementation.
 | Route | When | Cost |
 |---|---|---|
 | **Explorer Journey** | One bounded packet or one wave | Direct Crewmate or one Explorer |
-| **Expedition** | Multi-phase or concurrent independent lanes | Navigator |
+| **Expedition** | Multi-phase or concurrent independent lanes | Router sequences; Explorer owns waves |
 
 An **Explorer Journey** uses a direct Crewmate for one ready packet or one
 Explorer over a compact/sequential wave.
-**Expedition** adds navigation so independent lanes
+**Expedition** lets the Router sequence waves so independent lanes
 stay small and sharp instead of degrading in one long context. Either shape can
 use substantial tokens; the product does not impose a default budget ceiling.
 
@@ -111,20 +129,20 @@ The text below remains authoritative for clients that do not render Mermaid.
 
 **Authoritative text (vision optional):** Owner Authority remains human-only. The
 Bearing Lite Router is the stateful planning controller, not a work role. It
-invokes only missing planning stages in fresh sessions, confirms the owner's
-lineup and cadence, then dispatches an Explorer Journey or Expedition. Explorer
+invokes only missing planning stages, has Map the Route generate all five
+artifacts with proposed lineup and `review_cadence: at-end`, then presents one
+integrated owner review before dispatching an Explorer Journey or Expedition. Explorer
 coordinates proven-independent in-wave lanes without a nested coordinator.
-Validator, Park Ranger,
-and Surveyor appear only when declared and when the selected per-slice,
-per-round, or at-end boundary is reached. Diagrams explain orientation; they
-never authorize a transition.
+Validator, Park Ranger, and Surveyor appear only when declared and only at the
+end on the final integrated candidate. Diagrams
+explain orientation; they never authorize a transition.
 
 ## Roles and authority
 
 | Role | What it is | Executes | Notes |
 |---|---|---|---|
-| **Router** | Stateful planning controller | no | User-facing; planning-state writer |
-| **Navigator** | Expedition orchestrator | no | Owns cross-wave sequencing and conflicts |
+| **Router** | Stateful planning controller | no | User-facing; planning-state writer; Expedition sequencing |
+| **Navigator** | Compatibility diagnostic | no | Not a normal role; existing plans reroute to Router |
 | **Explorer** | One-wave controller | no | Dispatches Crewmates; owns proven-independent lanes |
 | **Crewmate** | Bounded implementer | yes | Most hands-on work; exact write set |
 | **Validator** | Evidence sufficiency | no | Independent of the author |
@@ -141,7 +159,7 @@ Failure escalates to the nearest role whose scope can see it:
 |---|---|
 | Within one slice or packet | Explorer or nearest parent |
 | Across slices in a wave | Explorer |
-| Across waves or phases | Navigator |
+| Across waves or phases | Router |
 | Contract, security, or authority change | Owner Authority |
 
 ## Task state (explanatory)
@@ -155,60 +173,30 @@ Normal progress is `PROPOSED` → `READY` → `IN_PROGRESS` → `EVIDENCE_READY`
 optional `VALIDATING` / `REVIEWING` when required, then `ACCEPTANCE` →
 `COMPLETE`. `WAITING_ON` holds for missing prerequisites, checkout-lease
 conflict, or assurance dispatch.
-`CORRECTION_REQUIRED` allows two in-authority repairs; a third failed correction
-escalates to `OWNER_DECISION_REQUIRED`. Diagrams never create state or authorize
-transitions.
+Ordinary execution corrections remain bounded. The assurance gate allows one
+review-directed repair, followed by deterministic coordinator verification and
+no second review. Diagrams never create state or authorize transitions.
 
 ## Implementation process (explanatory)
 
-Owner-approved multi-phase work follows four phases: Inventory, Foundation,
-Proof and Documentation, and Final Audit. Default slice completion is author
-self-check plus coordinator confirmation when `required_assurance` is `none`.
-Fresh Validator then separate Park Ranger is mandatory only on exact integrated
-phase candidates, not on every packet.
-
-![Bearing Lite implementation process: four phases with default self-check slices, optional owner slice assurance, mandatory integrated phase gates, bounded correction, and final Surveyor acceptance](docs/plans/2026-08-09-bearing-skills-first-architecture/assets/implementation-process.png)
-
-Mermaid source:
-[`docs/plans/2026-08-09-bearing-skills-first-architecture/assets/implementation-process.mmd`](docs/plans/2026-08-09-bearing-skills-first-architecture/assets/implementation-process.mmd).
-
-<details>
-<summary>Diagram source (implementation process)</summary>
+Default packet completion is author self-check plus coordinator confirmation.
+Declared independent assurance runs once at the end. A repairable
+verdict permits one repair; deterministic coordinator verification then closes
+the gate without another review. Once the Journey is `COMPLETE`, an already
+authorized deployment proceeds with operational checks and rollback readiness,
+not a new assurance round. Source-changing deployment work is separate work.
 
 ```mermaid
-flowchart TD
-    P1[Phase 1 Inventory S1-S4 complete] --> P2[Phase 2 Foundation S4A-S7]
-    P2 --> SLICE[Crewmate then author self-check]
-    SLICE --> CC[Coordinator scope and dependency confirmation]
-    CC --> OPT{Owner slice assurance?}
-    OPT -->|Yes| V[Fresh Validator then optional Park Ranger]
-    OPT -->|No| MORE{More Foundation slices?}
-    V -->|Fail or repair| R[Bounded Correction Attempt]
-    V -->|Pass| MORE
-    R -->|Attempt 1 or 2| SLICE
-    R -->|3rd Failure| O[OWNER_DECISION_REQUIRED]
-    MORE -->|Yes| SLICE
-    MORE -->|No: integrated Foundation| FG[Fresh Validator then separate Park Ranger]
-    FG --> P3[Phase 3 Proof and Documentation S8-S10]
-    P3 --> SLICE3[Crewmate then author self-check]
-    SLICE3 --> CC3[Coordinator confirmation]
-    CC3 --> OPT3{Owner slice assurance?}
-    OPT3 -->|Yes| V3[Fresh Validator then optional Park Ranger]
-    OPT3 -->|No| MORE3{More Proof and Documentation slices?}
-    V3 -->|Fail or repair| R
-    V3 -->|Pass| MORE3
-    MORE3 -->|Yes| SLICE3
-    MORE3 -->|No: integrated Proof and Documentation| PG[Fresh Validator then separate Park Ranger]
-    PG --> P4[Phase 4 Final Audit S11-S12]
-    P4 --> S11[S11 Skill and State Alignment Audit]
-    S11 --> S12[S12 Integrated Acceptance]
-    S12 --> S[Fresh Surveyor Final Acceptance]
-    S -->|Pass| CMP[COMPLETE]
-    O -->|Owner Decision| MORE
+flowchart LR
+    W[Bounded work] --> C[Deterministic checks]
+    C --> R[Single independent review]
+    R -->|Pass| X[COMPLETE]
+    R -->|Repairable| F[One repair]
+    F --> V[Coordinator verification]
+    V --> X
+    X --> D[Authorized deploy and operational verification]
 ```
 
-</details>
-
 ## Package layout
 
 | Path | Purpose |

package/hooks/closeout.cjs

@@ -10,25 +10,42 @@
 const HOOK_CLASS = "closeout";
 const OUTCOMES = Object.freeze(["ADVISE", "REROUTE", "BLOCK", "UNAVAILABLE"]);
 const ENFORCEMENT = "procedural";
+const { evaluatePlanningReview } = require("./planning-review.cjs");
 
 const HANDOFF_FIELDS = Object.freeze([
-  "plan_ref",
-  "role",
-  "subject",
-  "depends_on",
-  "scope",
-  "authority",
-  "outcome",
-  "evidence",
+  "verdict",
+  "candidate_ref",
+  "changed_paths",
+  "tests",
+  "findings",
   "blocker",
-  "next_action",
-  "receiving_role",
+]);
+
+/** Closed role-return tokens. Task-block `outcome` is intent and cannot satisfy this. */
+const VERDICT_VALUES = new Set([
+  "ACCEPT",
+  "ACCEPT_WITH_FINDINGS",
+  "BLOCK",
+  "CANDIDATE_READY",
+  "FAIL",
+  "GAPS",
+  "NEEDS_MORE_EVIDENCE",
+  "OWNER_DECISION_REQUIRED",
+  "PARTIAL",
+  "PASS",
+  "READY",
+  "REPAIR_REQUIRED",
+  "REROUTED",
+  "WAITING_ON",
 ]);
 
 const RECOVERY_UNAVAILABLE =
   "Report UNAVAILABLE, complete the handoff checklist manually, and do not request protected completion until required fields and assurance are present";
 const RECOVERY_HANDOFF =
-  "Complete the role return envelope (plan_ref, role, subject, depends_on, scope, authority, outcome, evidence, blocker, next_action, receiving_role) in the project plan";
+  "Complete the compact receipt (verdict, candidate_ref, changed_paths, tests, findings, blocker) in the project plan";
+const RECOVERY_INVALID_VERDICT =
+  "Replace verdict with a closed role-return token: " +
+  [...VERDICT_VALUES].join(", ");
 const RECOVERY_COMPLETE =
   "Handoff is complete; parent coordinator may advance using the project plan only";
 const RECOVERY_BLOCK_COMPLETION =
@@ -75,9 +92,10 @@ function normalizeAssurance(value) {
   return [String(value)].filter((s) => s && s !== "none");
 }
 
-function missingHandoffFields(input) {
+function inspectHandoffFields(input) {
   const handoff = isPlainObject(input.handoff) ? input.handoff : input;
   const missing = [];
+  const invalid = [];
   for (const field of HANDOFF_FIELDS) {
     const value = handoff[field];
     if (value === undefined || value === null) {
@@ -86,10 +104,14 @@ function missingHandoffFields(input) {
     }
     if (typeof value === "string" && value.trim() === "") {
       missing.push(field);
+      continue;
+    }
+    if (field === "verdict" && (typeof value !== "string" || !VERDICT_VALUES.has(value.trim()))) {
+      invalid.push(field);
     }
   }
   // blocker may be the string "none"; that is present and valid.
-  return missing;
+  return { missing, invalid };
 }
 
 /**
@@ -124,7 +146,11 @@ function evaluate(input) {
         ? "protected_completion"
         : "advisory";
 
-    const missing = missingHandoffFields(input);
+    const planningVerdict = input.planning_review
+      ? evaluatePlanningReview(input.planning_review)
+      : null;
+
+    const { missing, invalid } = inspectHandoffFields(input);
     const required = normalizeAssurance(input.required_assurance);
     const accepted = Array.isArray(input.assurance_accepted)
       ? input.assurance_accepted.map(String)
@@ -141,12 +167,16 @@ function evaluate(input) {
 
     if (mode === "protected_completion") {
       const blockers = [];
-      if (missing.length > 0) blockers.push("handoff:" + missing.join(","));
+      const handoffProblems = [...missing, ...invalid];
+      if (handoffProblems.length > 0) blockers.push("handoff:" + handoffProblems.join(","));
       if (missingAssurance.length > 0) {
         blockers.push("assurance:" + missingAssurance.join(","));
       }
       if (!candidateMatched) blockers.push("candidate_mismatch");
       if (unresolvedBlocker) blockers.push("unresolved_blocker");
+      if (planningVerdict && planningVerdict.outcome !== "PASS") {
+        blockers.push("planning_review:" + planningVerdict.outcome);
+      }
 
       if (blockers.length > 0) {
         return result(
@@ -165,6 +195,16 @@ function evaluate(input) {
       );
     }
 
+    if (planningVerdict) {
+      return result(
+        planningVerdict.outcome === "PASS" ? "ADVISE" : "REROUTE",
+        "planning_review:" + planningVerdict.outcome + ":" + planningVerdict.reason,
+        planningVerdict.outcome === "PASS"
+          ? "Planning-review record is complete; continue to the integrated owner gate"
+          : "Keep dispatch closed and complete, repair, or amend the planning-review record"
+      );
+    }
+
     // Advisory closeout: never BLOCK.
     if (missing.length > 0) {
       return result(
@@ -174,6 +214,14 @@ function evaluate(input) {
       );
     }
 
+    if (invalid.length > 0) {
+      return result(
+        "ADVISE",
+        "handoff_invalid:" + invalid.join(","),
+        RECOVERY_INVALID_VERDICT
+      );
+    }
+
     if (missingAssurance.length > 0) {
       return result(
         "ADVISE",
@@ -234,6 +282,7 @@ module.exports = {
   OUTCOMES,
   ENFORCEMENT,
   HANDOFF_FIELDS,
+  VERDICT_VALUES,
   evaluate,
 };
 

package/hooks/com.anthropic.claude-code/host.cjs

@@ -52,7 +52,9 @@ const SKIP_DIRS = new Set([
 const TASK_MARK = /(?:^|\n)###\s*task_id:\s*\S+/;
 const TASK_LINE = /^###\s*task_id:\s*(\S+)\s*$/;
 const FIELD_LINE =
-  /^-\s*(assigned_role|next_action|status|required_assurance|blocker|evidence|candidate_ref|scope|authority|outcome|depends_on|receiving_role|plan_ref|role|subject):\s*(.*)$/;
+  /^-\s*(assigned_role|next_action|status|required_assurance|blocker|evidence|candidate_ref|scope|authority|outcome|verdict|depends_on|receiving_role|plan_ref|role|subject|changed_paths|tests|findings):\s*(.*)$/;
+// Matches both the plan-level Journey type and the lease-nested Journey
+// identity; either non-placeholder value marks the Router as invoked.
 const JOURNEY_LINE = /^\s*-\s*journey:\s*(.+)$/i;
 const LEASE_MARK = /^\s*-\s*checkout_lease:/m;
 
@@ -325,17 +327,12 @@ function evaluateForHost(eventName, derived) {
   if (classForEvent(eventName) === "closeout") {
     const task = derived.active_task || {};
     return closeout.evaluate({
-      plan_ref: derived.plan_present ? "project-plan" : undefined,
-      role: presentString(task.assigned_role) || presentString(task.role),
-      subject: presentString(task.task_id) || presentString(task.subject),
-      depends_on: task.depends_on,
-      scope: presentString(task.scope),
-      authority: presentString(task.authority),
-      outcome: presentString(task.outcome),
-      evidence: presentString(task.evidence),
+      verdict: presentString(task.verdict),
+      candidate_ref: presentString(task.candidate_ref),
+      changed_paths: presentString(task.changed_paths),
+      tests: presentString(task.tests),
+      findings: presentString(task.findings),
       blocker: presentString(task.blocker) || "none",
-      next_action: presentString(task.next_action),
-      receiving_role: presentString(task.receiving_role),
       required_assurance: task.required_assurance,
     });
   }

package/hooks/com.anthropic.claude-code/mapping.md

@@ -16,6 +16,7 @@ procedural.
 | Kimi Code | `.kimi-plugin/plugin.json` | manifest `hooks` array | partial |
 | AGY | `.agy/` (strict `plugin.json`) | none | skills-only |
 | Pi | `package.json` `"pi"` + `pi-package` | none (TypeScript extensions, not command hooks) | skills-only |
+| DeepCode | `.deepcode/skills` or interoperable `.agents/skills` discovery | none | skills-only |
 
 Do **not** set `hooks` on Claude, Codex, or Grok host manifests. Those hosts
 auto-load `hooks/hooks.json`; declaring both is a duplicate-file error.
@@ -32,6 +33,14 @@ adapters into global hook configuration.
 | `Stop`, `stop` | closeout | yes, advisory only |
 | any other host event | none | unmapped; fail open as `UNAVAILABLE` |
 
+The shared planning-review evaluator is used by transition and closeout when a
+client supplies a structured `planning_review` record. Current session-start /
+stop mappings cannot derive that nested record safely, so Claude Code, Codex,
+Grok Build, Cursor, and Kimi remain partial and the check is procedural there.
+AGY, Pi, and DeepCode remain skills-only. Do not claim full planning-review
+enforcement for any of these hosts until a native event supplies the complete
+record.
+
 The adapter accepts snake_case and camelCase (`hook_event_name` /
 `hookEventName`, `cwd` / `workspaceRoot`).
 
@@ -44,15 +53,20 @@ trees) and sets only:
 | Bearing field | Source |
 |---|---|
 | `plan_present` | a Markdown file contains a `task_id`, `assigned_role`, non-placeholder journey marker, or `checkout_lease` block |
-| `router_invoked` | a `- journey:` setting is present and not a placeholder |
+| `router_invoked` | a non-placeholder `- journey:` setting is present, including the Journey identity nested inside the `checkout_lease` block |
 | `assigned_role` | active task `assigned_role` when not `unassigned` or `<…>` |
 | `next_action` / `next_action_known` | active task `next_action` when not a placeholder |
-| closeout handoff fields | matching task-record keys when present |
+| closeout handoff fields | matching task-record keys when present. Receipt `verdict` is a closed role-return token; task `outcome` is approved intent and is not mapped into the receipt |
 
 `assigned_role` and `router_invoked` are **not** inferred from the tool-call
 payload. Missing values stay missing, so activation advises the router instead
 of inventing context.
 
+The Router writes the visible `checkout_lease` before any planning write or
+dispatch; its nested non-placeholder Journey identity is the Router-invoked
+signal during planning. The plan-level Explorer-versus-Expedition value is
+recorded later at the route review.
+
 ## Outcome translation
 
 | Outcome | Host JSON | Process exit |

package/hooks/planning-review.cjs

@@ -0,0 +1,99 @@
+"use strict";
+
+const POLICY = Object.freeze({
+  reviewer_slots_min: 2,
+  reviewer_slots_max: 2,
+  independence_required: true,
+  isolated_findings_until_aggregation: true,
+  candidate_fields: ["candidate_ref", "candidate_revision", "candidate_digest"],
+  shared_candidate_required: true,
+  review_rounds: 1,
+  aggregated_repairs_max: 1,
+  post_repair_gate: "deterministic_PASS",
+  automatic_rereview: "prohibited",
+  slot_exhaustion_outcome: "FAIL_ROUND",
+  terminal_outcomes: ["HALT", "OWNER_AMENDMENT_REQUIRED"],
+});
+
+const sameCandidate = (a, b) =>
+  POLICY.candidate_fields.every(
+    (key) => typeof a?.[key] === "string" && a[key] && a[key] === b?.[key]
+  );
+
+function evaluatePlanningReview(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return { outcome: "NEEDS_MORE_EVIDENCE", reason: "planning_review_missing" };
+  }
+  const slots = Array.isArray(input.reviewer_slots) ? input.reviewer_slots : [];
+  const ids = slots.map((slot) => slot?.slot_id);
+  const primaryRoutes = slots.map((slot) => slot?.primary_route_ref);
+  if (
+    slots.length < POLICY.reviewer_slots_min ||
+    slots.length > POLICY.reviewer_slots_max ||
+    ids.some((id) => typeof id !== "string" || !id) ||
+    new Set(ids).size !== ids.length ||
+    new Set(primaryRoutes).size !== primaryRoutes.length ||
+    slots.some(
+      (slot) =>
+        typeof slot.primary_route_ref !== "string" ||
+        !slot.primary_route_ref ||
+        !Array.isArray(slot.fallback_route_refs)
+    )
+  ) {
+    return { outcome: "OWNER_AMENDMENT_REQUIRED", reason: "slot_binding_invalid" };
+  }
+  if (slots.some((slot) => slot.exhausted === true)) {
+    return { outcome: POLICY.slot_exhaustion_outcome, reason: "reviewer_slot_exhausted" };
+  }
+  if (input.round_number !== 1 || input.completed_rounds > POLICY.review_rounds) {
+    return { outcome: "HALT", reason: "review_round_limit" };
+  }
+  if (input.completed_rounds === 0) {
+    return { outcome: "NEEDS_MORE_EVIDENCE", reason: "review_round_pending" };
+  }
+  if (input.completed_rounds !== POLICY.review_rounds) {
+    return { outcome: "OWNER_AMENDMENT_REQUIRED", reason: "review_round_invalid" };
+  }
+  if (
+    POLICY.automatic_rereview === "prohibited" &&
+    (input.automatic_rereview_requested === true || input.review_after_repair === true)
+  ) {
+    return { outcome: "OWNER_AMENDMENT_REQUIRED", reason: "automatic_rereview_prohibited" };
+  }
+  const receipts = Array.isArray(input.receipts) ? input.receipts : [];
+  const receiptIds = receipts.map((receipt) => receipt?.slot_id);
+  const selectedRoutes = receipts.map((receipt) => receipt?.selected_route_ref);
+  if (
+    receipts.length !== slots.length ||
+    new Set(receiptIds).size !== receiptIds.length ||
+    new Set(selectedRoutes).size !== selectedRoutes.length ||
+    !input.candidate ||
+    receipts.some(
+      (receipt) => {
+        const slot = slots.find((item) => item.slot_id === receipt?.slot_id);
+        return (
+          !slot ||
+          ![slot.primary_route_ref, ...slot.fallback_route_refs].includes(receipt.selected_route_ref) ||
+          receipt.independent !== POLICY.independence_required ||
+          receipt.findings_isolated !== POLICY.isolated_findings_until_aggregation ||
+          !sameCandidate(receipt, input.candidate)
+        );
+      }
+    )
+  ) {
+    return { outcome: "HALT", reason: "candidate_or_independence_mismatch" };
+  }
+  if (input.aggregation_complete !== true) {
+    return { outcome: "NEEDS_MORE_EVIDENCE", reason: "aggregation_pending" };
+  }
+  const repairs = Number(input.aggregated_repairs || 0);
+  if (!Number.isInteger(repairs) || repairs < 0 || repairs > POLICY.aggregated_repairs_max) {
+    return { outcome: "HALT", reason: "aggregated_repair_limit" };
+  }
+  if (repairs === 1 && input.deterministic_gate !== POLICY.post_repair_gate.split("_")[1]) {
+    return { outcome: "HALT", reason: "deterministic_post_repair_gate_required" };
+  }
+  return { outcome: "PASS", reason: repairs ? "repair_gate_passed" : "review_aggregated" };
+}
+
+module.exports = { POLICY, evaluatePlanningReview };

package/hooks/transition-order.cjs

@@ -10,6 +10,7 @@
 const HOOK_CLASS = "transition";
 const OUTCOMES = Object.freeze(["ADVISE", "REROUTE", "BLOCK", "UNAVAILABLE"]);
 const ENFORCEMENT = "procedural";
+const { evaluatePlanningReview } = require("./planning-review.cjs");
 
 const RECOVERY_UNAVAILABLE =
   "Keep the current state, run the transition checklist procedurally, and record the result before retrying";
@@ -125,6 +126,18 @@ function evaluate(input) {
       return result("ADVISE", "channel_open", RECOVERY_CHANNEL);
     }
 
+    if (input.action_kind === "planning_review_transition") {
+      const verdict = evaluatePlanningReview(input.planning_review);
+      if (verdict.outcome === "PASS") {
+        return result("ADVISE", "planning_review:PASS", RECOVERY_ALLOW);
+      }
+      return result(
+        verdict.outcome === "NEEDS_MORE_EVIDENCE" ? "REROUTE" : "BLOCK",
+        "planning_review:" + verdict.outcome + ":" + verdict.reason,
+        "Keep dispatch closed and repair or amend the planning-review record"
+      );
+    }
+
     const from = typeof input.from_state === "string" ? input.from_state.trim() : "";
     const to = typeof input.to_state === "string" ? input.to_state.trim() : "";
     if (!from || !to) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphazede/bearing-lite",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Skills-first Agent Plugin for planning, routing, bounded execution, and independent review of repository work—without CLI, MCP, server, or hidden runtime state.",
   "keywords": [
     "agent-plugins",
@@ -15,7 +15,9 @@
     "pi-package"
   ],
   "pi": {
-    "skills": ["./skills"]
+    "skills": [
+      "./skills"
+    ]
   },
   "author": "William Rumph / AlphaZede",
   "license": "Apache-2.0",
@@ -36,5 +38,6 @@
     "CONTRIBUTING.md",
     "SECURITY.md",
     "LICENSE-APACHE"
-  ]
+  ],
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319"
 }

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "bearing-lite",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Skills-first portable plugin that routes repository work through the smallest valid planning stages and agent roles, using project Markdown as the only task record.",
   "author": {
     "name": "William Rumph / AlphaZede",