instar 1.3.482 → 1.3.484

package/dist/core/crossModelReviewer.d.ts

@@ -22,10 +22,27 @@
  *     from `degraded` (framework present, this call failed) and
  *     `skipped-abbreviated` (author chose the fast path).
  *
- * codex is the FIRST supported framework; the registry
- * (`SUPPORTED_REVIEWER_FRAMEWORKS`) is the single seam for gemini-cli and
- * others to plug in later (Out of Scope here). Adding a framework is one
- * registry entry + one `id`-union extension — no skill change.
+ * codex is the FIRST supported framework; gemini-cli is the SECOND (Piece 3 of
+ * docs/specs/AUTONOMY-PRINCIPLES-ENFORCEMENT-SPEC.md — cross-model convergence
+ * hardening). The registry (`SUPPORTED_REVIEWER_FRAMEWORKS`) remains the single
+ * seam for further frameworks. Adding a framework is one registry entry + one
+ * `id`-union extension — no skill change.
+ *
+ * Piece 3 additions (all signal-only, never-throw, same invariants as above):
+ *   - `detectGeminiReviewer` + the gemini registry entry (family diversity).
+ *   - `detectAllCrossModelReviewers` — collect EVERY available framework, not
+ *     just the first match, so the skill runs one external pass per family.
+ *   - `isConcreteReviewerModel` — the fail-loud model canary: a tier word
+ *     ('capable', 'fast', …) falling through model resolution degrades the
+ *     review LOUDLY instead of silently selecting a dead reviewer.
+ *   - `hashSpecReviewableBody` — delta-gating: externals re-run only when the
+ *     spec's reviewable body (frontmatter stripped) actually changed.
+ *   - `recordFrameworkActivationObservation` / `wasNonClaudeFrameworkActiveWithin`
+ *     — the durable standing-framework baseline: activation is judged against
+ *     a lookback window of recorded observations, not a just-in-time reading,
+ *     so a just-before-converge framework deactivation cannot exempt a spec.
+ *   - `TRUSTED_REVIEWER_FRAMEWORKS` — the provider allowlist (no spec egress
+ *     to untrusted/custom endpoints).
  */
 import { type IntelligenceFramework } from './intelligenceProviderFactory.js';
 /**
@@ -70,7 +87,7 @@ export declare function orderContextDeterministically(context: readonly Referenc
  * Rule-1 / auth-probe vocabulary so a report can render a specific
  * remediation.
  */
-export type CrossModelUnavailableReason = 'codex-not-installed' | 'codex-not-authed' | 'codex-auth-apikey-forbidden' | 'no-supported-framework';
+export type CrossModelUnavailableReason = 'codex-not-installed' | 'codex-not-authed' | 'codex-auth-apikey-forbidden' | 'gemini-not-installed' | 'gemini-not-authed' | 'no-supported-framework';
 export interface CrossModelDetectionResult {
     available: boolean;
     /** Present when available; the framework id that will run the review. */
@@ -99,6 +116,16 @@ export interface CrossModelDetectInputs {
     env?: NodeJS.ProcessEnv;
     /** Clock injection for the Rule-1 killswitch sunset check. */
     now?: Date;
+    /**
+     * Path to the gemini binary if detected, else null. Defaults to
+     * `detectGeminiPath()` (PATH + known-location resolution).
+     */
+    geminiPathDetected?: string | null;
+    /**
+     * Path to the gemini CLI's cached OAuth credentials. Defaults to
+     * `${GEMINI_HOME || ~/.gemini}/oauth_creds.json`.
+     */
+    geminiOauthCredsPath?: string;
 }
 /**
  * Detect a codex reviewer. Returns `{ available: true, framework, model }`
@@ -109,6 +136,17 @@ export interface CrossModelDetectInputs {
  * real host. It NEVER throws.
  */
 export declare function detectCodexReviewer(inputs?: CrossModelDetectInputs): CrossModelDetectionResult;
+/**
+ * Detect a gemini reviewer (Piece 3 — the second family in the registry).
+ * Returns `{ available: true, framework, model }` iff BOTH of: gemini binary
+ * detected, cached OAuth credentials present (`access_token` or
+ * `refresh_token`). Any miss → a specific reason.
+ *
+ * Pure-ish: all external inputs are injectable (mirrors
+ * `detectCodexReviewer`). With no inputs it probes the real host. It NEVER
+ * throws.
+ */
+export declare function detectGeminiReviewer(inputs?: CrossModelDetectInputs): CrossModelDetectionResult;
 export interface ReviewerResult {
     /** Outcome class for the cross-model pass. */
     status: 'ok' | 'degraded' | 'unavailable';
@@ -162,22 +200,66 @@ export interface ReviewerInvokeArgs {
             timeoutMs?: number;
         }): Promise<string>;
     };
