@alphazede/bearing-lite 0.2.2 → 1.0.0

package/hooks/com.anthropic.claude-code/mapping.md

@@ -17,9 +17,13 @@ procedural.
 | AGY | `.agy/` (strict `plugin.json`) | none | skills-only |
 | Pi | `package.json` `"pi"` + `pi-package` | none (TypeScript extensions, not command hooks) | skills-only |
 | DeepCode | `.deepcode/skills` or interoperable `.agents/skills` discovery | none | skills-only |
+| GitHub Copilot | Agent Plugins 1.0 `plugin.json` + `com.github.copilot/` | `com.github.copilot/hooks/hooks.json` (`SessionStart`, `PreToolUse`, `Stop`, `SubagentStop`) | partial |
 
-Do **not** set `hooks` on Claude, Codex, or Grok host manifests. Those hosts
-auto-load `hooks/hooks.json`; declaring both is a duplicate-file error.
+Do **not** set `hooks` on the root Agent Plugins 1.0 `plugin.json`, or on Claude,
+Codex, or Grok host manifests. Root `hooks` is outside the closed Agent Plugins
+1.0 field set. Claude, Codex, and Grok auto-load `hooks/hooks.json`; declaring
+both is a duplicate-file error. GitHub Copilot in VS Code discovers plugin hooks
+from `com.github.copilot/hooks/hooks.json`.
 
 Skill-copy into a host skills directory does **not** register hooks. Plugin
 install or disable uses the host's native controls. Bearing Lite never copies
@@ -43,19 +47,19 @@ registered separately, and a `Stop` event reaches both.
 The shared planning-review evaluator is used by transition and closeout when a
 client supplies a structured `planning_review` record. Current session-start /
 stop mappings cannot derive that nested record safely, so Claude Code, Codex,
-Grok Build, Cursor, and Kimi remain partial and the check is procedural there.
-AGY, Pi, and DeepCode remain skills-only. Do not claim full planning-review
-enforcement for any of these hosts until a native event supplies the complete
-record.
+Grok Build, Cursor, Kimi, and GitHub Copilot remain partial and the check is
+procedural there. AGY, Pi, and DeepCode remain skills-only. Do not claim full
+planning-review enforcement for any of these hosts until a native event supplies
+the complete record.
 
 The per-declared-phase-or-wave assurance record
 (`skills/bearing-lite/references/assurance-policy.md`) is evaluated by the same
 `transition` class through the `assurance_transition` action_kind. No mapped
 host exposes a hook event that carries the frozen declaration and the visible
 task record, so the assurance budget is procedural on every mapped host:
-Claude Code, Codex, Grok Build, Cursor, and Kimi Code stay partial, and AGY,
-Pi, and DeepCode stay skills-only. No host may advertise an enforcement of the
-assurance budget it cannot perform.
+Claude Code, Codex, Grok Build, Cursor, Kimi Code, and GitHub Copilot stay
+partial, and AGY, Pi, and DeepCode stay skills-only. No host may advertise an
+enforcement of the assurance budget it cannot perform.
 
 The adapter accepts snake_case and camelCase (`hook_event_name` /
 `hookEventName`, `cwd` / `workspaceRoot`).
@@ -108,13 +112,24 @@ this adapter must not advertise enforcement it cannot perform.
 | Pi | te_test_write UNAVAILABLE | te_completion UNAVAILABLE | child te_completion UNAVAILABLE |
 | AGY | te_test_write UNAVAILABLE | te_completion UNAVAILABLE | child te_completion UNAVAILABLE |
 | DeepCode | te_test_write UNAVAILABLE | te_completion UNAVAILABLE | child te_completion UNAVAILABLE |
+| GitHub Copilot | native `PreToolUse` deny | native `Stop` deny | native `SubagentStop` deny |
 
 Cursor's `stop` guidance message is advisory text, not a hard completion
 block, and Cursor exposes no distinct hard child-stop deny; neither is
 registered as one. Kimi Code, Pi, AGY, and DeepCode carry no verified native
