@alphazede/bearing-lite 0.2.0 → 0.2.1

package/README.md

@@ -118,7 +118,7 @@ register hooks. That path remains first-class. See
 
 Bearing Lite never selects models, providers, credentials, or launchers. The
 owner provides each role's primary/fallback agent or harness, model, and
-reasoning level in `~/.agents/bearing-lite/default-role-lineup.md`, then confirms
+reasoning level in `~/.agents/bearing-lite/lineups.json`, then confirms
 the applicable Journey snapshot before implementation.
 
 ## Routes and scaling
@@ -157,6 +157,7 @@ explain orientation; they never authorize a transition.
 | **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 | Split test-writing versus product; neither self-certifies |
+| **Light Implementer** | Mechanical implementer | yes | `work_class: light` slices only; verified by the packet's command; no repair loop |
 | **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 |
@@ -201,6 +202,11 @@ 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.
 
+`hooks/reconcile.cjs` deterministically applies evidence events to Journey state.
+It is a short-lived Router-run invocation, not a daemon or host event adapter;
+hosts emit no events today, so invocation remains a procedural limitation.
+It observes merge and issue closure but never grants acceptance, merges, or closes issues.
+
 ## Implementation process (explanatory)
 
 Default packet completion is author self-check plus coordinator confirmation.

package/hooks/assurance-budget.cjs

@@ -9,25 +9,7 @@
 
 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",
-});
+const { ASSURANCE_BUDGET_POLICY: POLICY } = require("./policy.cjs");
 
 /** The sentinel unit when the frozen declaration names neither waves nor phases. */
 const DIRECT = "direct";

package/hooks/closeout.cjs

@@ -39,6 +39,19 @@ const VERDICT_VALUES = new Set([
   "WAITING_ON",
 ]);
 