+    /**
+     * Optional detection override — `runCrossModelReview` passes the detection
+     * it already computed (so review never re-probes the host), and tests inject
+     * synthetic detections (e.g. a tier-word model to exercise the canary).
+     * Absent → the entry runs its own real-host detect, as before (back-compat).
+     */
+    detectionOverride?: CrossModelDetectionResult;
 }
+/**
+ * Fail-loud model canary (Piece 3). A cross-model review must run on a
+ * CONCRETE model id — never a bare tier word that fell through a
+ * tier→model resolution map (the `resolveModelForFramework` fall-through
+ * failure class: the literal string 'capable' is not a model, and silently
+ * passing it selects a dead reviewer). Returns false for undefined/empty
+ * strings and for bare tier words (case-insensitive). Both registry entries
+ * check this BEFORE invoking the provider and degrade LOUDLY
+ * (`model-resolution-canary`) on a failure.
+ */
+export declare function isConcreteReviewerModel(model: string | undefined): boolean;
 /**
  * The supported-reviewer registry. codex first — the order IS the preference
- * order. gemini-cli and others land here as later steps (Out of Scope).
+ * order. gemini second (Piece 3). Further frameworks land here as later
+ * registry entries. NOTE: the registry only ever carries first-party OAuth
+ * CLI adapters — see `TRUSTED_REVIEWER_FRAMEWORKS` below.
  */
 export declare const SUPPORTED_REVIEWER_FRAMEWORKS: SupportedReviewerFramework[];
+/**
+ * Trusted-provider allowlist (Piece 3 — no spec egress to untrusted
+ * endpoints). The registry only ever carries FIRST-PARTY OAuth CLI adapters:
+ * the full spec text is handed to the reviewer model, so it must NEVER be
+ * sent to a custom/base-URL endpoint an operator (or attacker) pointed a
+ * framework at. The pi-cli multi-provider case is deliberately EXCLUDED from
+ * cross-model review for exactly this reason — its provider may be a custom
+ * endpoint. A framework id outside this list is refused by the script
+ * wrapper (`--family`) with reason `untrusted-framework`.
+ */
+export declare const TRUSTED_REVIEWER_FRAMEWORKS: readonly string[];
+/** Is `id` on the trusted first-party reviewer allowlist? */
+export declare function isTrustedReviewerFramework(id: string): boolean;
 /**
  * Walk the registry in preference order and return the FIRST available
- * framework's detection result. If none is available, returns the codex
- * reason when there's exactly one entry (so the report can be specific), else
- * the generic `no-supported-framework`.
+ * framework's detection result (back-compat single-reviewer entry point —
+ * the multi-family collection is `detectAllCrossModelReviewers`). If none is
+ * available, returns the preference-leader's specific reason (codex today) so
+ * the report can render a concrete remediation, rather than the generic
+ * `no-supported-framework`.
  *
  * SIGNAL-ONLY: never throws, never blocks. A `false` simply routes the skill
  * to the internal-only fallback (spec §4).
  */
 export declare function detectCrossModelReviewer(inputs?: CrossModelDetectInputs): CrossModelDetectionResult;