-Test Engineering blocking at all, so `hooks/te-host.cjs` returns `UNAVAILABLE`
-for every class on those hosts rather than claiming an enforcement it cannot
-deliver.
+Test Engineering blocking in this adapter, so `hooks/te-host.cjs` returns
+`UNAVAILABLE` for every class on those hosts rather than claiming an
+enforcement it cannot deliver.
+
+GitHub Copilot in VS Code is a native TE host. Agent Plugins 1.0 discovers
+`com.github.copilot/hooks/hooks.json` and expands `${PLUGIN_ROOT}`; the TE
+commands quote that path and pass `--host=copilot`. Copilot `PreToolUse` denies
+through `hookSpecificOutput.permissionDecision`. Copilot `Stop` denies through
+`hookSpecificOutput` with `hookEventName` `Stop`, `decision` `block`, and
+`reason`. Copilot `SubagentStop` denies through a top-level `decision` block
+and `reason`. `Stop` and `SubagentStop` carry `stop_hook_active`; a true
+re-entry terminates as quiet success so a deny cannot loop. Transition-order,
+protected-action, planning-review, and assurance-budget stay procedural.
 
 ## Derived fields
 
@@ -134,10 +149,10 @@ trees) and sets only:
 payload. Missing values stay missing, so activation advises the router instead
 of inventing context.
 
-The Router writes the visible `checkout_lease` before any planning write or
-dispatch; its nested non-placeholder Journey identity is the Router-invoked
-signal during planning. The plan-level Explorer-versus-Expedition value is
-recorded later at the route review.
+The Orchestrator writes the visible `checkout_lease` before any planning write
+or dispatch; its nested non-placeholder Lifecycle identity is the
+Router-invoked signal during planning. The plan-level lifecycle setting is
+recorded later at the integrated owner review.
 
 ## Outcome translation
 
@@ -148,6 +163,10 @@ recorded later at the route review.
 | Stop/SubagentStop with no discoverable Journey | quiet success (empty JSON; no `additionalContext`) | always `0` |
 | first-pass Stop/SubagentStop with a discoverable Journey | `hookSpecificOutput.additionalContext` | always `0` |
 | `BLOCK` | JSON `decision: "block"` only; this mapping never requests protected completion | always `0` |
+| Copilot `PreToolUse` deny | `hookSpecificOutput.permissionDecision` `"deny"` | always `0` |
+| Copilot `Stop` deny | `hookSpecificOutput` `{ hookEventName: "Stop", decision: "block", reason }` | always `0` |
+| Copilot `SubagentStop` deny | top-level `{ decision: "block", reason }` | always `0` |
+| Copilot `Stop`/`SubagentStop` re-entry (`stop_hook_active`) | quiet success (empty JSON) | always `0` |
 
 A discoverable Journey is a visible plan with a `task_id`, `assigned_role`,
 non-placeholder journey marker, or `checkout_lease` block. Empty cwd and

package/hooks/plan-package.cjs

@@ -4,7 +4,7 @@
  * 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.
+ * checkPlanningRoles excludes planning-only roles from Lifecycle implementation 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
@@ -70,13 +70,14 @@ function checkWorkClass(node, findings = []) {
   return findings;
 }
 
