@alphazede/bearing-lite 0.2.0 → 0.2.2

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
@@ -151,12 +151,23 @@ explain orientation; they never authorize a transition.
 
 ## Roles and authority
 
+Owner questions follow [the owner-stop policy](skills/bearing-lite/references/owner-stops.md).
+The integrated approval records bounded continuation with exclusions and expiry.
+The Router applies approved policy and fallbacks, batches nonblocking questions,
+and continues ready independent work while dependent work waits. Approval shows
+the first-package summary or subsequent changes with the complete package available.
+Local receipt metrics distinguish questions, round trips, response intervals and
+fully blocked time; no telemetry leaves the checkout. The transition preflight
+and scheduling remain procedural, including on skills-only hosts. A legacy
+Journey without explicit timing coverage reports unavailable, not zero wait.
+
 | Role | What it is | Executes | Notes |
 |---|---|---|---|
 | **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 | 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 +212,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

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 "use strict";
 
+const { ownerWaitMetrics } = require("./owner-stops.cjs");
+
 /**
  * Bearing Lite return/closeout adapter (CONTRACT-HOOK-01).
  * Advisory for ordinary handoff reminders; may BLOCK only protected completion.
@@ -39,6 +41,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 =
@@ -141,6 +156,21 @@ function evaluate(input) {
       return result("ADVISE", "channel_open", RECOVERY_CHANNEL);
     }
 
+    // Explicit invocation by Router; native Stop mappings do not supply Journey JSON.
+    if (input.action_kind === "owner_wait_summary") {
+      if (input.mode === "protected_completion" || input.protected_completion === true) {
+        return unavailable("owner_wait_summary_is_not_completion");
+      }
+      try {
+        const metrics = ownerWaitMetrics(input.journey, input.as_of);
+        return { ...result("ADVISE", "owner_wait:" + metrics.status,
+          "Render metrics and coverage in the wave or closeout receipt; no authority is granted"),
+        owner_wait: metrics };
+      } catch {
+        return unavailable("owner_wait_records_invalid");
+      }
+    }
+
     const mode =
       input.mode === "protected_completion" || input.protected_completion === true
         ? "protected_completion"
@@ -169,6 +199,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 +315,7 @@ module.exports = {
   ENFORCEMENT,
   HANDOFF_FIELDS,
   VERDICT_VALUES,
+  NEGATIVE_VERDICTS,
   evaluate,
 };
 

package/hooks/owner-stops.cjs

@@ -0,0 +1,154 @@
+"use strict";
+
+// Procedural owner-stop preflight and local receipt metrics; never grants authority.
+const fs = require("node:fs");
+const object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const text = (v) => typeof v === "string" && v.trim().length > 0;
+const classes = ["A", "B", "C", "D", "E", "F"];
+const exclusions = ["scope_change", "budget_exhaustion", "owner_hold", "owner_only_actions"];
+
+function timestamp(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value)) {
+    throw new Error("invalid_utc_timestamp");
+  }
+  const n = Date.parse(value);
+  if (!Number.isFinite(n) || new Date(n).toISOString() !== (value.includes(".") ? value : value.replace("Z", ".000Z"))) {
+    throw new Error("invalid_utc_timestamp");
+  }
+  return n;
+}
+
+function evaluateOwnerStop(input) {
+  const unknown = (reason) => ({ disposition: "NEEDS_MORE_EVIDENCE", reason });
+  if (!object(input) || !classes.includes(input.class) || typeof input.blocking !== "boolean" || !text(input.evidence_ref)) {
+    return unknown("owner_stop_input_missing");
+  }
+  if (["C", "E", "F"].includes(input.class)) {
+    return { disposition: input.blocking ? "ASK" : "QUEUE", reason: "owner_boundary" };
+  }
+  const a = input.authority;
+  const grant = a?.continuation;
+  if (!object(a) || a.effective !== true || a.state !== "active" || !text(a.id) ||
+      !object(a.approval_receipt) || Object.keys(a.approval_receipt).length === 0 ||
+      !object(grant) || grant.granted !== true || !text(grant.owner_decision_id) ||
+      !Array.isArray(a.granting_owner_decisions) || !a.granting_owner_decisions.includes(grant.owner_decision_id) ||
+      !Array.isArray(a.expiry_conditions) || !a.expiry_conditions.length || !a.expiry_conditions.every(text) ||
+      !Array.isArray(grant.exclusions) || !exclusions.every((item) => grant.exclusions.includes(item))) {
+    return unknown("continuation_grant_missing");
+  }
+  try {
+    const now = timestamp(input.checked_at);
+    if (grant.expires_at !== null && timestamp(grant.expires_at) <= now) return unknown("continuation_expired");
+  } catch {
+    return unknown("continuation_expiry_unverified");
+  }
+  const checks = ["scope", "budget", "exclusions", "expiry", "owner_hold"];
+  if (input.class === "A") checks.push("policy");
+  if (input.class === "B") checks.push("fallback");
+  if (!object(input.checks) || !checks.every((key) => input.checks[key] === true) || !text(input.resolution_ref)) {
+    return unknown("continuation_conditions_unverified");
+  }
+  return { disposition: "CONTINUE", reason: "approved_resolution", authority_id: a.id };
+}
+
+function unionLength(intervals) {
+  let total = 0;
+  let end = -Infinity;
+  for (const [start, stop] of intervals.sort((a, b) => a[0] - b[0])) {
+    total += Math.max(0, stop - Math.max(start, end));
+    end = Math.max(end, stop);
+  }
+  return total;
+}
+
+function ownerWaitMetrics(journey, asOf) {
+  if (!object(journey)) throw new Error("journey_missing");
+  if (journey.owner_wait_tracking === undefined || journey.owner_wait_tracking === false) {
+    return { status: "unavailable", reason: "owner_wait_not_tracked" };
+  }
+  if (journey.owner_wait_tracking !== true || !Array.isArray(journey.decisions) ||
+      !Array.isArray(journey.open_decisions) || !Array.isArray(journey.owner_blocked_intervals)) {
+    throw new Error("owner_wait_records_missing");
+  }
+  const now = timestamp(asOf);
+  const counts = Object.fromEntries(classes.map((key) => [key, 0]));
+  const metrics = { status: "measured", as_of: asOf, decisions_asked: 0, round_trips: 0,
+    queued: 0, pending: 0, cancelled: 0, by_class: counts,
+    response_ms: 0, pending_response_ms: 0, response_window_ms: 0, blocked_ms: 0 };
+  const ids = new Set();
+  const rounds = new Map();
+  const responses = [];
+  const windows = new Map();
+  for (const q of [...journey.decisions, ...journey.open_decisions]) {
+    if (!object(q) || q.record_type !== "owner_stop") continue;
+    if (!text(q.id) || ids.has(q.id)) throw new Error("duplicate_or_missing_decision_id");
+    ids.add(q.id);
+    if (!classes.includes(q.class) || !["queued", "asked", "answered", "cancelled"].includes(q.status) ||
+        !text(q.question) || !text(q.evidence_ref) || !text(q.why_owner) ||
+        typeof q.blocking !== "boolean" || !Array.isArray(q.affected_slices) || !q.affected_slices.every(text) ||
+        !["asked_at", "answered_at", "cancelled_at", "round_trip_id"].every((key) => Object.hasOwn(q, key))) {
+      throw new Error("invalid_owner_stop_record");
+    }
+    const asked = q.asked_at === null ? null : timestamp(q.asked_at);
+    const answered = q.answered_at === null ? null : timestamp(q.answered_at);
+    const cancelled = q.cancelled_at === null ? null : timestamp(q.cancelled_at);
+    const created = timestamp(q.created_at);
+    if (created > now || (asked !== null && (asked < created || asked > now))) throw new Error("invalid_question_time");
+    if (q.status === "queued" && (asked !== null || answered !== null || cancelled !== null)) throw new Error("invalid_queued_question");
+    if (q.status === "asked" && (asked === null || answered !== null || cancelled !== null)) throw new Error("invalid_pending_question");
+    if (q.status === "answered" && (asked === null || answered === null || cancelled !== null || !text(q.answer_ref))) throw new Error("invalid_answered_question");
+    if (q.status === "cancelled" && (cancelled === null || answered !== null)) throw new Error("invalid_cancelled_question");
+    const end = answered ?? cancelled ?? now;
+    if (end < (asked ?? created) || end > now) throw new Error("invalid_response_time");
+    if (q.status === "queued") metrics.queued++;
+    if (q.status === "asked") metrics.pending++;
+    if (q.status === "cancelled") metrics.cancelled++;
+    if (asked === null) {
+      if (q.round_trip_id !== null) throw new Error("unasked_round_trip");
+      continue;
+    }
+    if (!text(q.round_trip_id)) throw new Error("round_trip_missing");
+    if (rounds.has(q.round_trip_id) && rounds.get(q.round_trip_id) !== asked) {
+      throw new Error("inconsistent_round_trip_time");
+    }
+    rounds.set(q.round_trip_id, asked);
+    metrics.decisions_asked++;
+    counts[q.class]++;
+    responses.push([asked, end]);
+    windows.set(q.id, [asked, end]);
+    if (answered !== null) metrics.response_ms += end - asked;
+    if (q.status === "asked") metrics.pending_response_ms += now - asked;
+  }
+  const blocked = [];
+  for (const interval of journey.owner_blocked_intervals) {
+    if (!object(interval) || !Array.isArray(interval.decision_ids) || !interval.decision_ids.length ||
+        !interval.decision_ids.every(text) || new Set(interval.decision_ids).size !== interval.decision_ids.length ||
+        !Object.hasOwn(interval, "ended_at")) throw new Error("invalid_blocked_interval");
+    const start = timestamp(interval.started_at);
+    const end = interval.ended_at === null ? now : timestamp(interval.ended_at);
+    if (start > end || end > now) throw new Error("invalid_blocked_time");
+    for (const id of interval.decision_ids) {
+      const window = windows.get(id);
+      if (!window || start < window[0] || end > window[1]) throw new Error("blocked_interval_outside_question");
+    }
+    blocked.push([start, end]);
+  }
+  metrics.round_trips = rounds.size;
+  metrics.response_window_ms = unionLength(responses);
+  metrics.blocked_ms = unionLength(blocked);
+  return metrics;
+}
+
+module.exports = { evaluateOwnerStop, ownerWaitMetrics };
+
+if (require.main === module) {
+  try {
+    const [file, asOf] = process.argv.slice(2);
+    if (!file || !asOf) throw new Error("usage: owner-stops.cjs <journey.json> <as-of-UTC>");
+    console.log(JSON.stringify(ownerWaitMetrics(JSON.parse(fs.readFileSync(file, "utf8")), asOf)));
+  } catch (error) {
+    console.log(JSON.stringify({ status: "invalid", reason: error.code ? "journey_unreadable" :
+      /^[a-z_]+$/.test(error.message) ? error.message : "invalid_journey_input" }));
+    process.exitCode = 1;
+  }
+}

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