@alphazede/bearing-lite 0.1.10 → 0.2.0

package/CONTRIBUTING.md

@@ -54,8 +54,33 @@ checkout):
 node --test test/diagram-sync.test.mjs
 node --test test/public-boundary.test.mjs
 node --test test/skills-conformance.test.mjs
+python3 test/schema-validation.py
 ```
 
+Schema validation requires Python 3.12. `python3 test/schema-validation.py` is
+the required developer and CI gate (`CMD-LITE-SCHEMA-VALIDATE`). It installs the
+pinned hashes from `test/schema-validator-requirements.txt` into an isolated
+temporary directory with `pip install --isolated --require-hashes --no-deps` and
+runs Draft 2020-12 validation with no remote `$ref` retrieval. Do not install
+those packages globally, with `--user`, or as production dependencies of this
+package.
+
+CI on `ubuntu-24.04` with Python 3.12 x64 performs the same isolated
+`--require-hashes --no-deps` install into a job-local target directory, then
+runs `python3 test/schema-validation.py`. To reuse a local isolated tree instead
+of a temporary install:
+
+```sh
+python3.12 -m venv .venv-schema-validator
+.venv-schema-validator/bin/python -m pip install \
+  --isolated --require-hashes --no-deps \
+  -r test/schema-validator-requirements.txt
+BEARING_LITE_SCHEMA_ISOLATED_ROOT=.venv-schema-validator/lib/python3.12/site-packages \
+  python3 test/schema-validation.py
+```
+
+Keep that virtualenv uncommitted.
+
 Keep skills lean. Prefer references and assets only when progressive disclosure
 needs them. Do not add dependencies or change the lockfile without explicit
 maintainer approval. Do not add `mcp.json`, postinstall scripts, or global hook

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,13 @@ 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 (`<journey-topic>-technical-plan.md`,
+`design.md`, `seit.json`, `implementation.json`, and two-state `review.html`)
+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 task state over those JSON
+authorities.
 
 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 +71,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,12 +97,24 @@ 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.
-5. **Record state visibly** in human-readable Markdown artifacts only.
+1. **Fill only missing planning stages:** Repository Fit → Set Bearings → Gather
+   Supplies.
+2. **Invoke Map the Route** after material intent is settled. It creates
+   technical-plan, `design.md`, `seit.json`, `implementation.json`, and
+   two-state `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.** The project's human-readable Markdown plan is the
+   only task-state record: task blocks, task states, and their transitions. The
+   Journey, execution, V&V, and authority records are machine-readable JSON
+   validated against `schemas/`: `journey.json` (Journey identity, checkout
+   lease, decisions, planning receipts, lineup selection), `seit.json` (V&V
+   proof rows), `implementation.json` (nested execution authority, waves,
+   slices, dispatch), and `authority.json` (authority envelope). `review.html`
+   and diagrams present state; like diagrams, they never authorize a
+   transition, create state, or grant authority.
 
 Bearing Lite never selects models, providers, credentials, or launchers. The
 owner provides each role's primary/fallback agent or harness, model, and
@@ -97,11 +126,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,28 +141,41 @@ 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
+Assurance Test Engineer, 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 |
-| **Park Ranger** | Defect review | no | Independent of the author |
-| **Surveyor** | User-facing acceptance | no | Read-only outcome judgment |
+| **Crewmate** | Bounded implementer | yes | Split test-writing versus product; neither self-certifies |
+| **Scribe** | Event side lane | no | Transcribes; cannot activate authority |
+| **Plan Integrator** | Artifact reconciliation | no | Generates `implementation.json` and `review.html` |
+| **Systems Modeler** | Engineering views | no | After requirements; before design finalization |
+| **Integration Engineer** | Progressive assembly | no | Dual planning and execution sessions |
+| **Test Engineer** | Planning and Assurance V&V | no | Retires Validator; Validator is not an active role |
+| **Park Ranger** | Defect review | no | Consumes Assurance Test Engineer; no routine TE |
+| **Surveyor** | User-facing acceptance | no | Read-only RE, SysML Modeling, and TE |
 | **Owner Authority** | Human decision | n/a | Never an agent role |
 