+/** Closed verdicts that refuse protected completion (#55). */
+const NEGATIVE_VERDICTS = new Set([
+  "BLOCK",
+  "FAIL",
+  "GAPS",
+  "NEEDS_MORE_EVIDENCE",
+  "OWNER_DECISION_REQUIRED",
+  "PARTIAL",
+  "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 =
@@ -169,6 +182,8 @@ function evaluate(input) {
       const blockers = [];
       const handoffProblems = [...missing, ...invalid];
       if (handoffProblems.length > 0) blockers.push("handoff:" + handoffProblems.join(","));
+      const verdict = String((isPlainObject(input.handoff) ? input.handoff : input).verdict ?? "").trim();
+      if (NEGATIVE_VERDICTS.has(verdict)) blockers.push("verdict:" + verdict);
       if (missingAssurance.length > 0) {
         blockers.push("assurance:" + missingAssurance.join(","));
       }
@@ -283,6 +298,7 @@ module.exports = {
   ENFORCEMENT,
   HANDOFF_FIELDS,
   VERDICT_VALUES,
+  NEGATIVE_VERDICTS,
   evaluate,
 };
 

package/hooks/plan-package.cjs

@@ -0,0 +1,177 @@
+"use strict";
+
+/**
+ * Map the Route freeze (#70, #73, #77, #80): pure checks over a planning package.
+ * checkRoles: every command a slice runs whose seit procedure names an actor
+ * must name the slice's role. checkWorkClass validates light slices;
+ * checkPlanningRoles excludes planning-only roles from Expedition slices.
+ * verifyDigests: every planning input digest
+ * embedded in seit.json matches the file on disk; the manifest digest over
+ * those inputs plus seit.json matches implementation.json's
+ * planning_review.candidate_digest; missing artifacts, inputs, digests, or a
+ * specification Journey's SDoc register fail closed.
+ * CLI: node <plugin root>/hooks/plan-package.cjs <plan dir> -> JSON, exit 1 on any finding.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+
+const sha256 = (data) => crypto.createHash("sha256").update(data).digest("hex");
+
+/** Walk any object graph and yield slice-like nodes. */
+function* slices(node) {
+  if (Array.isArray(node)) {
+    for (const item of node) yield* slices(item);
+  } else if (node && typeof node === "object") {
+    const ids = [...(node.command_ids || []), ...(node.post_step_command_ids || [])];
+    if (typeof node.id === "string" && typeof node.role === "string") {
+      yield { id: node.id, role: node.role, commandIds: ids };
+    }
+    for (const value of Object.values(node)) yield* slices(value);
+  }
+}
+
+function checkRoles(seit, implementation) {
+  const procedures = new Map(
+    (seit?.procedures_and_commands || []).map((p) => [p.id, p])
+  );
+  const findings = [];
+  for (const slice of slices(implementation)) {
+    for (const command_id of slice.commandIds) {
+      const procedure = procedures.get(command_id);
+      if (!procedure) {
+        findings.push({ code: "unknown_command_id", step: slice.id, command_id });
+      } else if (typeof procedure.actor === "string" && procedure.actor !== slice.role) {
+        findings.push({
+          code: "actor_role_mismatch",
+          step: slice.id,
+          command_id,
+          seit_actor: procedure.actor,
+          implementation_role: slice.role,
+          files: ["seit.json", "implementation.json"],
+        });
+      }
+    }
+  }
+  return findings;
+}
+
+/** #77: a light slice must run at least one command and be routed to the Light Implementer. */
+function checkWorkClass(node, findings = []) {
+  if (Array.isArray(node)) node.forEach((item) => checkWorkClass(item, findings));
+  else if (node && typeof node === "object") {
+    if (node.work_class === "light" && typeof node.id === "string") {
+      if (!(node.command_ids || []).length) findings.push({ code: "light_slice_without_command", step: node.id });
+      if (node.role !== "Light Implementer") findings.push({ code: "light_slice_role", step: node.id, role: node.role });
+    }
+    for (const value of Object.values(node)) checkWorkClass(value, findings);
+  }
+  return findings;
+}
+
+/** #80: Requirements Engineer is planning-only and never an Expedition slice. */
+function checkPlanningRoles(node, findings = []) {
+  if (Array.isArray(node)) node.forEach((item) => checkPlanningRoles(item, findings));
+  else if (node && typeof node === "object") {
+    if (typeof node.role === "string" && node.role.startsWith("Requirements Engineer")) {
+      findings.push({
+        code: "planning_role_in_expedition",
+        step: typeof node.id === "string" ? node.id : null,
+        role: node.role,
+      });
+    }
+    for (const value of Object.values(node)) checkPlanningRoles(value, findings);
+  }
+  return findings;
+}
+
+function repoRoot(dir) {
+  let current = path.resolve(dir);
+  for (;;) {
+    if (fs.existsSync(path.join(current, ".git"))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return path.resolve(dir);
+    current = parent;
+  }
+}
+
+function readJson(file) {
+  return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : null;
+}
+
+function verifyDigests(dir) {
+  const findings = [];
+  for (const name of ["seit.json", "implementation.json"]) {
+    if (!fs.existsSync(path.join(dir, name))) findings.push({ code: "missing_artifact", path: name });
+  }
+  if (findings.length) return { manifest_digest: null, findings };
+  const seit = readJson(path.join(dir, "seit.json"));
+  const implementation = readJson(path.join(dir, "implementation.json"));
+  const root = repoRoot(dir);
+  const inputs = seit?.source_baseline?.planning_inputs;
+  if (!Array.isArray(inputs) || !inputs.length) {
+    findings.push({ code: "missing_planning_inputs", path: "seit.json" });
+  }
+  const actual = [];
+  for (const input of inputs || []) {
+    if (typeof input?.path !== "string" || !/^[0-9a-f]{64}$/.test(input?.sha256 || "")) {
+      findings.push({ code: "malformed_planning_input", input });
+      continue;
+    }
+    const file = path.resolve(root, input.path);
+    if (!fs.existsSync(file)) {
+      findings.push({ code: "missing_input", path: input.path });
+      continue;
+    }
+    const digest = sha256(fs.readFileSync(file));
+    actual.push(digest);
+    if (digest !== input.sha256) {
+      findings.push({ code: "digest_mismatch", path: input.path, recorded: input.sha256, actual: digest });
+    }
+  }
+  // The manifest binds the planning inputs and seit.json itself (#70).
+  actual.push(sha256(fs.readFileSync(path.join(dir, "seit.json"))));
+  const manifest_digest = sha256(actual.join("\n"));
+  const recorded = implementation?.journey_settings?.planning_review?.candidate_digest;
+  if (typeof recorded !== "string" || !recorded) {
+    findings.push({ code: "missing_candidate_digest", actual: manifest_digest });
+  } else if (recorded !== manifest_digest) {
+    findings.push({ code: "candidate_digest_mismatch", recorded, actual: manifest_digest });
+  }
+  // #69: a specification Journey records an existing SDoc register at planning.
+  const settings = implementation?.journey_settings || {};
+  if (settings.journey_type === "specification") {
+    const register = settings.requirement_register;
+    if (typeof register !== "string" || !register.endsWith(".sdoc") || !fs.existsSync(path.resolve(root, register))) {
+      findings.push({ code: "missing_requirement_register", recorded: register ?? null });
+    }
+  }
+  return { manifest_digest, findings };
+}
+
+function freeze(dir) {
+  const digests = verifyDigests(dir);
+  const seit = readJson(path.join(dir, "seit.json"));
+  const implementation = readJson(path.join(dir, "implementation.json"));
+  const findings = [
+    ...checkRoles(seit, implementation),
+    ...checkWorkClass(implementation),
+    ...checkPlanningRoles(implementation),
+    ...digests.findings,
+  ];
+  return { outcome: findings.length ? "FAIL" : "PASS", manifest_digest: digests.manifest_digest, findings };
+}
+
+module.exports = { checkRoles, checkWorkClass, checkPlanningRoles, verifyDigests, freeze };
+
+if (require.main === module) {
+  const dir = process.argv[2];
+  if (!dir) {
+    process.stderr.write("usage: node hooks/plan-package.cjs <plan dir>\n");
+    process.exit(2);
+  }
+  const result = freeze(dir);
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  process.exit(result.outcome === "PASS" ? 0 : 1);
+}

package/hooks/planning-review.cjs

@@ -1,19 +1,6 @@
 "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 { PLANNING_REVIEW_POLICY: POLICY } = require("./policy.cjs");
 
 const sameCandidate = (a, b) =>
   POLICY.candidate_fields.every(
@@ -24,6 +11,14 @@ function evaluatePlanningReview(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     return { outcome: "NEEDS_MORE_EVIDENCE", reason: "planning_review_missing" };
   }
+  // #69: a specification Journey gates its requirement register at planning;
+  // existence on disk is checked by hooks/plan-package.cjs at the freeze.
+  if (
+    input.journey_type === "specification" &&
+    !(typeof input.requirement_register === "string" && input.requirement_register.endsWith(".sdoc"))
+  ) {
+    return { outcome: "NEEDS_MORE_EVIDENCE", reason: "missing_requirement_register" };
+  }
   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);

package/hooks/policy.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+/**
+ * Single policy source for the planning-review and assurance-budget
+ * evaluators (#63). The JSON blocks in
+ * skills/bearing-lite/references/review-policy.md and assurance-policy.md
+ * must equal these objects; test/policy-drift.test.mjs enforces it.
+ */
+
+const PLANNING_REVIEW_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 ASSURANCE_BUDGET_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",
+});
+
+module.exports = { PLANNING_REVIEW_POLICY, ASSURANCE_BUDGET_POLICY };

package/hooks/reconcile.cjs

@@ -0,0 +1,145 @@
+"use strict";
+
+/** Deterministically apply evidence events to Journey state (#64). */
+const fs = require("node:fs");
+
+const REQUIRED = [
+  "schema_version", "event_id", "source", "journey", "repository", "unit",
+  "candidate_revision", "generation", "evidence", "transition", "occurred_at",
+];
+const KINDS = new Set(["implementation", "verification", "assurance", "acceptance", "merge", "issue_close"]);
+const FIELDS = {
+  implementation: "implementation",
+  verification: "verification",
+  assurance: "assurance",
+  acceptance: "acceptance",
+  merge: "observed_merge",
+  issue_close: "observed_issue_close",
+};
+const PREDECESSORS = { verification: "implementation", assurance: "verification", acceptance: "assurance" };
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const nonempty = (value) => typeof value === "string" && value.length > 0;
+const only = (value, names) => Object.keys(value).every((name) => names.includes(name));
+const dateTime = (value) => nonempty(value) && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && !Number.isNaN(Date.parse(value));
+
+function receiptFor(event) {
+  return {
+    event_id: event?.event_id ?? null,
+    applied: false,
+    code: "invalid_event",
+    transition: event?.transition?.kind ?? null,
+    slice: event?.unit?.slice ?? null,
+    candidate_revision: event?.candidate_revision ?? null,
+    evidence_sha256: event?.evidence?.sha256 ?? null,
+  };
+}
+
+function structuralError(event) {
+  if (!object(event) || !REQUIRED.every((name) => Object.hasOwn(event, name)) || !only(event, REQUIRED)) return true;
+  if (event.schema_version !== 1 || !nonempty(event.event_id) || !nonempty(event.source) ||
+      !nonempty(event.journey) || !nonempty(event.repository) || !nonempty(event.candidate_revision) ||
+      !Number.isInteger(event.generation) || event.generation < 0 || !dateTime(event.occurred_at)) return true;
+  if (!object(event.unit) || !only(event.unit, ["wave", "slice"]) || !nonempty(event.unit.slice) ||
+      (Object.hasOwn(event.unit, "wave") && !nonempty(event.unit.wave))) return true;
+  if (!object(event.evidence) || !only(event.evidence, ["ref", "sha256"])) return true;
+  if (!object(event.transition) || !only(event.transition, ["kind", "verdict"]) ||
+      !KINDS.has(event.transition.kind) || !nonempty(event.transition.verdict)) return true;
+  return false;
+}
+
+function reject(state, receipt, code) {
+  return { state, receipt: { ...receipt, code, reason: code } };
+}
+
+function applyEvent(state, event, options = {}) {
+  const receipt = receiptFor(event);
+  if (structuralError(event)) return reject(state, receipt, "invalid_event");
+  if (options.expected_version !== undefined && options.expected_version !== state.version) {
+    return reject(state, receipt, "stale_write");
+  }
+  if (state.applied_event_ids.includes(event.event_id)) return reject(state, receipt, "duplicate_event");
+  if (event.journey !== state.journey || event.repository !== state.repository) {
+    return reject(state, receipt, "unrelated_journey");
+  }
+  if (event.generation < state.generation) return reject(state, receipt, "stale_generation");
+
+  const hasEvidence = nonempty(event.evidence.ref) && nonempty(event.evidence.sha256);
+  if (!hasEvidence && event.transition.verdict === "PASS") return reject(state, receipt, "bare_pass");
+  if (!hasEvidence) return reject(state, receipt, "missing_evidence");
+  if (!/^[0-9a-f]{64}$/.test(event.evidence.sha256)) return reject(state, receipt, "invalid_event");
+
+  const kind = event.transition.kind;
+  const slice = state.slices[event.unit.slice] || {};
+  const field = FIELDS[kind];
+  const prior = slice[field];
+  const history = prior ? {
+    ...prior.history,
+    [prior.candidate_revision]: { verdict: prior.verdict, sha256: prior.evidence.sha256 },
+  } : {};
+  const h = Object.hasOwn(history, event.candidate_revision) ? history[event.candidate_revision] : undefined;
+  if (h && (h.verdict !== event.transition.verdict || h.sha256 !== event.evidence.sha256)) {
+    return reject(state, receipt, "conflicting_receipt");
+  }
+  if (h) {
+    return reject(state, receipt, event.candidate_revision === prior.candidate_revision ? "duplicate_event" : "stale_candidate");
+  }
+
+  const implementation = slice.implementation;
+  if (["verification", "assurance", "acceptance"].includes(kind) &&
+      implementation?.candidate_revision !== event.candidate_revision) {
+    return reject(state, receipt, implementation ? "stale_candidate" : "predecessor_missing");
+  }
+  const predecessor = PREDECESSORS[kind];
+  if (predecessor && slice[predecessor]?.candidate_revision !== event.candidate_revision) {
+    return reject(state, receipt, "predecessor_missing");
+  }
+
+  const entry = {
+    candidate_revision: event.candidate_revision,
+    verdict: event.transition.verdict,
+    evidence: { ...event.evidence },
+    event_id: event.event_id,
+    history: { ...history, [event.candidate_revision]: { verdict: event.transition.verdict, sha256: event.evidence.sha256 } },
+  };
+  const next = {
+    ...state,
+    generation: Math.max(state.generation, event.generation),
+    version: state.version + 1,
+    applied_event_ids: [...state.applied_event_ids, event.event_id],
+    slices: { ...state.slices, [event.unit.slice]: { ...slice, [field]: entry } },
+  };
+  return { state: next, receipt: { ...receipt, applied: true, code: "applied" } };
+}
+
+function replay(state, events) {
+  const receipts = [];
+  let current = state;
+  for (const event of events) {
+    const result = applyEvent(current, event);
+    current = result.state;
+    receipts.push(result.receipt);
+  }
+  return { state: current, receipts };
+}
+
+function main(args = process.argv.slice(2)) {
+  const [stateFile, eventsFile] = args;
+  try {
+    if (!stateFile || !eventsFile) throw new Error("usage: node hooks/reconcile.cjs <state.json> <events.ndjson>");
+    const state = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+    const events = fs.readFileSync(eventsFile, "utf8").split(/\r?\n/).filter(Boolean).map(JSON.parse);
+    const result = replay(state, events);
+    const temporary = `${stateFile}.tmp-${process.pid}`;
+    fs.writeFileSync(temporary, JSON.stringify(result.state, null, 2) + "\n");
+    fs.renameSync(temporary, stateFile);
+    for (const receipt of result.receipts) process.stdout.write(JSON.stringify(receipt) + "\n");
+    return 0;
+  } catch (error) {
+    process.stderr.write(`${error.message}\n`);
+    return 1;
+  }
+}
+
+module.exports = { applyEvent, replay };
+
+if (require.main === module) process.exitCode = main();

package/hooks/te-host.cjs

@@ -584,6 +584,28 @@ function readStdinSync() {
   }
 }
 
+/**
+ * Project the internal response onto the host wire (#71). Codex validates
+ * hookSpecificOutput with additionalProperties:false per event, so only host
+ * fields go to stdout: a PreToolUse deny, a Stop/SubagentStop block, or an
+ * empty object (allow / fail-open). The full internal verdict goes to stderr
+ * for audit; the exit stays 0 so no host reads stderr as a blocking reason.
+ */
+function toWire(response) {
+  const inner = isPlainObject(response.hookSpecificOutput) ? response.hookSpecificOutput : {};
+  if (inner.permissionDecision === "deny") {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: inner.permissionDecisionReason,
+      },
+    };
+  }
+  if (response.decision === "block") return { decision: "block", reason: response.reason };
+  return {};
+}
+
 function main() {
   let raw = "";
   let response;
@@ -600,7 +622,8 @@ function main() {
       "adapter_failure: the test-engineering adapter could not run; unavailable"
     );
   }
