@alphazede/bearing-lite 0.1.10 → 0.1.11

package/README.md

@@ -8,10 +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 once at the owner's selected boundary: after a
-slice, after an integrated round, or at the end. One repair may follow; it is
-verified deterministically without another review. 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.
 
@@ -28,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
@@ -66,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
@@ -80,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 single review boundary.
-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
@@ -97,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.
 
@@ -112,19 +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
-single selected per-slice, per-round, or at-end boundary is reached. Diagrams
+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)
@@ -162,7 +180,7 @@ no second review. Diagrams never create state or authorize transitions.
 ## Implementation process (explanatory)
 
 Default packet completion is author self-check plus coordinator confirmation.
-Declared independent assurance runs once at the selected boundary. A repairable
+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,

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.10",
+  "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.10",
+  "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",

package/skills/bearing-lite/SKILL.md

@@ -3,51 +3,44 @@ name: bearing-lite
 description: Bearing Lite Router for Journeys. Not for ordinary work, assigned packets, implementation, or publication.
 ---
 
-The Router alone writes Journey planning state and owns owner conversation;
-planning nodes return owner questions. No second start confirmation, `.bearing`,
-or hidden ledger. plugin hosts are partial; skill-copy is skills-only.
+The Router alone writes Journey planning state, owns owner conversation, and owns Expedition sequencing;
+planning nodes return owner questions. Plugin hosts are partial; skill-copy is skills-only.
 
-1. Say `Preparing this Journey.` Inventory visible nonterminal Journeys; acquire or
-   resume a generation-bound checkout lease before any planning write or dispatch.
-   A live same-checkout competitor returns `WAITING_ON` with sanitized competing identity;
-   Distinct explicitly approved compatible worktrees may proceed.
-2. New Journey: recommend Explorer Journey or Expedition with reason; say when
-   the other fits. Ask exactly: `What Journey shall
-   we Embark on—an Explorer Journey or an Expedition?`
-3. On resume, keep the same lease generation and next incomplete stage. Parent-proven
-   same-Journey progress refreshes `candidate_revision` on that generation.
-   Never replay accepted stages or duplicate a dispatch.
-4. If `~/.agents/bearing-lite/default-role-lineup.md` is absent, create a
-   proposed copy from `templates/default-role-lineup.md`; confirm one role at a
-   time. Never infer identity values.
-5. Run one missing stage in order: Repository Fit → Set Bearings → Gather
-   Supplies. The Router holds every owner conversation inline; Gather Supplies
-   is a Router-led interview, never dispatched. Dispatch a fresh session only
-   for bounded mechanical legwork (mapping, drafting) after stage intent is
-   clear, on a cheaper lower-reasoning model than the Router; integrate returns.
-6. Before Map the Route, display each role's primary/fallback, model, reasoning,
-   and active/standby/unused state. Ask `Is this a
-   good lineup for the roles on this Journey?`; never choose. Recommend cadence
-   with a reason plus one cheaper and one more expensive alternative stating
-   what each gives up or buys. Ask `Where should the single independent
-   review run—after a slice, after an integrated round, or at the end?`
-7. Record route, lineup, and cadence before task mapping; if declined, record the named default explicitly.
-   The recorded snapshot is authoritative for this Journey. Later edits to
-   `~/.agents/bearing-lite/default-role-lineup.md` have no effect on it. Replace
-   only through an explicit owner-confirmed dated visible amendment. Invoke Map the Route with the snapshot.
-8. Every ready node gets a fresh session with lineup identity from the recorded snapshot.
+1. Say `Preparing this Journey.` Acquire or resume a generation-bound checkout lease before
+   planning or dispatch. A live same-checkout competitor returns `WAITING_ON` with sanitized identity.
+2. Resume the next incomplete stage in the same generation; refresh `candidate_revision`.
+   Never replay accepted stages or duplicate dispatch. Invalid leases fail closed.
+3. If `~/.agents/bearing-lite/default-role-lineup.md` is absent, create a proposed copy
+   from `templates/default-role-lineup.md`;
+   never infer identity values. The recorded snapshot is authoritative for this Journey.
+   Later edits to
+   `~/.agents/bearing-lite/default-role-lineup.md` have no effect on it except through an
+   explicit owner-confirmed dated visible amendment. Dispatch uses lineup identity from the recorded snapshot.
+4. Run Repository Fit → Set Bearings → Gather Supplies; unresolved material intent blocks Map the Route.
+5. Invoke Map the Route after settled intent. Do not ask for lineup or route
+   before it; carry owner-supplied lineup and `review_cadence: at-end` as proposals.
+6. On `PLAN_REVIEW_READY`, enforce `references/review-policy.md`: one candidate,
+   unique independent slots, one round and aggregated repair, deterministic PASS,
+   no rereview. Journey snapshots bind slots; validation never dispatches. Show one integrated
+   approval-or-change gate for outcome, design, route, lineup, role states,
+   reasoning, cadence, and plan. Record the approved Journey type and snapshot; regenerate changes.
+   Never add a staged lineup or route-review gate.
+   Dispatch only after approval.
+7. Dispatch from the snapshot. Crewmate and Explorer may continue in-wave unchanged.
+   Validate the lease at wave start, after drift, and before commit; use the visible wave receipt
+   and update implementation and review once per wave.
 