-/** #80: Requirements Engineer is planning-only and never an Expedition slice. */
+/** #80: Requirements Engineer is planning-only and never a Lifecycle implementation 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")) {
+    const isSlice = typeof node.id === "string" || Array.isArray(node.command_ids);
+    if (isSlice && typeof node.role === "string" && node.role.startsWith("Requirements Engineer")) {
       findings.push({
-        code: "planning_role_in_expedition",
+        code: "planning_role_in_lifecycle",
         step: typeof node.id === "string" ? node.id : null,
         role: node.role,
       });

package/hooks/policy.cjs

@@ -8,8 +8,8 @@
  */
 
 const PLANNING_REVIEW_POLICY = Object.freeze({
-  reviewer_slots_min: 2,
-  reviewer_slots_max: 2,
+  reviewer_slots_min: 1,
+  reviewer_slots_max: 1,
   independence_required: true,
   isolated_findings_until_aggregation: true,
   candidate_fields: ["candidate_ref", "candidate_revision", "candidate_digest"],
@@ -23,12 +23,18 @@ const PLANNING_REVIEW_POLICY = Object.freeze({
 });
 
 const ASSURANCE_BUDGET_POLICY = Object.freeze({
-  budget_scope: "per_declared_phase_or_wave",
+  budget_scope: "per_declared_cadence_unit",
+  cadence_values: ["slice", "phase", "lifecycle"],
+  default_cadence: {
+    "test_engineer.assurance": "phase",
+    reviewer: "phase",
+    "integration_engineer.execution": "lifecycle",
+  },
   review_rounds: 1,
   aggregated_repairs_max: 1,
   post_repair_gate: "deterministic_PASS",
   automatic_phase_or_wave_end_review: "required",
-  automatic_per_slice_review: "prohibited",
+  automatic_per_slice_review: "cadence_gated",
   post_repair_rereview: "prohibited",
   automatic_rereview_of_same_unit: "prohibited",
   budget_reset_on_candidate_change: false,

package/hooks/profiles.cjs

@@ -0,0 +1,119 @@
+"use strict";
+
+/**
+ * Profile catalog presence and migration classifier (DES-BDL-004/005).
+ * Pure evaluator: never writes, never treats lineups.json as live configuration.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const PACKAGED_BYTES = '{"schema_version":1,"profiles":{}}';
+const NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const RETIRED_ROLE_KEYS = new Set([
+  "surveyor",
+  "explorer",
+  "crewmate",
+  "navigator",
+  "park_ranger",
+  "park-ranger",
+  "validator",
+]);
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function resolveHome(env) {
+  const home = typeof env.HOME === "string" ? env.HOME.trim() : "";
+  if (home && path.isAbsolute(home)) return home;
+  const profile = typeof env.USERPROFILE === "string" ? env.USERPROFILE.trim() : "";
+  if (profile && path.isAbsolute(profile)) return profile;
+  return null;
+}
+
+function exists(file) {
+  try {
+    return fs.existsSync(file);
+  } catch {
+    return false;
+  }
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function retiredRoleKeys(profile) {
+  if (!isPlainObject(profile) || !isPlainObject(profile.roles)) return [];
+  return Object.keys(profile.roles).filter((key) => RETIRED_ROLE_KEYS.has(key));
+}
+
+/**
+ * @param {object} [input]
+ * @returns {{ outcome: string, reason: string, path?: string }}
+ */
+function evaluateCatalogState(input) {
+  const env = (input && input.env) || process.env;
+  const home = resolveHome(env);
+  if (!home) {
+    return { outcome: "NEEDS_MORE_EVIDENCE", reason: "home_unresolved" };
+  }
+  const dir = path.join(home, ".agents", "bearing-lite");
+  const profilesPath = path.join(dir, "profiles.json");
+  const lineupsPath = path.join(dir, "lineups.json");
+
+  const hasLineups = exists(lineupsPath);
+  const hasProfiles = exists(profilesPath);
+
+  if (hasLineups) {
+    return {
+      outcome: "MIGRATION_REQUIRED",
+      reason: "legacy_lineups_present",
+      path: lineupsPath,
+    };
+  }
+  if (!hasProfiles) {
+    return { outcome: "no_named_profiles", reason: "missing_user_catalog", path: profilesPath };
+  }
+
+  const parsed = readJson(profilesPath);
+  if (!isPlainObject(parsed)) {
+    return { outcome: "NEEDS_MORE_EVIDENCE", reason: "catalog_not_json", path: profilesPath };
+  }
+  if ("lineups" in parsed) {
+    return { outcome: "MIGRATION_REQUIRED", reason: "legacy_lineups_field", path: profilesPath };
+  }
+  const profiles = parsed.profiles;
+  if (!isPlainObject(profiles)) {
+    return { outcome: "NEEDS_MORE_EVIDENCE", reason: "profiles_not_object", path: profilesPath };
+  }
+  for (const name of Object.keys(profiles)) {
+    if (!NAME_PATTERN.test(name)) {
+      return { outcome: "NEEDS_MORE_EVIDENCE", reason: "invalid_profile_name", path: profilesPath };
+    }
+    const retired = retiredRoleKeys(profiles[name]);
+    if (retired.length) {
+      return {
+        outcome: "NEEDS_MORE_EVIDENCE",
+        reason: "retired_role:" + retired[0],
+        path: profilesPath,
+      };
+    }
+  }
+  return { outcome: "READY", reason: "profiles_live", path: profilesPath };
+}
+
+function packagedCatalogBytes() {
+  return PACKAGED_BYTES;
+}
+
+module.exports = {
+  evaluateCatalogState,
+  packagedCatalogBytes,
+  PACKAGED_BYTES,
+};

package/hooks/te-host.cjs

@@ -69,6 +69,7 @@ const HOST_SUPPORT = Object.freeze({
   grok: FULL_NATIVE,
   codex: FULL_NATIVE,
   "claude-code": FULL_NATIVE,
+  copilot: FULL_NATIVE,
   cursor: Object.freeze({
     write_time_deny: NATIVE,
     completion_deny: UNAVAILABLE,
@@ -118,6 +119,10 @@ function presentString(value) {
   return trimmed;
 }
 
+function isTruthyFlag(value) {
+  return value === true || value === "true";
+}
+
 /** Normalize Claude, Codex, Grok, Cursor, and Kimi event spellings. */
 function normalizeEvent(name) {
   if (typeof name !== "string") return "";
@@ -508,6 +513,19 @@ function handle(envelope, options) {
     );
   }
 
+  if (
+    host === "copilot" &&
+    hookClass === TE_COMPLETION &&
+    (isTruthyFlag(input.stop_hook_active) || isTruthyFlag(input.stopHookActive))
+  ) {
+    return hostOutput(
+      hookClass,
+      ALLOW,
+      "stop_hook_active: re-entry terminates quietly",
+      { hookEventName: eventName, host, code: "stop_hook_active" }
+    );
+  }
+
   const root = path.resolve(
     presentString(input.cwd) || presentString(input.workspaceRoot) || process.cwd()
   );
@@ -522,12 +540,13 @@ function handle(envelope, options) {
       hookClass,
       "capability_inactive: test-engineering is unselected and not required; " +
         "the class fails open and this is not a failure",
-      { hookEventName: eventName, code: resolved.code }
+      { hookEventName: eventName, host, code: resolved.code }
     );
   }
   if (resolved.status !== "ACTIVE" || !resolved.evaluator) {
     return unavailable(hookClass, resolved.message || "typed_capability_gap", {
       hookEventName: eventName,
+      host,
       code: resolved.code || "typed_capability_gap",
       recovery: resolved.recovery,
     });
@@ -545,7 +564,7 @@ function handle(envelope, options) {
       hookClass,
       "evaluator_failure: the test-engineering evaluator did not return a " +
         "verdict; enforcement is unavailable for this event",
-      { hookEventName: eventName, code: "evaluator_failure" }
+      { hookEventName: eventName, host, code: "evaluator_failure" }
     );
   }
 
@@ -554,14 +573,14 @@ function handle(envelope, options) {
     return unavailable(
       hookClass,
       "evaluator_verdict_unrecognized: enforcement is unavailable for this event",
-      { hookEventName: eventName, code: "evaluator_verdict_unrecognized" }
+      { hookEventName: eventName, host, code: "evaluator_verdict_unrecognized" }
     );
   }
 
   const reason =
     (isPlainObject(result) ? presentString(result.reason) : undefined) ||
     "test_engineering_verdict";
-  return toHostResponse(hookClass, verdict, reason, { hookEventName: eventName });
+  return toHostResponse(hookClass, verdict, reason, { hookEventName: eventName, host });
 }
 
 function flag(value) {
@@ -602,7 +621,23 @@ function toWire(response) {
       },
     };
   }
-  if (response.decision === "block") return { decision: "block", reason: response.reason };
+  if (response.decision === "block") {
+    // VS Code Stop deny is nested; Claude/Codex/Grok and VS Code SubagentStop
+    // keep the top-level decision block.
+    if (
+      presentString(inner.host) === "copilot" &&
+      normalizeEvent(inner.hookEventName) === "stop"
+    ) {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "Stop",
+          decision: "block",
+          reason: response.reason,
+        },
+      };
+    }
+    return { decision: "block", reason: response.reason };
+  }
   return {};
 }
 

package/hooks/transition-order.cjs

@@ -83,7 +83,7 @@ function normalizeAssurance(value) {
   return [String(value)].filter((s) => s && s !== "none");
 }
 
-/** Normalize role labels for order comparison (Validator vs validator vs park-ranger). */
+/** Normalize role labels for order comparison (Validator vs validator vs reviewer). */
 function normalizeRoleKey(role) {
   return String(role)
     .trim()
@@ -94,15 +94,23 @@ function normalizeRoleKey(role) {
 /**
  * Map the next missing assurance role to the state that should receive it.
  * Assurance Test Engineer (or the retired Validator label) -> VALIDATING,
- * Park Ranger -> REVIEWING, Surveyor -> ACCEPTANCE.
+ * Reviewer (or retired Park Ranger) -> REVIEWING,
+ * Integration Engineer execution (or retired Surveyor) -> ACCEPTANCE.
  */
 function assuranceTargetState(role) {
   const key = normalizeRoleKey(role);
   if (key === "validator" || key === "assurance-test-engineer" || key === "test-engineer") {
     return "VALIDATING";
   }
-  if (key === "park-ranger" || key === "parkranger") return "REVIEWING";
-  if (key === "surveyor") return "ACCEPTANCE";
+  if (key === "reviewer" || key === "park-ranger" || key === "parkranger") return "REVIEWING";
+  if (
+    key === "surveyor" ||
+    key === "integration-engineer" ||
+    key === "integration-engineer-execution" ||
+    key === "execution-integration-engineer"
+  ) {
+    return "ACCEPTANCE";
+  }
   return null;
 }