@aiwg/cli 2026.10.11 → 2026.10.12

package/dist/src/config/aiwg-config.js

@@ -1,3 +1,4 @@
+import { validateHitlPolicy } from '../policy/hitl-validation.js';
 import { normalizeAiwgConfigCandidate } from './config-normalization.js';
 import { atomicConfigWrite, withWorkerWriteLock } from './worker-write.js';
 import { workerConfigDigest } from './worker-config-digest.js';
@@ -979,6 +980,9 @@ export async function readAiwgConfigCandidate(projectDir) {
     if (workspaceErrors.length > 0) {
         throw new Error(`Invalid .aiwg/aiwg.config:\n${workspaceErrors.join('\n')}`);
     }
+    const hitlErrors = validateHitlPolicy(parsed.authorization?.hitl);
+    if (hitlErrors.length)
+        throw new Error(hitlErrors.join("\n"));
     const authorizationErrors = parsed.authorization
         ? validateAuthorization(parsed.authorization).filter(item => item.severity === 'error')
         : [];
@@ -1050,6 +1054,9 @@ async function writeAiwgConfigUnlocked(projectDir, config) {
                 throw error;
         }
     }
+    const hitlErrors = validateHitlPolicy(config.authorization?.hitl);
+    if (hitlErrors.length)
+        throw new Error(hitlErrors.join("\n"));
     const pinConfigs = loadRulePinConfigs(projectDir, config);
     const currentCapabilities = new Set(installedRuleCapabilities(pinConfigs));
     const removed = previous ? installedRuleCapabilities({ ...pinConfigs, project: previous }).filter(id => !currentCapabilities.has(id)) : [];

package/dist/src/config/authorization-cli.js

@@ -0,0 +1,89 @@
+// Exposes HITL inspection, validation, preview, enable/revoke and signed receipts under config/steward.
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { AiwgError, EXIT_CODES } from '../cli/errors.js';
+import { getProjectDir, readAiwgConfig, writeAiwgConfig } from './aiwg-config.js';
+import { ensureAuthorization, loadHitlLayers } from '../policy/hitl-config.js';
+import { resolveHitlAuthorization } from '../policy/hitl.js';
+import { validateHitlPolicy } from '../policy/hitl-validation.js';
+export const authorizationUsage = `aiwg config authorization (also aiwg steward authorization)
+  inspect | validate [--target DIRECTORY]
+  preview --action-file FILE [--target DIRECTORY]
+  enable --policy-file FILE [--target DIRECTORY]
+  revoke [--profile NAME] [--target DIRECTORY]
+  receipt --action-file FILE [--target DIRECTORY]
+Preview is read-only. Receipt writes the decision to the existing signed effect ledger;
+it does not perform the proposed action. Action files cannot supply session authorization.`;
+const usageError = (message) => new AiwgError({ code: 'ERR_AUTHORIZATION_USAGE', message, exitCode: EXIT_CODES.USAGE });
+async function jsonFile(file) {
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        throw usageError('Authorization JSON input could not be read or parsed');
+    }
+}
+export async function authorizationCli(args, cwd = process.cwd()) {
+    if (!args.length || args.includes('--help') || args[0] === 'help') {
+        console.log(authorizationUsage);
+        return;
+    }
+    const [operation, ...rest] = args;
+    const flags = {};
+    const allowed = ['--target', ...(operation === 'enable' ? ['--policy-file'] : []),
+        ...(['preview', 'receipt'].includes(operation) ? ['--action-file'] : []), ...(operation === 'revoke' ? ['--profile'] : [])];
+    for (let i = 0; i < rest.length; i += 2) {
+        if (!allowed.includes(rest[i]) || !rest[i + 1] || rest[i + 1].startsWith('--') || flags[rest[i]])
+            throw usageError('Invalid authorization option');
+        flags[rest[i]] = rest[i + 1];
+    }
+    const target = resolve(getProjectDir({ cwd }, rest));
+    if (operation === 'inspect' || operation === 'validate') {
+        const loaded = await loadHitlLayers(target);
+        console.log(JSON.stringify(operation === 'inspect' ? loaded : { valid: true, layers: loaded.layers.length }, null, 2));
+        return;
+    }
+    if (operation === 'preview' || operation === 'receipt') {
+        if (!flags['--action-file'])
+            throw usageError('--action-file is required');
+        const action = await jsonFile(resolve(cwd, flags['--action-file']));
+        const loaded = await loadHitlLayers(target);
+        const context = { now: new Date().toISOString(), layers: loaded.layers };
+        if (operation === 'preview')
+            console.log(JSON.stringify(resolveHitlAuthorization(action, context), null, 2));
+        else {
+            const { effectSession, openLedger } = await import('../effects/host.js');
+            const { recordHitlAuthorization } = await import('../policy/hitl-receipt.js');
+            const session = await effectSession(loaded.projectDir, 'custom');
+            console.log(JSON.stringify(await recordHitlAuthorization(openLedger(session), action, context), null, 2));
+        }
+        return;
+    }
+    if (operation !== 'enable' && operation !== 'revoke')
+        throw usageError('Unknown authorization operation');
+    const config = await readAiwgConfig(target);
+    if (!config)
+        throw usageError('No project config found; initialize project config first');
+    const authorization = ensureAuthorization(config);
+    if (operation === 'enable') {
+        if (!flags['--policy-file'])
+            throw usageError('--policy-file is required');
+        const policy = await jsonFile(resolve(cwd, flags['--policy-file']));
+        const errors = validateHitlPolicy(policy);
+        if (policy === undefined || errors.length)
+            throw usageError('Invalid authorization.hitl policy');
+        authorization.hitl = { ...policy, enabled: true };
+    }
+    else if (authorization.hitl) {
+        if (flags['--profile']) {
+            if (!Object.hasOwn(authorization.hitl.profiles, flags['--profile']))
+                throw usageError('Unknown authorization profile');
+            delete authorization.hitl.profiles[flags['--profile']];
+        }
+        else
+            authorization.hitl.enabled = false;
+    }
+    await writeAiwgConfig(target, config);
+    console.log(JSON.stringify({ operation, enabled: authorization.hitl?.enabled ?? false }));
+}
+//# sourceMappingURL=authorization-cli.js.map