-  process.stdout.write(JSON.stringify(response) + "\n");
+  process.stderr.write(JSON.stringify(response) + "\n");
+  process.stdout.write(JSON.stringify(toWire(response)) + "\n");
   process.exit(0);
 }
 
@@ -613,6 +636,7 @@ module.exports = {
   supportChannel,
   handle,
   toHostResponse,
+  toWire,
 };
 
 if (require.main === module) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphazede/bearing-lite",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "bearing-lite",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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/schemas/event.schema.json

@@ -0,0 +1,59 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/alphazede/bearing-lite/schemas/event.schema.json",
+  "title": "Bearing Lite evidence event",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version",
+    "event_id",
+    "source",
+    "journey",
+    "repository",
+    "unit",
+    "candidate_revision",
+    "generation",
+    "evidence",
+    "transition",
+    "occurred_at"
+  ],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "event_id": { "type": "string", "minLength": 1 },
+    "source": { "type": "string", "minLength": 1 },
+    "journey": { "type": "string", "minLength": 1 },
+    "repository": { "type": "string", "minLength": 1 },
+    "unit": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["slice"],
+      "properties": {
+        "wave": { "type": "string", "minLength": 1 },
+        "slice": { "type": "string", "minLength": 1 }
+      }
+    },
+    "candidate_revision": { "type": "string", "minLength": 1 },
+    "generation": { "type": "integer", "minimum": 0 },
+    "evidence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["ref", "sha256"],
+      "properties": {
+        "ref": { "type": "string", "minLength": 1 },
+        "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" }
+      }
+    },
+    "transition": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["kind", "verdict"],
+      "properties": {
+        "kind": {
+          "enum": ["implementation", "verification", "assurance", "acceptance", "merge", "issue_close"]
+        },
+        "verdict": { "type": "string", "minLength": 1 }
+      }
+    },
+    "occurred_at": { "type": "string", "format": "date-time" }
+  }
+}