-**Independent review:** a candidate author never provides their own Validator,
-Park Ranger, or Surveyor verdict.
+**Independent review:** a candidate author never provides their own Assurance
+Test Engineer, Park Ranger, or Surveyor verdict.
+
+Public Bearing Lite remains usable without AlphaZede-specific skills
+(`requirements-engineering`, `sysml-modeling`, `test-engineering`,
+`integration-engineering`). Specialized capabilities activate when selected
+or required. Unavailability of a selected-or-required capability is a typed capability gap,
+not success and not invented behavior. Selected-only missing and required-only
+missing are each typed gaps. Only unselected and unrequired absence remains
+inactive / not a global failure.
 
 Failure escalates to the nearest role whose scope can see it:
 
@@ -141,7 +183,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 +204,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,
@@ -186,6 +228,8 @@ flowchart LR
 | `plugin.json` | Agent Plugins v1.0.0 manifest |
 | `skills/` | Router, planning stages, and role skills |
 | `hooks/` | Four portable class adapters plus the verified Claude Code / Codex mapping |
+| `lineups.json` | Empty shipped catalog; no packaged providers, models, or defaults |
+| `schemas/` | JSON Schema for `seit.json`, `implementation.json`, `authority.json`, and `journey.json` |
 | `README.md` and governance docs | Public product and conduct surfaces |
 
 There is no `mcp.json`, `bin` entrypoint, postinstall, or runtime dependency on

package/hooks/assurance-budget.cjs

