@alphazede/bearing-lite 0.2.0 → 0.2.2

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/hooks/transition-order.cjs

@@ -12,6 +12,7 @@ const OUTCOMES = Object.freeze(["ADVISE", "REROUTE", "BLOCK", "UNAVAILABLE"]);
 const ENFORCEMENT = "procedural";
 const { evaluatePlanningReview } = require("./planning-review.cjs");
 const { evaluateAssuranceBudget } = require("./assurance-budget.cjs");
+const { evaluateOwnerStop } = require("./owner-stops.cjs");
 
 const RECOVERY_UNAVAILABLE =
   "Keep the current state, run the transition checklist procedurally, and record the result before retrying";
@@ -132,6 +133,17 @@ function evaluate(input) {
       return result("ADVISE", "channel_open", RECOVERY_CHANNEL);
     }
 
+    if (input.action_kind === "owner_stop_check") {
+      const stop = evaluateOwnerStop(input.owner_stop);
+      return {
+        ...result(stop.disposition === "NEEDS_MORE_EVIDENCE" ? "UNAVAILABLE" :
+          stop.disposition === "ASK" ? "REROUTE" : "ADVISE",
+        "owner_stop:" + stop.disposition + ":" + stop.reason,
+        "Apply references/owner-stops.md; this check grants no action or dispatch authority"),
+        owner_stop: stop,
+      };
+    }
+
     if (input.action_kind === "planning_review_transition") {
       const verdict = evaluatePlanningReview(input.planning_review);
       if (verdict.outcome === "PASS") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphazede/bearing-lite",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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.2",
   "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/authority.schema.json

@@ -23,28 +23,22 @@
     "approval_receipt"
   ],
   "properties": {
-    "schema_version": { "type": "string", "minLength": 1 },
-    "schema": { "type": "string", "minLength": 1, "description": "Envelope schema identity" },
-    "id": { "type": "string", "minLength": 1, "description": "Authority envelope ID" },
-    "state": { "type": "string", "minLength": 1 },
-    "subject": { "type": "object", "minProperties": 1, "additionalProperties": true },
-    "repositories": {
-      "type": "array",
-      "items": { "type": "object", "additionalProperties": true }
-    },
-    "baseline": { "type": "object", "minProperties": 1, "additionalProperties": true },
-    "granting_owner_decisions": {
-      "type": "array",
-      "items": { "type": "string", "minLength": 1 }
-    },
+    "schema_version": {"type": "string", "minLength": 1},
+    "schema": {"type": "string", "minLength": 1, "description": "Envelope schema identity"},
+    "id": {"type": "string", "minLength": 1, "description": "Authority envelope ID"},
+    "state": {"type": "string", "minLength": 1},
+    "subject": {"type": "object", "minProperties": 1, "additionalProperties": true},
+    "repositories": {"type": "array", "items": {"type": "object", "additionalProperties": true}},
+    "baseline": {"type": "object", "minProperties": 1, "additionalProperties": true},
+    "granting_owner_decisions": {"type": "array", "items": {"type": "string", "minLength": 1}},
     "allowed": {
       "type": "object",
       "additionalProperties": true,
       "required": ["scope", "actions", "paths"],
       "properties": {
-        "scope": { "type": "array", "items": { "type": "string" } },
-        "actions": { "type": "array", "items": { "type": "string" } },
-        "paths": { "type": "array", "items": { "type": "string" } }
+        "scope": {"type": "array", "items": {"type": "string"}},
+        "actions": {"type": "array", "items": {"type": "string"}},
+        "paths": {"type": "array", "items": {"type": "string"}}
       }
     },
     "prohibited": {
@@ -52,24 +46,51 @@
       "additionalProperties": true,
       "required": ["scope", "actions", "paths"],
       "properties": {
-        "scope": { "type": "array", "items": { "type": "string" } },
-        "actions": { "type": "array", "items": { "type": "string" } },
-        "paths": { "type": "array", "items": { "type": "string" } }
+        "scope": {"type": "array", "items": {"type": "string"}},
+        "actions": {"type": "array", "items": {"type": "string"}},
+        "paths": {"type": "array", "items": {"type": "string"}}
       }
     },
-    "role_grants": {
-      "type": "array",
-      "items": { "type": "object", "additionalProperties": true }
-    },
-    "effective": { "type": "boolean", "description": "Machine-enforced effectiveness. Boolean only: a string is not an effectiveness decision." },
-    "expiry_conditions": {
-      "type": "array",
-      "items": { "type": "string", "minLength": 1 }
-    },
-    "supersedes": {
-      "type": "array",
-      "items": { "type": "string" }
+    "role_grants": {"type": "array", "items": {"type": "object", "additionalProperties": true}},
+    "effective": {
+      "type": "boolean",
+      "description": "Machine-enforced effectiveness. Boolean only: a string is not an effectiveness decision."
     },
-    "approval_receipt": { "type": "object", "additionalProperties": true }
-  }
+    "expiry_conditions": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "supersedes": {"type": "array", "items": {"type": "string"}},
+    "approval_receipt": {"type": "object", "additionalProperties": true},
+    "continuation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["granted", "owner_decision_id", "exclusions", "expires_at"],
+      "properties": {
+        "granted": {"type": "boolean"},
+        "owner_decision_id": {"type": "string", "minLength": 1},
+        "exclusions": {
+          "type": "array",
+          "uniqueItems": true,
+          "items": {"type": "string", "minLength": 1},
+          "allOf": [
+            {"contains": {"const": "scope_change"}},
+            {"contains": {"const": "budget_exhaustion"}},
+            {"contains": {"const": "owner_hold"}},
+            {"contains": {"const": "owner_only_actions"}}
+          ]
+        },
+        "expires_at": {"type": ["string", "null"], "format": "date-time", "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{3})?Z$"}
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": {"required": ["continuation"]},
+      "then": {
+        "properties": {
+          "expiry_conditions": {"minItems": 1},
+          "granting_owner_decisions": {"minItems": 1},
+          "approval_receipt": {"minProperties": 1}
+        }
+      }
+    }
+  ]
 }

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": {