package/schemas/implementation.schema.json

@@ -64,27 +64,50 @@
         "human_decision": { "type": ["string", "object", "null"] },
         "authority_id": { "type": ["string", "null"] },
         "dispatchable": { "type": "boolean" },
-        "slice_status": { "type": "string" }
+        "slice_status": { "type": "string" },
+        "work_class": {
+          "type": "string",
+          "enum": ["light", "judgement"],
+          "description": "light: inputs fully determine the output and the packet's command verifies it (skills/light-implementer). Default judgement."
+        },
+        "work_class_reason": { "type": "string", "minLength": 1 }
       },
-      "if": {
-        "not": {
-          "anyOf": [
-            {
-              "properties": { "dispatchable": { "const": false } },
-              "required": ["dispatchable"]
-            },
-            {
-              "properties": { "slice_status": { "const": "publication-blocked" } },
-              "required": ["slice_status"]
+      "allOf": [
+        {
+          "if": {
+            "not": {
+              "anyOf": [
+                {
+                  "properties": { "dispatchable": { "const": false } },
+                  "required": ["dispatchable"]
+                },
+                {
+                  "properties": { "slice_status": { "const": "publication-blocked" } },
+                  "required": ["slice_status"]
+                }
+              ]
             }
-          ]
-        }
-      },
-      "then": {
-        "properties": {
-          "authority_id": { "type": "string", "minLength": 1 }
+          },
+          "then": {
+            "properties": {
+              "authority_id": { "type": "string", "minLength": 1 }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": { "work_class": { "const": "light" } },
+            "required": ["work_class"]
+          },
+          "then": {
+            "required": ["work_class_reason"],
+            "properties": {
+              "role": { "const": "Light Implementer" },
+              "command_ids": { "minItems": 1 }
+            }
+          }
         }
-      }
+      ]
     }
   },
   "properties": {

package/schemas/journey.schema.json

@@ -23,7 +23,10 @@
       "properties": {
         "id": { "type": "string", "minLength": 1 },
         "title": { "type": "string", "minLength": 1 },
-        "status": { "type": "string", "minLength": 1 },
+        "status": {
+          "type": "string",
+          "enum": ["planning", "implementation", "complete", "cancelled"]
+        },
         "planning_repository": { "type": "string", "minLength": 1 }
       }
     },
@@ -50,7 +53,17 @@
         "candidate_revision": { "type": "string", "minLength": 1 },
         "acquired_at": { "type": "string", "minLength": 1 },
         "generation": { "type": "integer", "minimum": 1 },
-        "state": { "enum": ["active", "released"] }
+        "state": { "enum": ["active", "released"] },
+        "released_at": { "type": "string", "format": "date-time" },
+        "release_reason": { "type": "string", "minLength": 1 }
+      },
+      "if": {
+        "properties": {
+          "state": { "const": "released" }
+        }
+      },
+      "then": {
+        "required": ["released_at", "release_reason"]
       }
     },
     "history": {

package/skills/bearing-lite/SKILL.md

@@ -10,21 +10,22 @@ planning nodes return owner questions. Plugin hosts are partial; skill-copy is s
    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; 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
+3. Lineup comes only from `~/.agents/bearing-lite/lineups.json` per
+   `references/lineups.md`; a missing catalog returns `no_named_profiles`,
+   never a generated file; never infer identity values. The Router is observed, not selected.
+   The recorded snapshot is authoritative for this Journey. Later edits to
+   `~/.agents/bearing-lite/lineups.json` 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.
-   Follow `references/lineups.md` for catalog selection and save.
 6. Enforce `references/review-policy.md`. 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.
+   reasoning, cadence, and plan. Record the approved Journey type and snapshot.
    Never add a staged lineup or route-review gate.
    Dispatch only after approval.
-7. Crewmate and Explorer may continue in-wave.
+7. Crewmate and Explorer may continue in-wave. `work_class: light` slices go to the
+   Light Implementer; a `reclassify: judgement` return re-dispatches to the Crewmate.
    Use the visible wave receipt and update implementation and review once per wave.
 
 Return `READY`, `WAITING_ON`, `OWNER_DECISION_REQUIRED`, or `COMPLETE`.
@@ -35,12 +36,10 @@ deterministically without another review; failed repair/scope change returns
 `OWNER_DECISION_REQUIRED` naming the candidate and count. `COMPLETE` ends Bearing assurance.
 Authorized deployment without reopening review.
 Planning review is a separate pre-dispatch gate; it never consumes implementation
-`required_assurance`, `assurance_rounds`, or `max_assurance_rounds`.
+assurance.
 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.
+recovery needs explicit recorded generation increment and cannot steal a live lease.
 Selected or required capabilities activate. Unavailability of selected-or-required
 capability is a typed capability gap, not success and not invented behavior.
-Selected-only missing and required-only missing are typed gaps. Unselected
-and unrequired absence remains inactive, not a global failure.
+Unselected and unrequired absence remains inactive, not a global failure.
 Never implement, self-assure, select models, or publish.

package/skills/bearing-lite/references/lineups.md

@@ -22,6 +22,32 @@ Missing user file means no named profiles. Do not auto-create the live
 catalog. An empty `lineups` object is valid and is not an error. A
 malformed unused catalog cannot override explicit inline owner choices.
 
+## Configurable roles
+
+Catalog entries assign Explorer, Crewmate, Light Implementer, Test Engineer,
+Scribe, Plan Integrator, Systems Modeler, Integration Engineer, Requirements
+Engineer, Park Ranger, and Surveyor. The Light Implementer takes only slices
+whose `work_class` is `light` (criteria in `skills/light-implementer`); it
+has its own primary and fallbacks, usually a lighter and cheaper route. Navigator and Validator are not lineup roles;
+existing plans that still assign them use the compatibility diagnostics and
+treat the assignment as unused. Never fill agent, model, or reasoning values
+on the user's behalf. `review_cadence` is `at-end`.
+
+The Router is not a configurable role: it is whatever session is running
+planning. The Journey snapshot records the observed Router identity
+(harness, model, reasoning at that time). A catalog or snapshot entry with
+`role: Router` is ignored with the typed note `router_row_ignored`; it is
+never a deviation.
+
+Only verified primary unavailability activates its approved fallback. If
+both are unavailable, return `OWNER_DECISION_REQUIRED`.
+
+This catalog is the single lineup source. A legacy
+`~/.agents/bearing-lite/default-role-lineup.md` is never read or created;
+when one is present it is ignored with the typed note
+`legacy_lineup_md_ignored`. A missing catalog returns the typed outcome
+`no_named_profiles` and an inline-selection prompt.
+
 ## Validity
 
 Named selection and save require a valid catalog. Bind

package/skills/bearing-lite/templates/task.md

@@ -40,7 +40,10 @@ the integrated owner approval; do not offer `per-slice` or `per-round`.
 `journey` stays a proposal until the mapped implementation graph exists and the
 integrated owner review approves it. `lineup_snapshot` is authoritative after
 that approval. Later
-edits to `~/.agents/bearing-lite/default-role-lineup.md` have no effect.
+edits to `~/.agents/bearing-lite/lineups.json` have no effect. The `Router`
+row of the snapshot is the observed identity of the session that ran planning
+(harness, model, reasoning at that time); it is never a catalog selection and
+never a deviation.
 Replace it only through an explicit owner-confirmed dated visible amendment.
 Record the amendment date beside the replacement values. Dispatch identities
 come from this snapshot, not from the current global defaults file.

package/skills/light-implementer/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: light-implementer
+description: >
+  Execute one approved light slice exactly as its packet states, verified by
+  the packet's deterministic command. Use for Light Implementer, light,
+  mechanical, scaffold, bind, assemble, regenerate, or runbook packets. Do
+  not use for judgement work, authoring, repair, review, or any decision.
+---
+
+# Light Implementer
+
+The cheapest route in the ladder. Inputs fully determine the output, a
+command decides pass or fail, and nothing is decided in-session.
+
+## Inputs and match
+
+- **Inputs:** the Crewmate packet contract (baseline, objective, exact write
+  set, authority, commands, stop rule, return schema, visible wave receipt,
+  lineup identity from the recorded snapshot) for a slice whose
+  `work_class` is `light`.
+- **Match:** every criterion holds:
+  1. Inputs are all named and present: paths, digests, UIDs, a runbook.
+     Nothing is discovered or interpreted.
+  2. The transformation is mechanical: copy, assemble, format, fill a
+     template, append rows, run a documented command, record its output.
+  3. The packet names the command whose exit status verifies the output.
+  4. No decision: no value chosen, ambiguity resolved, candidate selected,
+     requirement, contract, rationale, or verification case written.
+  5. Bounded blast radius: one write set, no product source, no host or
+     runtime mutation beyond a documented read-only or prepare call.
+- **Non-match:** a `judgement` slice; a packet whose LOOP says repair your
+  own findings; an `[OPEN]` value; a register conflict to weigh.
+
+## Algorithm
+
+1. Revalidate the checkout lease exactly as the Crewmate does. On mismatch
+   return `WAITING_ON` without writing.
+2. Do exactly what the packet states, inside the write set, and nothing else.
+3. Run the packet's verification command at the candidate revision. Record
+   exit status, output digest, and changed paths.
+4. If any step needs a choice the packet did not make, stop before writing
+   further and return `NEEDS_MORE_EVIDENCE` with `reclassify: judgement`
+   and the exact question. Never guess, never escalate silently.
+5. There is no in-wave repair loop. A failing command returns the typed
+   failure with its output; the Router decides.
+
+## Return and recovery
+
+Return `CANDIDATE_READY`, `NEEDS_MORE_EVIDENCE`, `WAITING_ON`, or
+`OWNER_DECISION_REQUIRED` with verdict, candidate_ref, changed_paths, tests,
+findings, blocker, and `reclassify` when set.
+
+Never author, repair, self-certify, expand the write set, or publish.

package/skills/map-the-route/SKILL.md

@@ -15,7 +15,7 @@ Fresh planning node. The Router writes Journey state and owns owner conversation
 
 - **Match:** material intent is settled and any technical-plan, design, SEIT,
   implementation graph, or review HTML is missing.
-- **Inputs:** confirmed decisions, repository map and evidence, artifact status,
+- **Inputs:** confirmed decisions, workspace.md and evidence, artifact status,
   requirements register, repository rules, proposed owner-supplied lineup and
   `review_cadence: at-end`, plus the return schema.
 - **Non-match:** unresolved material scope, behavior, authority, risk, or
@@ -38,7 +38,8 @@ Fresh planning node. The Router writes Journey state and owns owner conversation
    `review_cadence: at-end`. Bind the planning-review slots to owner-supplied
    primary and ordered fallback route references under one candidate ref,
    revision, and digest. Use supplied identities; never invent them.
-4. After those stable source inputs, generate `implementation.json` and the
+4. After those stable source inputs, freeze: `node <plugin root>/hooks/plan-package.cjs <plan dir>`
+   must PASS; any finding halts. Then generate `implementation.json` and the
    self-contained offline `review.html` together. Each includes the proposed
    route, lineup, role states, reasoning, cadence, traceability, waves,
    recovery, approval boundaries, and register references versus Journey-local

package/skills/map-the-route/references/artifact-grammar.md

@@ -56,6 +56,13 @@ optional derived export and is never authority.
    Journey-local, so a reviewer can tell which artifact owns each statement.
 6. `design.md` is unaffected: it records how the work is built, which no
    requirements register covers.
+7. A specification-authoring Journey carries its requirement register (UID,
+   statement, rationale, verification method, allocation) as a planning
+   artifact: a draft `.sdoc` path (Markdown sections are not lint-checkable),
+   recorded as `implementation.json` `journey_settings.journey_type:
+   specification` plus `journey_settings.requirement_register`. The freeze
+   fails without an existing register; the Requirements Engineer gates it
+   before the integrated owner review; no Expedition wave re-gates it.
 
 ## Published standards
 
@@ -82,7 +89,9 @@ optional derived export and is never authority.
    case | Negative/failure case | Command/procedure ID | Evidence.
 5. Every row carries exactly one SEIT row ID, requirement ID, design ID, and
    command ID, and names an observable failure.
-6. Bind a stable decision-baseline projection of confirmed decision identities
+6. For a specification wave, each case-authoring proof row cites the planning
+   register gate receipt.
+7. Bind a stable decision-baseline projection of confirmed decision identities
    and open-item statuses rather than the whole-file `journey.json` digest.
 
 ## Implementation rules
@@ -94,18 +103,26 @@ optional derived export and is never authority.
    owner-selected model route, reasoning, review path, write set, command IDs,
    stop condition, human decision, and `authority_id`. Goals are at most 512
    characters. Slice actions and write sets are subsets of current authority.
-3. Optional fields are Shared interfaces (`path#Symbol`), Integration
+3. `work_class` is `light` or `judgement` (default). A `light` slice names
+   the Light Implementer role, at least one command id, and a
+   `work_class_reason`; see `skills/light-implementer` for the criteria.
+4. For `journey_type: specification`, a specification-authoring Expedition
+   wave defaults to scaffold → author from the gated register → Test Engineer
+   verification cases → bind to the host → readback of the bound revision and
+   digest from the host → Park Ranger with both named in the review
+   request → owner decision. A deviation is a planning-review finding.
+5. Optional fields are Shared interfaces (`path#Symbol`), Integration
    boundary, Published standard (`doc#clause`) when applicable, SysML and
    integration fields when selected, and Parallel safe (`yes` or `no` plus
    reason).
-4. Write sets use one line: `Write only `path``. Paths are bounded, normalized,
+6. Write sets use one line: `Write only `path``. Paths are bounded, normalized,
    repository-relative literals. Put prohibitions in prose, not the write set.
-5. Multi-slice plans declare consecutive `Wave <n>: <ids>` lines. Every slice
+7. Multi-slice plans declare consecutive `Wave <n>: <ids>` lines. Every slice
    belongs to one wave. Dependencies use acyclic `S1 --> S2` arrows.
-6. Ordered integration steps, resources, ownership, and rollback live here.
+8. Ordered integration steps, resources, ownership, and rollback live here.
    Owner-configured reviewer count `n`, repair bound `k`, and confirmation
    count `c` are explicit fields with no assistant default integers.
-7. Plans may contain at most 128 slices, manifests, write paths, and commands.
+9. Plans may contain at most 128 slices, manifests, write paths, and commands.
    Aim for at most 500 estimated tokens per slice plus manifest; split larger
    packets when practical.
 

package/skills/plan-integrator/SKILL.md

@@ -23,9 +23,18 @@ the five artifacts, and generates `implementation.json` and two-state
 
 1. Cross-validate the five canonical artifacts. Copy design-lens names
    from design.md; never invent lens IDs.
-2. Generate `implementation.json` and `review.html` (`planning-review`,
+2. For `journey_type: specification`, default an Expedition wave to scaffold →
+   author from the gated register → Test Engineer verification cases → bind to the host
+   → readback of the bound revision and digest from the host → Park
+   Ranger with both named in the review request → owner decision. A deviation
+   is a planning-review finding.
+3. Generate `implementation.json` and `review.html` (`planning-review`,
    then `final-closeout`) when inputs are stable.
-3. Request a Planning Test Engineer delta after relevant decision,
+4. Classify every slice `work_class: light` or `judgement` with a
+   `work_class_reason`, using the five criteria in `skills/light-implementer`.
+   Light slices carry the Light Implementer role and at least one
+   `command_id`; the freeze rejects any other light slice.
+5. Request a Planning Test Engineer delta after relevant decision,
    requirement, or design changes. Do not author V&V.
 
 ## Return and recovery

package/skills/requirements-engineer/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: requirements-engineer
+description: >
+  One Requirements Engineer role, planning stage only. Use for the
+  requirement register quality gate after Gather Supplies and before the
+  Systems Modeler finalizes mappings. Do not use inside an Expedition wave,
+  or for V&V, SysML modeling, implementation, defect review, or publication.
+---
+
+# Requirements Engineer
+
+One role, one planning session. It owns requirement quality: every statement
+is precise, measurable, traceable, allocated, and verification-ready.
+Requirements are fixed at plan approval; an Expedition wave stores, binds,
+adds verification cases, and publishes approved statements and never re-gates
+them (the Assurance Test Engineer re-verifies at wave end). It never persists
+SDoc, publishes, selects models or lineups, or writes tests.
+
+## Inputs and match
+
+- **Inputs:** settled owner decisions, the requirement register as a planning
+  artifact (UID, statement, rationale, verification method, allocation: a
+  draft `.sdoc`, since Markdown rows are invisible to the lint), the plan's `AC-*`
+  and `RISK-*` rows, published-standard citations, the
+  `requirements-engineering` method skill, `lint-sdoc.py --profile library`
+  output, compact return schema.
+- **Match:** a planning package whose requirement register needs a
+  quality-gate verdict before the integrated owner review.
+- **Non-match:** any Expedition wave, design, SEIT, implementation, Park
+  Ranger, Surveyor.
+
+## Algorithm
+
+1. Run after Gather Supplies and before the Systems Modeler finalizes
+   mappings, on the requirement statements themselves: gate every register
+   row's statement, rationale, verification method, and allocation, and the
+   `AC-*`/`RISK-*` rows that cite them, against the NASA-adapted checklist;
+   reject escape clauses and undefined terms; every row cites its register
+   identity or is marked Journey-local.
+2. Cite the mechanical output (`lint-sdoc.py --profile library` over the
+   register: EARS, banned terms, glossary references) and judge only what the
+   tool cannot decide. Missing tool output is `NEEDS_MORE_EVIDENCE`.
+3. When a published standard is cited, verify the document and clause.
+4. Return the smallest set of failing rows. Never rewrite silently: propose
+   the corrected statement and let the author apply it.
+
+## Return and recovery
+
+Return `PASS`, `REPAIRABLE_FAILURE`, `NEEDS_MORE_EVIDENCE`, or
+`NEEDS_OWNER_DECISION` with verdict, candidate_ref, changed_paths, per-row
+findings, and blocker. Rerun the gate on each corrected register within Map the
+Route's correction rounds. Exhaustion with fixable rows returns
+`NEEDS_OWNER_DECISION` listing those rows, never silent acceptance. Missing
+`requirements-engineering` method skill is a typed capability gap.
+
+Never implement, model, self-certify, persist or publish SDoc, or grant
+owner-only approval.

package/skills/set-bearings/SKILL.md

@@ -15,19 +15,28 @@ Fresh planning node. The Router announces `Setting Our Bearings in <repo>.`
 
 - **Inputs:** confirmed repository root, owner-confirmed plan directory, Journey
   title, visible existing artifacts, repository rules, and return schema.
-- **Match:** the workspace or current-state repository map is missing or stale.
+- **Match:** the workspace or repository map is missing or stale.
 - **Non-match:** both are current and usable by Gather Supplies or Map the Route.
 
 ## Algorithm
 
 1. Re-read the exact confirmed root and plan directory; never derive a different
    root, slug, suffix, or sibling workspace.
-2. Preserve every existing artifact and unrelated edit. Resume rather than
-   replace an existing Journey.
-3. Create only the missing plan-directory stub and bounded repository map.
-4. Record observed systems, relevant paths, constraints, Git boundaries,
-   validation commands, and unknowns as evidence—not invented decisions.
-5. Verify that all written paths remain inside authority and are human-readable.
+2. If `workspace.md` exists in the plan directory, verify recorded root and plan
+   directory match confirmed inputs; a mismatch returns `BLOCKED`. Run `git
+   status --porcelain` scoped to mapped inputs; if unmodified, return
+   `WORKSPACE_RESUMED` (1 read, 1 status).
+3. Bound discovery: depth 2, max 40 paths, max 64 KiB, read-only. Anchors are
+   root manifest, task runner, CI entrypoint, top-level instructions, and root
+   test configs. Strictly prohibit discovery traversal into repo-relative
+   `src/`, `lib/`, `vendor/`, and `docs/`.
+4. If bounds are exhausted before required anchors are found, return
+   `NEEDS_EVIDENCE` naming the missing anchor. Never compose unobserved commands.
+5. Create missing plan directory or update `workspace.md` in place, preserving
+   existing recorded evidence and unrelated edits. Initialize a missing file
+   from `templates/workspace.md`. Quote validation commands with source and mark
+   `[observed, not run]`. Drop detail before Constraints and Unknowns.
+6. Verify written paths remain inside authority and return `WORKSPACE_READY`.
 
 ## Return and recovery
 

package/skills/set-bearings/templates/workspace.md

@@ -0,0 +1,28 @@
+# Workspace Environment: <journey-topic>
+
+## Repository Identity
+- Root: `<repository-root>`
+- Plan directory: `<plan-directory>`
+
+## Mapped Inputs
+- `<relative-path>`: `<what it establishes>`
+
+## Observed Systems
+- `<relative-directory>`: `<subsystem>`
+
+## Constraints and Git Boundaries
+- Branch / Worktree: `<branch>` (clean | dirty)
+- Rules: `<applicable-rules>`
+
+## Validation Commands [observed, not run]
+- Test: `<command>` (source: `<anchor-file>`) [observed, not run]
+- Lint: `<command>` (source: `<anchor-file>`) [observed, not run]
+- Build: `<command>` (source: `<anchor-file>`) [observed, not run]
+
+## Unknowns
+- `<unknown or none observed>`
+
+## Map Freshness
+- Tier 1: Recorded root and plan directory match confirmed inputs.
+- Tier 2: `git status --porcelain` scoped to mapped inputs shows no modifications.
+- Note: Does not detect committed changes postdating this observation.

package/skills/test-engineer/SKILL.md

@@ -27,6 +27,8 @@ separate catalog roles.
    reconciliation and performs delta reconciliation after relevant
    decision, requirement, or design changes. Do not invent missing
    method-skill behavior.
+   Expedition in-document verification cases are authored only against the
+   approved, planning-gated register.
 2. Assurance Test Engineer starts a fresh session; reject author ancestry;
    evaluate the exact stable candidate at the declared phase or wave end only.
    VALIDATING is owned here.

package/skills/bearing-lite/templates/default-role-lineup.md

@@ -1,32 +0,0 @@
-# Bearing Lite global defaults
-
-Store the user-owned copy at
-`~/.agents/bearing-lite/default-role-lineup.md`. The Router displays it before
-implementation and asks whether it is good for the current Journey. Never fill
-agent, model, or reasoning values on the user's behalf.
-
-```markdown
-review_cadence: at-end
-
-| Role | Primary agent/harness | Primary model | Primary reasoning | Fallback agent/harness | Fallback model | Fallback reasoning |
-| --- | --- | --- | --- | --- | --- | --- |
-| Router | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Explorer | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Crewmate | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Test Engineer | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Scribe | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Plan Integrator | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Systems Modeler | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Integration Engineer | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Park Ranger | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-| Surveyor | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET | OWNER_TO_SET |
-```
-
-Navigator is not a normal lineup role. Existing plans that still assign it use
-the Navigator compatibility diagnostic; treat the assignment as unused.
-Validator is not a normal lineup role. Existing plans that still assign it use
-the Validator compatibility diagnostic; treat the assignment as unused.
-
-Journey artifacts copy the confirmed values and mark named instances active,
-standby, or unused. Only verified primary unavailability activates its approved
-fallback. If both are unavailable, return `OWNER_DECISION_REQUIRED`.