+/**
+ * Collect EVERY available reviewer framework, in registry preference order
+ * (Piece 3 — family diversity: GPT and Gemini catch different failure
+ * classes, so the externals pass runs one review PER available family, not
+ * first-match-only). Returns an empty array when none is available.
+ *
+ * SIGNAL-ONLY: never throws, never blocks.
+ */
+export declare function detectAllCrossModelReviewers(inputs?: CrossModelDetectInputs): CrossModelDetectionResult[];
 /**
  * Map a provider rejection into a coarse `degraded` reason. The provider
  * surfaces timeouts, non-zero exits, and (via the circuit breaker) rate
@@ -306,5 +388,53 @@ export declare function runCrossModelReview(args: {
     detectInputs?: CrossModelDetectInputs;
     providerOverride?: ReviewerInvokeArgs['providerOverride'];
 }): Promise<ReviewerResult>;
+/**
+ * Hash the spec's REVIEWABLE body (Piece 3 delta-gating): sha256 hex of the
+ * spec text with the leading YAML frontmatter block stripped and line endings
+ * normalized (\r\n → \n). Frontmatter is excluded so tag-writes
+ * (`review-convergence`, `approved: true`, cross-model flags) and other
+ * metadata edits do NOT change the hash — externals re-run only when the
+ * content a reviewer would actually read changed. The skill runs externals on
+ * round 1 and on any round where this hash differs from the last external
+ * pass's hash; an unchanged round records a skip-with-logged-note.
+ */
+export declare function hashSpecReviewableBody(specText: string): string;
+/**
+ * One recorded observation of which reviewer frameworks were available at a
+ * moment in time. Appended (JSONL) to
+ * `<stateDir>/state/framework-activation-history.jsonl` by the script
+ * wrapper's `--detect-only --state-dir` path on every detection.
+ */
+export interface FrameworkActivationObservation {
+    /** ISO timestamp; defaults to now. */
+    ts?: string;
+    /** framework id → was it available/active at observation time. */
+    frameworks: Record<string, boolean>;
+}
+/**
+ * Append ONE observation line to the durable framework-activation history
+ * (Piece 3 — the standing-framework baseline). The externals-mandatory check
+ * is judged against this recorded history over a lookback window, NOT a
+ * just-in-time reading — so deactivating a framework right before converging
+ * cannot present the agent as "genuinely single-framework."
+ *
+ * mkdir -p's the state dir; caps the file at the most recent
+ * `ACTIVATION_HISTORY_MAX_LINES` lines on every write. Filesystem errors
+ * propagate — a silently-unrecorded baseline would quietly weaken the
+ * mandatory check (fail-loud).
+ */
+export declare function recordFrameworkActivationObservation(stateDir: string, observation: FrameworkActivationObservation): void;
+/**
+ * Was ANY non-Claude reviewer framework active at ANY point within the
+ * lookback window, per the durable activation history? This is the
+ * externals-mandatory check (Piece 3): `true` means the cross-model pass is
+ * NON-SKIPPABLE for the spec — including when a framework was deactivated
+ * inside the window (a just-before-converge deactivation does not exempt the
+ * spec). The advisory "externals unavailable" floor is legitimate only when
+ * this returns `false` across the whole lookback.
+ *
+ * NEVER throws: a missing file → false; corrupt lines are skipped.
+ */
+export declare function wasNonClaudeFrameworkActiveWithin(stateDir: string, lookbackDays: number, now?: Date): boolean;
 export {};
 //# sourceMappingURL=crossModelReviewer.d.ts.map

package/dist/core/crossModelReviewer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crossModelReviewer.d.ts","sourceRoot":"","sources":["../../src/core/crossModelReviewer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"crossModelReviewer.d.ts","sourceRoot":"","sources":["../../src/core/crossModelReviewer.ts"],"names":[],"mappings":"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"}

package/dist/core/crossModelReviewer.js

@@ -22,17 +22,36 @@
  *     from `degraded` (framework present, this call failed) and
  *     `skipped-abbreviated` (author chose the fast path).
  *