package/dist/src/config/cli-help.js

@@ -17,6 +17,7 @@ Subcommands:
   path                Print config directory path
   edit                Open config in $EDITOR/$VISUAL (requires a terminal)
   edit --print-path   Print the config file path instead of opening an editor
+  authorization       Inspect/validate/preview/enable/revoke bounded HITL policy
   gitignore           Show/check/fix .gitignore AIWG entries
 
 Reviewed worker policy pair (project scope, no prompts):

package/dist/src/config/cli.js

@@ -33,6 +33,11 @@ const _scriptDir = path.dirname(fileURLToPath(import.meta.url));
  * Main CLI entry point for `aiwg config <subcommand> [args]`
  */
 export async function main(args) {
+    if (args[0] === 'authorization') {
+        const { authorizationCli } = await import('./authorization-cli.js');
+        await authorizationCli(args.slice(1));
+        return;
+    }
     if (await handleWorkerAdoptionArgs(args, process.cwd(), 'config'))
         return;
     // Extract --config-dir flag before routing
@@ -291,7 +296,7 @@ async function projectConfigSet(key, raw, args, quiet = false) {
     }
     // Coerce booleans for known boolean fields
     let value = raw;
-    if (key === 'rules' || key.startsWith('rules.') || key === 'parallelism' || /^parallelism\.(worker_dispatch|worker_mode|groups|clis|admission|budgets|health|retry|activation)(\.|$)/.test(key)) {
+    if (key === 'authorization' || key.startsWith('authorization.') || key === 'rules' || key.startsWith('rules.') || key === 'parallelism' || /^parallelism\.(worker_dispatch|worker_mode|groups|clis|admission|budgets|health|retry|activation)(\.|$)/.test(key)) {
         try {
             value = JSON.parse(raw);
         }
@@ -397,6 +402,10 @@ async function projectConfigSet(key, raw, args, quiet = false) {
         ? (existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : emptyConfig())
         : (await readAiwgConfig(projectDir)) ?? emptyConfig();
     const before = structuredClone(getDottedPath(cfg, key));
+    if (key.startsWith('authorization.hitl')) {
+        const { ensureAuthorization } = await import('../policy/hitl-config.js');
+        ensureAuthorization(cfg);
+    }
     setDottedPath(cfg, key, value);
     const externalLinkErrors = validateExternalLinks(cfg.externalLinks);
     if (externalLinkErrors.length > 0) {

package/dist/src/decision/context-pruning.js

@@ -1,3 +1,4 @@
+import { ceilingDecision } from '../gates/lattice.js';
 import { ContextBudgetManager } from '../metrics/context-budget.js';
 import { sha256 } from './compile-cache/identity.js';
 import { admitEntry } from './entry.js';
@@ -436,9 +437,9 @@ export function buildContextPruningEvaluationReport(input) {
         findings.add(`missing-input:${name}`);
     // Automatic rollback triggers from the D26 rollout plan: protected miss, demonstrated quality harm, negative
     // economics. An inconclusive non-inferiority result (no evidence of harm) holds instead.
-    const rollback = upstreamDecision === 'ROLLBACK' || findings.has('protected-retention-breach')
+    const rollback = findings.has('protected-retention-breach')
         || findings.has('quality-harm') || findings.has('negative-net-economics');
-    const decision = rollback ? 'ROLLBACK' : upstreamDecision === 'HOLD' || findings.size > 0 ? 'HOLD' : 'PROMOTE';
+    const decision = ceilingDecision(upstreamDecision, rollback ? 'ROLLBACK' : findings.size > 0 ? 'HOLD' : 'PROMOTE');
     const advisory = [...findings].some(item => item.startsWith('insufficient-') || item.startsWith('quality-metric-missing:')
         || item.startsWith('missing-input:') || item.startsWith('quality-outcomes-incomplete:')
         || item.startsWith('quality-non-inferiority-inconclusive:')

package/dist/src/decision/ensemble/contract.js

@@ -1,3 +1,4 @@
+import { assertDecisionCeiling, ceilingDecision, GATE_RANK, GateDecisionUpgradeError } from '../../gates/lattice.js';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
@@ -10,8 +11,8 @@ import { admitEntry } from '../entry.js';
 export class EnsembleContractError extends Error {
     layer;
     details;
-    constructor(message, layer = 'semantic', details = []) {
-        super(message);
+    constructor(message, layer = 'semantic', details = [], cause) {
+        super(message, { cause });
         this.layer = layer;
         this.details = details;
         this.name = 'EnsembleContractError';
@@ -41,7 +42,6 @@ export const ENSEMBLE_DISAGREEMENT_PRIMITIVES = {
 const UNCERTAINTY_COMBINING = new Set(['mean-probability-v1', 'jensen-shannon-v1']);
 export const REQUIRED_PAIRED_METRICS = ['quality', 'calibration', 'risk-coverage', 'abstention', 'latency', 'tokens', 'cost', 'slice'];
 const CEILING_FIELDS = ['members', 'attempts', 'deadlineMs', 'tokens', 'costMicros', 'concurrency', 'fallbackDepth'];
-const GATE_RANK = { PROMOTE: 0, HOLD: 1, ROLLBACK: 2 };
 let validators = null;
 function schemaValidator(kind) {
     if (!validators) {
@@ -334,7 +334,7 @@ export function pairedDeltaFinding(threshold, item) {
 export function ensembleIntegrityDecision(integrity, findingCount) {
     const upstream = integrity.release_gate.decision;
     const compromised = integrity.integrity_state === 'compromised' || integrity.compromise_labels.length > 0;
-    return upstream === 'ROLLBACK' || compromised ? 'ROLLBACK' : upstream === 'HOLD' || findingCount > 0 ? 'HOLD' : 'PROMOTE';
+    return ceilingDecision(upstream, compromised ? 'ROLLBACK' : 'PROMOTE', findingCount > 0 ? 'HOLD' : 'PROMOTE');
 }
 /** A D17 report may keep or tighten the upstream #2037/#2048 decision, never loosen it. Every
  * finding, passed flag and the decision are recomputed from the carried integrity fields and the
@@ -346,6 +346,15 @@ export function validateEnsembleIntegrityReport(value) {
     const problems = [];
     if (report.upstreamDecision !== report.integrity.release_gate.decision)
         problems.push('upstream decision must be the eval-integrity release gate decision');
+    let upgrade;
+    try {
+        assertDecisionCeiling(report.decision, report.upstreamDecision, ensembleIntegrityDecision(report.integrity, report.findings.length));
+    }
+    catch (error) {
+        if (!(error instanceof GateDecisionUpgradeError))
+            throw error;
+        upgrade = error;
+    }
     if (GATE_RANK[report.decision] < GATE_RANK[report.upstreamDecision])
         problems.push(`D17 cannot upgrade ${report.upstreamDecision} to ${report.decision}`);
     if (report.decision === 'PROMOTE' && (report.findings.length > 0 || report.pairedDeltas.some(item => !item.passed)))
@@ -372,6 +381,8 @@ export function validateEnsembleIntegrityReport(value) {
         problems.push(`decision ${report.decision} does not follow from its integrity and findings (${decision})`);
     if (digest !== ensembleContractDigest(payload))
         problems.push('integrity report digest does not match its content');
+    if (upgrade)
+        throw new EnsembleContractError('ensemble integrity report rejected', 'semantic', problems, upgrade);
     semantic(problems, 'ensemble integrity report rejected');
     return report;
 }

package/dist/src/decision/ensemble-study/artifacts.js

@@ -1,3 +1,4 @@
+import { assertDecisionCeiling, ceilingDecision } from '../../gates/lattice.js';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -32,6 +33,10 @@ export function validateD17Artifact(name, value) {
     admitEntry(value, name === 'report' || name === 'reportV2' ? reportLimits : limits);
     if (!validators[name]?.(value))
         throw new Error(`D17 invalid ${name} artifact`);
+    if (name === 'report' || name === 'reportV2') {
+        const report = value;
+        assertDecisionCeiling(report.decision, ceilingDecision('HOLD', report.integrity.release_gate.decision, report.integrity.compromise_labels.length ? 'ROLLBACK' : 'PROMOTE'));
+    }
     if (name === 'splits') {
         const manifest = value;
         const ids = new Set(), inputs = new Set(), families = new Map();

package/dist/src/decision/ensemble-study/score.js

@@ -1,3 +1,4 @@
+import { ceilingDecision } from '../../gates/lattice.js';
 import { heldoutDigest, validateHeldoutAttempt, validateHeldoutInputs } from '../heldout/contract.js';
 import { artifactPin } from '../validate.js';
 import { aggregateEnsembleResults } from '../ensemble/aggregate.js';
@@ -145,7 +146,7 @@ export async function scoreD17Study(input, prepared) {
         calibrationDiagnostics: { champion: binary('champion'), challenger: binary('challenger'), calibrated: false },
         pending: ['D09 compatible member and aggregate calibration', 'blind gold audit and delayed repeats', 'separate extra-cost tradeoff approval',
             'protected native report approval and eligibility'],
-        decision: input.integrity.release_gate.decision === 'ROLLBACK' || input.integrity.compromise_labels.length ? 'ROLLBACK' : 'HOLD' };
+        decision: ceilingDecision('HOLD', input.integrity.release_gate.decision, input.integrity.compromise_labels.length ? 'ROLLBACK' : 'PROMOTE') };
     validateD17Artifact('report', report);
     return report;
 }
@@ -325,7 +326,7 @@ export async function scoreD17StagedStudy(input, prepared, context) {
         mappingDigest: heldoutDigest(verified[role].mapping), compatibility: { action: 'allow',
             state: verified[role].compatibility.state, pinId: verified[role].compatibility.pinId } });
     const approved = input.approvedCalibration;
-    const decision = input.integrity.release_gate.decision === 'ROLLBACK' || input.integrity.compromise_labels.length ? 'ROLLBACK' : 'HOLD';
+    const decision = ceilingDecision('HOLD', input.integrity.release_gate.decision, input.integrity.compromise_labels.length ? 'ROLLBACK' : 'PROMOTE');
     const report = { schemaVersion: 'decision-d17-study-report/v2', scope: 'synthetic-staged-calibrated',
         calibrated: true, d09Qualified: true, calibratedGate: true,
         corpusDigest: heldoutDigest(prepared.corpus), preregistrationDigest: heldoutDigest(prepared.preregistration),
@@ -453,7 +454,7 @@ export function d17NativeIntegrity(input) {
     // The ensemble integrity contract carries only the gate decision and reasons (eval-tool thresholds are dropped).
     const gate = { decision: input.base.release_gate.decision, reasons: [...input.base.release_gate.reasons] };
     const release_gate = gate.decision === 'PROMOTE' && missing.length
-        ? { decision: 'HOLD', reasons: [...gate.reasons, ...missing.map(reason => `promotion withheld: ${reason}`)] } : gate;
+        ? { decision: ceilingDecision(gate.decision, 'HOLD'), reasons: [...gate.reasons, ...missing.map(reason => `promotion withheld: ${reason}`)] } : gate;
     const { sample_n, uncertainty, integrity_mode, fresh_workspace_required, fresh_workspace_verified, integrity_state, trusted_score_source, compromise_labels, weak_signal_reason } = input.base;
     return { sample_n, uncertainty, paired_baseline: { ...input.pairedBaseline, d17TradeoffApprovalDigest: tradeoffDigest },
         integrity_mode, fresh_workspace_required, fresh_workspace_verified, integrity_state, trusted_score_source,

package/dist/src/decision/feature-export.js

@@ -1,3 +1,4 @@
+import { assertDecisionCeiling } from '../gates/lattice.js';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
@@ -942,9 +943,7 @@ function normalizeEvalIntegrity(value) {
     if (value.upstreamDisposition !== value.qualificationRelease.decision) {
         throw new DecisionFeatureExportError('Feature export integrity must preserve the upstream qualification release decision');
     }
-    if (integrityRank(value.disposition) < integrityRank(value.upstreamDisposition)) {
-        throw new DecisionFeatureExportError(`Feature export integrity cannot upgrade ${value.upstreamDisposition} to ${value.disposition}`);
-    }
+    assertDecisionCeiling(value.disposition, value.upstreamDisposition);
     const { digest, ...payload } = value;
     if (digest !== digestEvalIntegrity(payload))
         throw new DecisionFeatureExportError('Feature export integrity digest does not match its content');
@@ -966,9 +965,7 @@ function validateQualificationRelease(record) {
         throw new DecisionFeatureExportError('Feature export qualification release digest does not match its content');
     }
     validateQualificationIntegrity(record.integrity);
-    if (integrityRank(record.decision) < integrityRank(record.integrity.release_gate.decision)) {
-        throw new DecisionFeatureExportError('Feature export qualification release cannot upgrade its integrity release gate');
-    }
+    assertDecisionCeiling(record.decision, record.integrity.release_gate.decision, record.integrity.integrity_state === 'compromised' || record.integrity.compromise_labels.length ? 'ROLLBACK' : 'PROMOTE', ...record.gates.map(gate => gate.status === 'pass' ? 'PROMOTE' : 'HOLD'));
 }
 function validateQualificationIntegrity(value) {
     if (!value || !Number.isSafeInteger(value.sample_n) || value.sample_n < 0
@@ -986,9 +983,6 @@ function validateQualificationIntegrity(value) {
 function digestEvalIntegrity(value) {
     return `sha256:${createHash('sha256').update(canonicalJson(value)).digest('hex')}`;
 }
-function integrityRank(decision) {
-    return { PROMOTE: 0, HOLD: 1, ROLLBACK: 2 }[decision];
-}
 function activeExportHold(hold, subject, nowEpochMs) {
     return hold.subject === subject && hold.expiresAt > nowEpochMs && hold.scope.includes('export');
 }

package/dist/src/decision/heldout/collector.js

@@ -1,3 +1,4 @@
+import { ceilingDecision } from '../../gates/lattice.js';
 import { createHash } from 'node:crypto';
 import { mkdir, readFile, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
@@ -425,7 +426,6 @@ export async function scoreHeldoutStudy(input) {
     return { schemaVersion: 'decision-heldout-score/v1', source: frozen.priorRuns.some(run => run.source === 'injected-transport') ? 'injected-transport' : frozen.source, evidenceDigest: input.trustedEvidenceDigest, integrityDigest: input.trustedIntegrityDigest,
         complete, diagnostics, approvedCalibration, calibrated: studyValidated ? true : calibrated, d09Qualified: studyValidated,
         calibratedGate: studyValidated && study?.calibratedGate === true,
-        calibrationArtifactValidation: studyValidated ? 'performed-by-study-scorer' : 'not-performed', integrityProblems: problems, decision: input.integrity.release_gate.decision === 'ROLLBACK'
-            || input.integrity.compromise_labels.length > 0 ? 'ROLLBACK' : 'HOLD' };
+        calibrationArtifactValidation: studyValidated ? 'performed-by-study-scorer' : 'not-performed', integrityProblems: problems, decision: ceilingDecision('HOLD', input.integrity.release_gate.decision, input.integrity.compromise_labels.length > 0 ? 'ROLLBACK' : 'PROMOTE') };
 }
 //# sourceMappingURL=collector.js.map

package/dist/src/decision/issue-triage/runtime.js

@@ -1,3 +1,4 @@
+import { assertDecisionCeiling, ceilingDecision } from '../../gates/lattice.js';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
@@ -26,7 +27,6 @@ const SCHEMA_FILES = {
     manifest: 'DecisionIssueTriageEvaluationManifest.v1.schema.json',
     report: 'DecisionIssueTriageEvaluationReport.v1.schema.json',
 };
-const GATE_RANK = { PROMOTE: 0, HOLD: 1, ROLLBACK: 2 };
 const FINAL_FIELDS = ['finalLabels', 'finalDuplicateOf', 'resolution', 'closedAt'];
 const RESPONSE_FIELDS = ['issueId', 'issueType', 'area', 'urgency', 'completeness', 'clarificationNeed', 'duplicate',
     'uncertaintyProfile', 'accepted', 'actualModel', 'requestedModel', 'latencyMs', 'usage', 'usageReceipts', 'calls', 'retries', 'fallbacks',
@@ -156,9 +156,7 @@ function checkIssueTriageEvaluationReportShape(value) {
     checkSchema('report', value);
     const report = value;
     const problems = [];
-    if (GATE_RANK[report.decision] < GATE_RANK[report.integrity.upstreamDecision]) {
-        problems.push(`issue triage report cannot upgrade ${report.integrity.upstreamDecision} to ${report.decision}`);
-    }
+    assertDecisionCeiling(report.decision, report.integrity.upstreamDecision, gateDecision(report.integrity.upstreamDecision, report.integrity.findings));
     if (report.decision === 'PROMOTE' && report.integrity.findings.length > 0)
         problems.push('PROMOTE requires no findings');
     if (report.decision === 'PROMOTE' && report.baselineComparison.qualityNonInferiority?.decision !== 'non-inferior') {
@@ -603,11 +601,7 @@ function correct(sample, which) {
         && observed.duplicate.issueId === sample.label.duplicateOf;
 }
 function gateDecision(upstream, findings) {
-    if (upstream === 'ROLLBACK')
-        return 'ROLLBACK';
-    if (upstream === 'HOLD' || findings.length > 0)
-        return 'HOLD';
-    return 'PROMOTE';
+    return ceilingDecision(upstream, findings.length > 0 ? 'HOLD' : 'PROMOTE');
 }
 /** Supported interval level in bps, or null. The paired helpers accept integer levels strictly in (5000, 9999). */
 function levelInBps(confidenceInterval) {

package/dist/src/decision/qualification/gates.js

@@ -1,3 +1,4 @@
+import { ceilingDecision } from '../../gates/lattice.js';
 import { expectedQualificationCaseIds, validateCaseInventory } from './manifest.js';
 import { deriveGateEvidence, DERIVED_GATE_EVIDENCE } from './gate-evidence.js';
 // Negative evidence always overrides a positive suite result. A release reviewer
@@ -76,7 +77,7 @@ export function evaluateQualification(manifest, definitions = DECISION_RELEASE_G
         schemaVersion: 'decision-qualification-report/v1',
         runId: manifest.runId,
         generatedAt: manifest.generatedAt,
-        decision: mandatoryFailed ? 'HOLD' : 'PROMOTE',
+        decision: ceilingDecision('PROMOTE', mandatoryFailed ? 'HOLD' : 'PROMOTE'),
         gates,
     };
 }

package/dist/src/decision/qualification/release.js

@@ -1,3 +1,4 @@
+import { ceilingDecision } from '../../gates/lattice.js';
 import { canonicalSha256, matchEvidenceDigest } from '../../gates/stats/index.js';
 /**
  * #2037/#2048 integrity modes whose verified state has a trusted score source.
@@ -133,9 +134,7 @@ export function buildQualificationReleaseRecord(executed, input) {
         && suites.length === manifest.cases.length && suites.every(item => item.outcome === 'pass' && item.verified)
         && report.gates.length === 7 && report.gates.every(gate => gate.status === 'pass')
         && report.decision === 'PROMOTE';
-    const decision = releaseDecision === 'ROLLBACK'
-        || report.decision === 'ROLLBACK' || input.integrity.integrity_state === 'compromised' || input.integrity.compromise_labels.length > 0 ? 'ROLLBACK'
-        : complete && releaseDecision === 'PROMOTE' ? 'PROMOTE' : 'HOLD';
+    const decision = ceilingDecision(releaseDecision, report.decision, complete ? 'PROMOTE' : 'HOLD', input.integrity.integrity_state === 'compromised' || input.integrity.compromise_labels.length > 0 ? 'ROLLBACK' : 'PROMOTE');
     const fields = {
         schemaVersion: 'decision-qualification-release/v2',
         runId: manifest.runId, sourceCommit: manifest.sourceCommit, dirty: manifest.dirty,

package/dist/src/decision/routing/report.js

@@ -1,3 +1,4 @@
+import { assertDecisionCeiling } from '../../gates/lattice.js';
 import { canonicalJson } from '../../security/artifact-trust.js';
 import { ensembleIntegrityDecision, integrityMetadataFindings } from '../ensemble/contract.js';
 import { pairedBinaryDifferenceInterval, pairedNonInferiority } from '../qualification/quality.js';
@@ -20,6 +21,7 @@ export function buildRoutingShadowReport(input) {
 export function validateRoutingShadowReport(value, trustedPreregistrationDigest) {
     checkRoutingSchema('shadowReport', value);
     const report = value;
+    assertDecisionCeiling(report.decision, ensembleIntegrityDecision(report.integrity, report.reasons.length));
     const rebuilt = computeRoutingShadowReport({
         id: report.id, preregistration: report.preregistration, trustedPreregistrationDigest,
         holdoutAccessedAt: report.holdoutAccessedAt, evaluatedAt: report.evaluatedAt,

package/dist/src/decision/sdlc-screening.js

@@ -1,3 +1,4 @@
+import { ceilingDecision } from '../gates/lattice.js';
 import { createHash } from 'node:crypto';
 import { DECISION_API_VERSION, DECISION_API_VERSION_STRUCTURED, } from './types.js';
 import { reviewDigest } from './review/validate.js';
@@ -1135,11 +1136,8 @@ export function buildSdlcScreeningReleaseReport(input) {
     const preregistered = evaluateSdlcScreeningPreregistration(input.preregistration, input.trustedPreregistrationDigest, input.heldout, input.nowEpochMs);
     const integrityProblems = qualificationIntegrityAllowlistProblems(input.integrity);
     const readable = !integrityProblems.includes('integrity-invalid');
-    const compromised = readable && (input.integrity.release_gate.decision === 'ROLLBACK'
-        || input.integrity.integrity_state === 'compromised' || input.integrity.compromise_labels.length > 0);
-    const decision = compromised ? 'ROLLBACK'
-        : readable && integrityProblems.length === 0 && preregistered.decision === 'pass'
-            && input.integrity.release_gate.decision === 'PROMOTE' ? 'PROMOTE' : 'HOLD';
+    const compromised = readable && (input.integrity.integrity_state === 'compromised' || input.integrity.compromise_labels.length > 0);
+    const decision = ceilingDecision(readable ? input.integrity.release_gate.decision : 'HOLD', compromised ? 'ROLLBACK' : 'PROMOTE', integrityProblems.length === 0 && preregistered.decision === 'pass' ? 'PROMOTE' : 'HOLD');
     const unsigned = {
         schemaVersion: input.preregistration.schemaVersion === SDLC_SCREENING_PREREGISTRATION_VERSION_V2
             ? SDLC_SCREENING_RELEASE_VERSION_V2 : SDLC_SCREENING_RELEASE_VERSION,

package/dist/src/decision/sensitivity/comparative.js

@@ -1,3 +1,4 @@
+import { assertDecisionCeiling, ceilingDecision } from '../../gates/lattice.js';
 import { pairedBinaryDifferenceInterval, wilsonScoreInterval } from '../qualification/quality.js';
 import { qualificationIntegrityAllowlistProblems } from '../qualification/release.js';
 import { checkSensitivitySchema, sensitivityDigest, validateSensitivityReport } from './contract.js';
@@ -128,9 +129,8 @@ export function buildComparativeReplayReport(input) {
         throw new Error('operator review ingestion is not implemented');
     findings.add('reviewer-audit-pending');
     const upstreamDecision = input.integrity.release_gate.decision;
-    const decision = upstreamDecision === 'ROLLBACK' || input.integrity.integrity_state === 'compromised'
-        || input.integrity.compromise_labels.length > 0 ? 'ROLLBACK'
-        : upstreamDecision === 'HOLD' || findings.size > 0 ? 'HOLD' : 'PROMOTE';
+    const decision = ceilingDecision(upstreamDecision, input.integrity.integrity_state === 'compromised'
+        || input.integrity.compromise_labels.length > 0 ? 'ROLLBACK' : 'PROMOTE', findings.size > 0 ? 'HOLD' : 'PROMOTE');
     const payload = {
         schemaVersion: 'decision-comparative-replay-report/v1', mode: 'shadow',
         semantics: 'associative-sensitivity-not-causal', actionAuthorization: 'not-authorized',
@@ -147,7 +147,9 @@ export function buildComparativeReplayReport(input) {
 }
 export function validateComparativeReplayReport(report, input) {
     checkSensitivitySchema('comparativeReport', report);
+    assertDecisionCeiling(report.decision, report.upstreamDecision, input.integrity.release_gate.decision);
     const expected = buildComparativeReplayReport(input);
+    assertDecisionCeiling(report.decision, expected.decision);
     if (sensitivityDigest(report) !== sensitivityDigest(expected))
         throw new Error('comparative replay report differs from bound inputs');
 }

package/dist/src/gates/driver.js

@@ -1,3 +1,4 @@
+import { assertGateReportDecision } from './report.js';
 import { lstatSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
@@ -159,11 +160,12 @@ export async function validateGateFile(kind, filePath, options = {}) {
         else {
             // Full report validation needs the trusted evaluation context
             // (`validateGateReport` re-derives the report byte-identically).
-            // `validate` checks the closed schema, the kind and the self-digest,
+            // `validate` checks component ceilings, the closed schema, kind and self-digest,
             // so rewritten evidence with a stale digest still fails here.
             const report = validateGateDocument(document);
             if (!isRecord(document) || document.kind !== 'GateReport')
                 throw new Error('expected kind GateReport');
+            assertGateReportDecision(report);
             const { digest, ...fields } = report;
             if (typeof digest !== 'string' || artifactDigest(fields) !== digest) {
                 throw new Error('report digest does not match its content');
@@ -276,83 +278,10 @@ export function listGatePacks(options = {}) {
         return summaries.filter(entry => entry.namespace === options.namespace);
     return summaries;
 }
-/**
- * Packs referenced by one rule's `enforcedBy` frontmatter (#2830 stub; full
- * coverage is #2839). Scans bundled and project-local `rules/*.md` for an
- * `enforcedBy: [aiwg:<bundle>/<pack>#<gate>]` list naming the rule. Returns
- * the referenced pack ids (without gate fragments). Empty when no rule
- * declares `enforcedBy` — rules remain guidance until they name a check.
- */
+/** List the distinct packs named by validated rule coverage declarations. */
 export async function packsReferencedByRule(ruleId, options = {}) {
-    const { readdir, readFile: readRuleFile, stat } = await import('node:fs/promises');
-    const roots = [];
-    const root = rootDir(options);
-    for (const sub of ['frameworks', 'addons', 'extensions']) {
-        roots.push(path.join(root, 'agentic/code', sub));
-    }
-    roots.push(path.join(baseDir(options), '.aiwg'));
-    const ruleFiles = [];
-    const walk = async (dir, depth) => {
-        if (depth > 5 || ruleFiles.length > 500)
-            return;
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-            if (ruleFiles.length > 500)
-                return;
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (entry.name === 'node_modules' || entry.name.startsWith('.git'))
-                    continue;
-                await walk(full, depth + 1);
-            }
-            else if (entry.isFile() && entry.name.endsWith('.md')) {
-                if (!full.replace(/\\/g, '/').includes('/rules/'))
-                    continue;
-                ruleFiles.push(full);
-            }
-        }
-    };
-    for (const dir of roots)
-        await walk(dir, 0);
-    const referenced = new Set();
-    for (const file of ruleFiles) {
-        let content;
-        try {
-            const st = await stat(file);
-            if (st.size > 65_536)
-                continue;
-            content = await readRuleFile(file, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
-        if (!match)
-            continue;
-        const frontmatter = match[1];
-        if (!frontmatter.includes('enforcedBy'))
-            continue;
-        const ruleName = path.basename(file, '.md');
-        const dirName = path.basename(path.dirname(file));
-        const names = new Set([ruleName, dirName === 'rules' ? null : `${dirName}/${ruleName}`, file]);
-        if (!names.has(ruleId) && ![...names].filter(Boolean).some(name => ruleId.endsWith(String(name))))
-            continue;
-        for (const line of frontmatter.split('\n')) {
-            const trimmed = line.trim().replace(/^-\s*/, '');
-            const id = trimmed.match(/(aiwg|framework|addon|extension|project):[^\s,'"\]]+/)?.[1]
-                ? trimmed.match(/((?:aiwg|framework|addon|extension|project):[^\s,'"\]]+)/)?.[1]
-                : null;
-            if (id)
-                referenced.add(id.split('#')[0]);
-        }
-    }
-    return [...referenced].sort();
+    const { listRuleGateCoverage } = await import('../rules/gate-coverage.js');
+    return [...new Set(listRuleGateCoverage(options, ruleId).flatMap(rule => rule.enforcedBy.map(reference => reference.split('#')[0])))].sort();
 }
 /** Show one pack by full id, rest-path or short pack name. */
 export function showGatePack(id, options = {}) {

package/dist/src/gates/evaluate.js

@@ -1,3 +1,4 @@
+import { ceilingDecision, maxOutcome } from './lattice.js';
 import { qualificationIntegrityAllowlistProblems } from '../decision/qualification/release.js';
 import { artifactDigest } from '../decision/validate.js';
 import { evaluatePredicate } from '../decision/predicates.js';
@@ -12,11 +13,7 @@ import { qualifyGateParameter } from './types.js';
 export class GateEvaluationError extends Error {
     constructor(message) { super(message); this.name = 'GateEvaluationError'; }
 }
-const RANK = { PROMOTE: 0, HOLD: 1, ROLLBACK: 2 };
-/** Shared outcome lattice. The maximum never upgrades any component. */
-export function maxOutcome(...outcomes) {
-    return outcomes.reduce((worst, outcome) => (RANK[outcome] > RANK[worst] ? outcome : worst), 'PROMOTE');
-}
+export { maxOutcome } from './lattice.js';
 /**
  * Per-gate outcome from its own status: `pass` promotes, `fail` takes the
  * gate's `onFail`, `insufficient` takes `onInsufficient` (always HOLD by load
@@ -447,11 +444,7 @@ function upstreamOutcome(upstream) {
     const compromised = problems.includes('compromised')
         || release === 'ROLLBACK'
         || upstream.metadata.integrity_state === 'compromised';
-    if (compromised)
-        return { ceiling: 'ROLLBACK', problems };
-    if (problems.length || release === 'HOLD')
-        return { ceiling: 'HOLD', problems };
-    return { ceiling: 'PROMOTE', problems };
+    return { ceiling: ceilingDecision(release ?? 'HOLD', compromised ? 'ROLLBACK' : 'PROMOTE', problems.length ? 'HOLD' : 'PROMOTE'), problems };
 }
 /**
  * Pure, deterministic gate evaluation. The binding is resolved internally
@@ -685,7 +678,7 @@ export function evaluateGates(input) {
     const packOutcome = maxOutcome(...gateEvidence.map(entry => entry.outcome));
     const { ceiling: upstreamCeiling, problems: upstreamProblems } = upstreamOutcome(upstream);
     const bindingCeiling = binding.spec.ceiling ?? 'PROMOTE';
-    const decision = maxOutcome(packOutcome, upstreamCeiling, bindingCeiling);
+    const decision = ceilingDecision(packOutcome, upstreamCeiling, bindingCeiling);
     const body = {
         apiVersion: binding.apiVersion,
         kind: 'GateReport',