-Return `READY`, `WAITING_ON`, `OWNER_DECISION_REQUIRED`, or `COMPLETE`. Fallback
-requires primary unavailability; both failing returns to owner. Allow three
-evidence-changing corrections outside assurance. `max_assurance_rounds` is 1
-per Journey; the sole review may authorize one repair. Direct route checks
-`assurance_rounds`; Navigator is not required. After repair, run deterministic
-coordinator verification and close the gate without another review. Failed repair
-or scope change returns `OWNER_DECISION_REQUIRED` naming the candidate and count.
-Only a separately scoped new Journey resets the review allowance.
-`COMPLETE` ends Bearing assurance: authorized deployment keeps deployment checks
-and rollback readiness without reopening review. Candidate-changing deployment
-work starts a new Journey. release the checkout lease exactly once on `COMPLETE`
-or `CANCELLED`. Recover by explicit recorded generation increment; it cannot steal a live lease.
-Process discovery cannot replace the lease. Never implement,
-self-assure, select models, or publish.
+Return `READY`, `WAITING_ON`, `OWNER_DECISION_REQUIRED`, or `COMPLETE`. Three
+evidence-changing corrections outside assurance.
+`max_assurance_rounds` is 1 per Journey; Direct route checks `assurance_rounds`, never
+dispatch Navigator, and one review may authorize one repair. Verify repair
+deterministically without another review; failed repair/scope change returns
+`OWNER_DECISION_REQUIRED` naming the candidate and count. Only a separately scoped,
+materially changed new Journey resets review allowance. `COMPLETE` ends Bearing assurance.
+Authorized deployment keeps checks without reopening review.
+Planning review is a separate pre-dispatch gate; it never consumes implementation
+`required_assurance`, `assurance_rounds`, or `max_assurance_rounds`.
+Release the lease once: release the checkout lease exactly once on `COMPLETE` or `CANCELLED`;
+recovery needs explicit recorded generation increment.
+Recovery cannot steal a live lease.
+Never implement, self-assure, select models, or publish.

package/skills/bearing-lite/agents/openai.yaml

@@ -1,7 +1,7 @@
 interface:
   display_name: "Bearing Lite"
   short_description: "Route a stateful repository Journey"
-  default_prompt: "Use $bearing-lite to start or resume this Journey, resolve planning one stage at a time, confirm the lineup and review cadence, then dispatch fresh bounded sessions."
+  default_prompt: "Use $bearing-lite to start or resume this Journey, resolve planning one stage at a time, confirm the lineup, record at-end review, then dispatch bounded sessions."
 
 policy:
   allow_implicit_invocation: false