- * codex is the FIRST supported framework; the registry
- * (`SUPPORTED_REVIEWER_FRAMEWORKS`) is the single seam for gemini-cli and
- * others to plug in later (Out of Scope here). Adding a framework is one
- * registry entry + one `id`-union extension — no skill change.
+ * codex is the FIRST supported framework; gemini-cli is the SECOND (Piece 3 of
+ * docs/specs/AUTONOMY-PRINCIPLES-ENFORCEMENT-SPEC.md — cross-model convergence
+ * hardening). The registry (`SUPPORTED_REVIEWER_FRAMEWORKS`) remains the single
+ * seam for further frameworks. Adding a framework is one registry entry + one
+ * `id`-union extension — no skill change.
+ *
+ * Piece 3 additions (all signal-only, never-throw, same invariants as above):
+ *   - `detectGeminiReviewer` + the gemini registry entry (family diversity).
+ *   - `detectAllCrossModelReviewers` — collect EVERY available framework, not
+ *     just the first match, so the skill runs one external pass per family.
+ *   - `isConcreteReviewerModel` — the fail-loud model canary: a tier word
+ *     ('capable', 'fast', …) falling through model resolution degrades the
+ *     review LOUDLY instead of silently selecting a dead reviewer.
+ *   - `hashSpecReviewableBody` — delta-gating: externals re-run only when the
+ *     spec's reviewable body (frontmatter stripped) actually changed.
+ *   - `recordFrameworkActivationObservation` / `wasNonClaudeFrameworkActiveWithin`
+ *     — the durable standing-framework baseline: activation is judged against
+ *     a lookback window of recorded observations, not a just-in-time reading,
+ *     so a just-before-converge framework deactivation cannot exempt a spec.
+ *   - `TRUSTED_REVIEWER_FRAMEWORKS` — the provider allowlist (no spec egress
+ *     to untrusted/custom endpoints).
  */
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { detectCodexPath } from './Config.js';
+import { detectCodexPath, detectGeminiPath } from './Config.js';
 import { validateRule1 } from '../providers/adapters/openai-codex/credentials.js';
 import { resolveCliModelFlag } from '../providers/adapters/openai-codex/models.js';