@@ -0,0 +1,167 @@
+"use strict";
+
+/**
+ * Per-declared-phase-or-wave assurance budget (ROUTER-EMV-CADENCE-IMPLEMENTATION-001).
+ * Exact runtime mirror of `skills/bearing-lite/references/assurance-policy.md`.
+ * A pure evaluator behind the existing `transition` class, like planning-review.cjs:
+ * it declares no HOOK_CLASS and registers no host event.
+ */
+
+const fs = require("node:fs");
+
+const POLICY = Object.freeze({
+  budget_scope: "per_declared_phase_or_wave",
+  review_rounds: 1,
+  aggregated_repairs_max: 1,
+  post_repair_gate: "deterministic_PASS",
+  automatic_phase_or_wave_end_review: "required",
+  automatic_per_slice_review: "prohibited",
+  post_repair_rereview: "prohibited",
+  automatic_rereview_of_same_unit: "prohibited",
+  budget_reset_on_candidate_change: false,
+  budget_reset_on_model_change: false,
+  budget_reset_on_harness_change: false,
+  budget_reset_on_role_change: false,
+  budget_reset_on_session_change: false,
+  budget_reset_on_resume: false,
+  budget_reset_on_alias_or_rename: false,
+  budget_reset_condition:
+    "next_distinct_declared_phase_or_wave_present_in_the_frozen_declaration",
+});
+
+/** The sentinel unit when the frozen declaration names neither waves nor phases. */
+const DIRECT = "direct";
+const PENDING_RECEIPTS = new Set(["WAITING_ON", "UNAVAILABLE"]);
+
+const isCount = (value) => Number.isInteger(value) && value >= 0;
+
+const isPlainObject = (value) =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+
+function readJson(file) {
+  if (typeof file !== "string" || !file) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return isPlainObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Declared unit ids from the frozen declaration, in declaration order. */
+function declaredUnits(declaration) {
+  const waves = Array.isArray(declaration.waves) ? declaration.waves : [];
+  const waveIds = waves.map((wave) => wave && wave.id).filter((id) => typeof id === "string" && id);
+  if (waveIds.length) return waveIds;
+  const phases = Array.isArray(declaration.phases) ? declaration.phases : [];
+  const phaseIds = phases
+    .map((phase) => phase && phase.phaseId)
+    .filter((id) => typeof id === "string" && id);
+  if (phaseIds.length) return phaseIds;
+  return [DIRECT];
+}
+
+const verdict = (outcome, reason) => ({ outcome, reason });
+
+/**
+ * @param {unknown} input assurance request
+ * @returns {{ outcome: string, reason: string }}
+ */
+function evaluateAssuranceBudget(input) {
+  try {
+    if (!isPlainObject(input)) {
+      return verdict("NEEDS_MORE_EVIDENCE", "assurance_request_missing");
+    }
+    if (
+      POLICY.automatic_per_slice_review === "prohibited" &&
+      (input.request_scope === "slice" || input.unit_kind === "slice")
+    ) {
+      return verdict("OWNER_AMENDMENT_REQUIRED", "automatic_per_slice_review_prohibited");
+    }
+    if (
+      POLICY.automatic_rereview_of_same_unit === "prohibited" &&
+      (input.automatic_rereview_requested === true || input.review_after_repair === true)
+    ) {
+      return verdict("OWNER_AMENDMENT_REQUIRED", "automatic_rereview_prohibited");
+    }
+
+    const declaration = readJson(input.declaration_path);
+    if (!declaration) {
+      return verdict("NEEDS_MORE_EVIDENCE", "frozen_declaration_unreadable");
+    }
+    const record = readJson(input.task_record_path);
+    if (!record) {
+      return verdict("NEEDS_MORE_EVIDENCE", "task_record_unreadable");
+    }
+    // The budget key is `journey + unit_kind + unit_id`; a record from another
+    // Journey never answers for this one.
+    if (
+      typeof record.journey === "string" &&
+      typeof input.journey === "string" &&
+      record.journey !== input.journey
+    ) {
+      return verdict("NEEDS_MORE_EVIDENCE", "task_record_journey_mismatch");
+    }
+
+    const declared = declaredUnits(declaration);
+    const requested =
+      typeof input.assurance_unit === "string" && input.assurance_unit
+        ? input.assurance_unit
+        : declared.length === 1 && declared[0] === DIRECT
+          ? DIRECT
+          : "";
+    if (!requested || !declared.includes(requested)) {
+      return verdict("OWNER_AMENDMENT_REQUIRED", "undeclared_review_unit");
+    }
+
+    const receipts = Array.isArray(input.receipts) ? input.receipts : [];
+    if (receipts.some((receipt) => PENDING_RECEIPTS.has(receipt && receipt.verdict))) {
+      return verdict("NEEDS_MORE_EVIDENCE", "assurance_transport_pending");
+    }
+
+    const units = Array.isArray(record.units) ? record.units : [];
+    const spent = units.find((unit) => {
+      if (!isPlainObject(unit)) return false;
+      const unitId = unit.unit_id || unit.assurance_unit;
+      const id = typeof unitId === "string" && unitId ? unitId : DIRECT;
+      if (id !== requested) return false;
+      if (typeof unit.journey === "string" && unit.journey !== input.journey) return false;
+      if (
+        typeof unit.unit_kind === "string" &&
+        typeof input.unit_kind === "string" &&
+        unit.unit_kind !== input.unit_kind
+      ) {
+        return false;
+      }
+      return true;
+    });
+    const counter = (field) => {
+      const value = spent && spent[field];
+      return value === undefined || value === null ? 0 : value;
+    };
+    const rounds = counter("assurance_rounds");
+    const repairs = counter("assurance_repairs");
+    // A corrupt counter is not a spent-zero budget.
+    if (!isCount(rounds) || !isCount(repairs)) {
+      return verdict("NEEDS_MORE_EVIDENCE", "invalid_assurance_counter");
+    }
+
+    if (repairs > POLICY.aggregated_repairs_max) {
+      return verdict("HALT", "assurance_repair_limit");
+    }
+    if (
+      repairs === POLICY.aggregated_repairs_max &&
+      (spent && spent.deterministic_gate) !== POLICY.post_repair_gate.split("_")[1]
+    ) {
+      return verdict("HALT", "deterministic_post_repair_gate_required");
+    }
+    if (rounds >= POLICY.review_rounds) {
+      return verdict("HALT", "assurance_round_limit");
+    }
+    return verdict("PASS", "assurance_round_available");
+  } catch {
+    return verdict("NEEDS_MORE_EVIDENCE", "assurance_budget_unavailable");
+  }
+}
+
+module.exports = { POLICY, evaluateAssuranceBudget };

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,
     });
   }