+import { resolveCliModelFlag as resolveGeminiModelFlag } from '../providers/adapters/gemini-cli/models.js';
 import { buildIntelligenceProvider, } from './intelligenceProviderFactory.js';
 // ── Constants (tunable) ─────────────────────────────────────────────────
 /**
@@ -154,6 +173,86 @@ export function detectCodexReviewer(inputs = {}) {
         model: resolveCliModelFlag(REVIEW_MODEL_TIER),
     };
 }
+/**
+ * Resolve the default gemini oauth_creds.json path. DELIBERATELY no env-var
+ * override: the gemini CLI (verified v0.25.2) resolves creds at
+ * `~/.gemini/oauth_creds.json` UNCONDITIONALLY — there is no GEMINI_HOME.
+ * Honoring one here would make detection probe a path the CLI never reads
+ * (false-unavailable on an authed host -> the gemini pass silently skipped AND
+ * a false `gemini-cli:false` recorded into the activation baseline — the exact
+ * suppression Piece 3 exists to prevent). Tests inject `geminiOauthCredsPath`.
+ */
+function defaultGeminiOauthCredsPath() {
+    return path.join(os.homedir(), '.gemini', 'oauth_creds.json');
+}
+/**
+ * Is the gemini CLI's cached OAuth credentials file an authed shape? Authed
+ * iff the file parses as JSON with a non-empty string `access_token` OR
+ * `refresh_token` (the CLI refreshes an expired access token from the refresh
+ * token, so either is a usable seat). A missing / unreadable / malformed file
+ * → false (not authed). Never throws.
+ */
+function geminiOauthCredsAuthed(credsPath) {
+    try {
+        const raw = fs.readFileSync(credsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const nonEmptyString = (v) => typeof v === 'string' && v.length > 0;
+        return nonEmptyString(parsed?.access_token) || nonEmptyString(parsed?.refresh_token);
+    }
+    catch {
+        // @silent-fallback-ok — deny-safe: missing/unreadable/malformed creds mean
+        // "not authed" (the reviewer is reported unavailable with a named reason);
+        // mirrors the codex auth probe above.
+        return false;
+    }
+}
+/**
+ * Detect a gemini reviewer (Piece 3 — the second family in the registry).
+ * Returns `{ available: true, framework, model }` iff BOTH of: gemini binary
+ * detected, cached OAuth credentials present (`access_token` or
+ * `refresh_token`). Any miss → a specific reason.
+ *
+ * Pure-ish: all external inputs are injectable (mirrors
+ * `detectCodexReviewer`). With no inputs it probes the real host. It NEVER
+ * throws.
+ */
+export function detectGeminiReviewer(inputs = {}) {
+    const env = inputs.env ?? process.env;
+    const geminiPath = inputs.geminiPathDetected !== undefined ? inputs.geminiPathDetected : detectGeminiPath();
+    const credsPath = inputs.geminiOauthCredsPath ?? defaultGeminiOauthCredsPath();
+    // 1. Binary present?
+    if (!geminiPath) {
+        return { available: false, reason: 'gemini-not-installed' };
+    }
+    // 2. Authed via the CLI's cached OAuth?
+    if (!geminiOauthCredsAuthed(credsPath)) {
+        return { available: false, reason: 'gemini-not-authed' };
+    }
+    return {
+        available: true,
+        framework: 'gemini-cli',
+        model: resolveGeminiModelFlag(REVIEW_MODEL_TIER),
+    };
+}
+/**
+ * Fail-loud model canary (Piece 3). A cross-model review must run on a
+ * CONCRETE model id — never a bare tier word that fell through a
+ * tier→model resolution map (the `resolveModelForFramework` fall-through
+ * failure class: the literal string 'capable' is not a model, and silently
+ * passing it selects a dead reviewer). Returns false for undefined/empty
+ * strings and for bare tier words (case-insensitive). Both registry entries
+ * check this BEFORE invoking the provider and degrade LOUDLY
+ * (`model-resolution-canary`) on a failure.
+ */
+export function isConcreteReviewerModel(model) {
+    if (typeof model !== 'string')
+        return false;
+    const trimmed = model.trim();
+    if (trimmed.length === 0)
+        return false;
+    const TIER_WORDS = new Set(['fast', 'balanced', 'capable', 'haiku', 'sonnet', 'opus']);
+    return !TIER_WORDS.has(trimmed.toLowerCase());
+}
 /**
  * The codex reviewer entry. Detection delegates to `detectCodexReviewer`;
  * `review` routes through the factory-built `CodexCliIntelligenceProvider`.
@@ -162,9 +261,20 @@ const codexReviewer = {
     id: 'codex-cli',
     detect: (inputs) => detectCodexReviewer(inputs),
     review: async (args) => {
-        const detection = detectCodexReviewer();
+        const detection = args.detectionOverride ?? detectCodexReviewer();
         const model = detection.model ?? resolveCliModelFlag(REVIEW_MODEL_TIER);
         const tag = `cross-model:codex-cli:${model}`;
+        // Fail-loud model canary (Piece 3): NEVER silently review with a
+        // tier-word model — a fall-through 'capable' is a dead reviewer.
+        if (!isConcreteReviewerModel(model)) {
+            return {
+                status: 'degraded',
+                framework: 'codex-cli',
+                model,
+                reason: 'model-resolution-canary',
+                flag: `cross-model-review: codex-cli:${model} (degraded: model-resolution-canary)`,
+            };
+        }
         // Build (or accept an injected) provider. The factory wraps it in the
         // account-global circuit breaker, so a rate-limited review degrades the
         // same way every other instar LLM call does.
@@ -210,16 +320,107 @@ const codexReviewer = {
         };
     },
 };
+/**
+ * The gemini reviewer entry (Piece 3 — family diversity: a second non-Claude
+ * model family alongside GPT). Detection delegates to `detectGeminiReviewer`;
+ * `review` routes through the factory-built `GeminiCliIntelligenceProvider`
+ * (same circuit-breaker wrapping, same degraded semantics as codex).
+ */
+const geminiReviewer = {
+    id: 'gemini-cli',
+    detect: (inputs) => detectGeminiReviewer(inputs),
+    review: async (args) => {
+        const detection = args.detectionOverride ?? detectGeminiReviewer();
+        const model = detection.model ?? resolveGeminiModelFlag(REVIEW_MODEL_TIER);
+        const tag = `cross-model:gemini-cli:${model}`;
+        // Fail-loud model canary (Piece 3): NEVER silently review with a
+        // tier-word model — a fall-through 'capable' is a dead reviewer.
+        if (!isConcreteReviewerModel(model)) {
+            return {
+                status: 'degraded',
+                framework: 'gemini-cli',
+                model,
+                reason: 'model-resolution-canary',
+                flag: `cross-model-review: gemini-cli:${model} (degraded: model-resolution-canary)`,
+            };
+        }
+        // Build (or accept an injected) provider. The factory wraps it in the
+        // account-global circuit breaker, so a rate-limited review degrades the
+        // same way every other instar LLM call does.
+        const provider = args.providerOverride ??
+            buildIntelligenceProvider({ framework: 'gemini-cli' });
+        if (!provider) {
+            // Binary vanished between detect and review (or detection said
+            // unavailable and review was called anyway). Degraded, not a throw.
+            return {
+                status: 'degraded',
+                framework: 'gemini-cli',
+                model,
+                reason: 'provider-unavailable',
+                flag: `cross-model-review: gemini-cli:${model} (degraded: provider-unavailable)`,
+            };
+        }
+        let raw;
+        try {
+            raw = await provider.evaluate(args.promptText, {
+                model: REVIEW_MODEL_TIER,
+                timeoutMs: args.timeoutMs,
+                attribution: { component: 'crossModelReviewer' }, // attribution for /metrics/features
+            });
+        }
+        catch (err) {
+            const reason = classifyReviewFailure(err);
+            return {
+                status: 'degraded',
+                framework: 'gemini-cli',
+                model,
+                reason,
+                flag: `cross-model-review: gemini-cli:${model} (degraded: ${reason})`,
+            };
+        }
+        const parsed = parseReviewerReply(raw, tag);
+        return {
+            status: 'ok',
+            framework: 'gemini-cli',
+            model,
+            verdict: parsed.verdict,
+            findings: [parsed],
+            flag: `cross-model-review: gemini-cli:${model}`,
+        };
+    },
+};
 /**
  * The supported-reviewer registry. codex first — the order IS the preference
- * order. gemini-cli and others land here as later steps (Out of Scope).
+ * order. gemini second (Piece 3). Further frameworks land here as later
+ * registry entries. NOTE: the registry only ever carries first-party OAuth
+ * CLI adapters — see `TRUSTED_REVIEWER_FRAMEWORKS` below.
  */
-export const SUPPORTED_REVIEWER_FRAMEWORKS = [codexReviewer];
+export const SUPPORTED_REVIEWER_FRAMEWORKS = [
+    codexReviewer,
+    geminiReviewer,
+];
+/**
+ * Trusted-provider allowlist (Piece 3 — no spec egress to untrusted
+ * endpoints). The registry only ever carries FIRST-PARTY OAuth CLI adapters:
+ * the full spec text is handed to the reviewer model, so it must NEVER be
+ * sent to a custom/base-URL endpoint an operator (or attacker) pointed a
+ * framework at. The pi-cli multi-provider case is deliberately EXCLUDED from
+ * cross-model review for exactly this reason — its provider may be a custom
+ * endpoint. A framework id outside this list is refused by the script
+ * wrapper (`--family`) with reason `untrusted-framework`.
+ */
+export const TRUSTED_REVIEWER_FRAMEWORKS = ['codex-cli', 'gemini-cli'];
+/** Is `id` on the trusted first-party reviewer allowlist? */
+export function isTrustedReviewerFramework(id) {
+    return TRUSTED_REVIEWER_FRAMEWORKS.includes(id);
+}
 /**
  * Walk the registry in preference order and return the FIRST available
- * framework's detection result. If none is available, returns the codex
- * reason when there's exactly one entry (so the report can be specific), else
- * the generic `no-supported-framework`.
+ * framework's detection result (back-compat single-reviewer entry point —
+ * the multi-family collection is `detectAllCrossModelReviewers`). If none is
+ * available, returns the preference-leader's specific reason (codex today) so
+ * the report can render a concrete remediation, rather than the generic
+ * `no-supported-framework`.
  *
  * SIGNAL-ONLY: never throws, never blocks. A `false` simply routes the skill
  * to the internal-only fallback (spec §4).
@@ -230,13 +431,29 @@ export function detectCrossModelReviewer(inputs = {}) {
         if (result.available)
             return result;
     }
-    // Nothing available. Surface the single framework's specific reason when
-    // there's only one entry (codex today); otherwise the generic reason.
-    if (SUPPORTED_REVIEWER_FRAMEWORKS.length === 1) {
-        return SUPPORTED_REVIEWER_FRAMEWORKS[0].detect(inputs);
-    }
+    // Nothing available. Surface the preference-leader's specific reason.
+    const leader = SUPPORTED_REVIEWER_FRAMEWORKS[0];
+    if (leader)
+        return leader.detect(inputs);
     return { available: false, reason: 'no-supported-framework' };
 }
+/**
+ * Collect EVERY available reviewer framework, in registry preference order
+ * (Piece 3 — family diversity: GPT and Gemini catch different failure
+ * classes, so the externals pass runs one review PER available family, not
+ * first-match-only). Returns an empty array when none is available.
+ *
+ * SIGNAL-ONLY: never throws, never blocks.
+ */
+export function detectAllCrossModelReviewers(inputs = {}) {
+    const available = [];
+    for (const framework of SUPPORTED_REVIEWER_FRAMEWORKS) {
+        const result = framework.detect(inputs);
+        if (result.available)
+            available.push(result);
+    }
+    return available;
+}
 // ── Failure classification ──────────────────────────────────────────────
 /**
  * Map a provider rejection into a coarse `degraded` reason. The provider
@@ -484,7 +701,116 @@ export async function runCrossModelReview(args) {
     return framework.review({
         promptText: args.assembled.promptText,
         timeoutMs: args.timeoutMs ?? REVIEW_TIMEOUT_MS,
+        // Hand the already-computed detection down so the entry never re-probes
+        // the host (and tests stay hermetic to the injected inputs).
+        detectionOverride: detection,
         ...(args.providerOverride ? { providerOverride: args.providerOverride } : {}),
     });
 }
+// ── Delta-gating (reviewable-body hash) ─────────────────────────────────
+/**
+ * Hash the spec's REVIEWABLE body (Piece 3 delta-gating): sha256 hex of the
+ * spec text with the leading YAML frontmatter block stripped and line endings
+ * normalized (\r\n → \n). Frontmatter is excluded so tag-writes
+ * (`review-convergence`, `approved: true`, cross-model flags) and other
+ * metadata edits do NOT change the hash — externals re-run only when the
+ * content a reviewer would actually read changed. The skill runs externals on
+ * round 1 and on any round where this hash differs from the last external
+ * pass's hash; an unchanged round records a skip-with-logged-note.
+ */
+export function hashSpecReviewableBody(specText) {
+    const normalized = (specText ?? '').replace(/\r\n/g, '\n');
+    // Strip ONE leading frontmatter block: `---\n ... \n---` at the very top,
+    // where the close fence is a WHOLE line (anchored `(\n|$)`) — `\n---\n?`
+    // could terminate mid-line on `--- text` / `----` inside the block
+    // (second-pass finding, PR 3).
+    const body = normalized.replace(/^---\n[\s\S]*?\n---(\n|$)/, '');
+    return crypto.createHash('sha256').update(body, 'utf-8').digest('hex');
+}
+/** Max JSONL lines retained in the activation-history file. */
+const ACTIVATION_HISTORY_MAX_LINES = 2000;
+function activationHistoryPath(stateDir) {
+    return path.join(stateDir, 'state', 'framework-activation-history.jsonl');
+}
+/**
+ * Append ONE observation line to the durable framework-activation history
+ * (Piece 3 — the standing-framework baseline). The externals-mandatory check
+ * is judged against this recorded history over a lookback window, NOT a
+ * just-in-time reading — so deactivating a framework right before converging
+ * cannot present the agent as "genuinely single-framework."
+ *
+ * mkdir -p's the state dir; caps the file at the most recent
+ * `ACTIVATION_HISTORY_MAX_LINES` lines on every write. Filesystem errors
+ * propagate — a silently-unrecorded baseline would quietly weaken the
+ * mandatory check (fail-loud).
+ */
+export function recordFrameworkActivationObservation(stateDir, observation) {
+    const file = activationHistoryPath(stateDir);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const entry = JSON.stringify({
+        ts: observation.ts ?? new Date().toISOString(),
+        frameworks: observation.frameworks,
+    });
+    let lines = [];
+    try {
+        lines = fs.readFileSync(file, 'utf-8').split('\n').filter((l) => l.trim().length > 0);
+    }
+    catch {
+        // No file yet — first observation.
+    }
+    lines.push(entry);
+    if (lines.length > ACTIVATION_HISTORY_MAX_LINES) {
+        lines = lines.slice(-ACTIVATION_HISTORY_MAX_LINES);
+    }
+    fs.writeFileSync(file, lines.join('\n') + '\n', 'utf-8');
+}
+/**
+ * Was ANY non-Claude reviewer framework active at ANY point within the
+ * lookback window, per the durable activation history? This is the
+ * externals-mandatory check (Piece 3): `true` means the cross-model pass is
+ * NON-SKIPPABLE for the spec — including when a framework was deactivated
+ * inside the window (a just-before-converge deactivation does not exempt the
+ * spec). The advisory "externals unavailable" floor is legitimate only when
+ * this returns `false` across the whole lookback.
+ *
+ * NEVER throws: a missing file → false; corrupt lines are skipped.
+ */
+export function wasNonClaudeFrameworkActiveWithin(stateDir, lookbackDays, now) {
+    try {
+        const file = activationHistoryPath(stateDir);
+        const raw = fs.readFileSync(file, 'utf-8');
+        const cutoff = (now ?? new Date()).getTime() - lookbackDays * 24 * 60 * 60 * 1000;
+        for (const line of raw.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                const ts = typeof parsed.ts === 'string' ? Date.parse(parsed.ts) : NaN;
+                if (!Number.isFinite(ts) || ts < cutoff)
+                    continue;
+                const frameworks = parsed.frameworks;
+                if (frameworks && typeof frameworks === 'object') {
+                    // Only TRUSTED reviewer framework ids count toward the baseline — a
+                    // stray/hand-written key (e.g. "claude-code": true) must not flip
+                    // the externals-mandatory decision (second-pass finding, PR 3).
+                    const entries = Object.entries(frameworks);
+                    if (entries.some(([id, v]) => v === true && isTrustedReviewerFramework(id))) {
+                        return true;
+                    }
+                }
+            }
+            catch {
+                // @silent-fallback-ok — a corrupt history line is skipped (never throws);
+                // the read is a union-over-time, so a lost line can only UNDER-report
+                // activation, which keeps externals mandatory-safe, never lies them off.
+            }
+        }
+        return false;
+    }
+    catch {
+        // @silent-fallback-ok — a missing/unreadable history file is the expected
+        // pre-first-run state: no recorded activation is the correct answer.
+        return false;
+    }
+}
 //# sourceMappingURL=crossModelReviewer.js.map