agentic-workflow-manager 9.11.12 → 9.12.1

package/dist/src/commands/watch/supervisor.js

@@ -4,6 +4,7 @@ exports.Supervisor = exports.MAX_SENSOR_DEFERRALS = exports.DEFAULT_SUPERVISOR_C
 exports.routingFacts = routingFacts;
 exports.defaultDispatchAdmission = defaultDispatchAdmission;
 exports.admissionForConfig = admissionForConfig;
+exports.recoveryWhitelistBlocker = recoveryWhitelistBlocker;
 exports.runSupervisorLoop = runSupervisorLoop;
 // Loop foreground (R4.4/R4.5): tick = apply -> collect/spawn -> stall -> gate.
 // COMPLETE exige gate verde (que exige cero vivos): drenaje ANTES de declarar.
@@ -15,6 +16,9 @@ const registry_contracts_1 = require("../../core/admission/registry-contracts");
 const config_1 = require("../../utils/config");
 const store_2 = require("../../core/model-policy/store");
 const capabilities_1 = require("../../core/model-policy/capabilities");
+const event_store_1 = require("../../core/model-policy/event-store");
+const local_event_scope_1 = require("../../core/model-policy/local-event-scope");
+const journal_1 = require("../../core/model-policy/journal");
 const adapter_1 = require("../../core/journal/adapter");
 const process_1 = require("../../core/journal/process");
 const gate_1 = require("../job/gate");
@@ -24,6 +28,7 @@ const apply_1 = require("./apply");
 const runner_1 = require("./runner");
 const tracks_1 = require("./tracks");
 const generations_1 = require("./generations");
+const types_1 = require("../../core/journal/types");
 /** #166: compact v2 admission requires the runtime identity, and the supervisor
  *  never supplied it — so `awm watch` blocked on every tick with
  *  ADMISSION_ROUTING_FACTS_REQUIRED even with every other gate green.
@@ -56,10 +61,39 @@ function defaultDispatchAdmission(repoRoot, branch, provider, identity, deps = {
         }
         const plan = (0, validate_1.validatePlanFile)(binding.path, repoRoot);
         const preferences = (0, config_1.readPreferences)();
+        let routing;
+        if ((provider === 'codex' || provider === 'claude-code') && identity) {
+            const runtime = (0, capabilities_1.validateRuntimeKey)({ target: provider, kind: identity.kind, version: identity.version, accountScopeDigest: identity.accountScopeDigest });
+            const stored = (deps.readStoredEventReceipt ?? event_store_1.readStoredEventReceipt)(runtime);
+            if (stored.state === 'absent')
+                routing = routingFacts(provider, identity, repoRoot, deps);
+            else {
+                const at = deps.now?.() ?? new Date();
+                if (!(at instanceof Date) || !Number.isFinite(at.getTime()))
+                    throw new Error('routing observation time must be a finite Date');
+                const policy = (deps.readEffectivePolicy ?? store_2.readEffectivePolicy)(repoRoot);
+                routing = { runtime, policy: policy.state === 'approved' ? policy.policy : undefined, now: at };
+                if (stored.state === 'invalid')
+                    routing.eventIssue = { code: 'ROUTING_CAPABILITY_INVALID', message: `Sealed native event receipt is invalid; run awm model-policy setup --provider ${provider}.` };
+                else {
+                    const local = await (provider === 'codex' && deps.queryLocalCodexScope ? deps.queryLocalCodexScope(repoRoot, identity.kind) : (0, local_event_scope_1.queryLocalEventScope)(repoRoot, provider, identity.kind));
+                    if (local.state === 'current' && JSON.stringify(local.scope.runtime) === JSON.stringify(runtime)) {
+                        routing.eventReceipt = stored.receipt;
+                        routing.eventScope = local.scope;
+                    }
+                    else {
+                        const reason = local.state === 'unverified' ? local.reason : 'RUNTIME_IDENTITY_MISMATCH';
+                        routing.eventIssue = { code: `ROUTING_${reason}`, message: `${provider} runtime/account scope changed or cannot be verified (${reason}); run awm model-policy setup --provider ${provider} --json.` };
+                    }
+                }
+            }
+        }
+        else
+            routing = routingFacts(provider, identity, repoRoot, deps);
         return (deps.admit ?? registry_contracts_1.admitRegistryPlan)({ plan, provider, cwd: repoRoot, enabledAgents: preferences.enabledAgents,
             executionMode: 'desatendido', requireCurrent: true, verifySensors: true,
             journalState: observed.state, journalCorrupt: observed.corrupt, planPath: binding.path,
-            routing: routingFacts(provider, identity, repoRoot, deps),
+            routing,
             controllerAutonomy: autonomy });
     };
 }
@@ -169,9 +203,11 @@ function admissionForConfig(repoRoot, branch, cfg, deps = {}) {
 exports.MAX_SENSOR_DEFERRALS = 3;
 const LIVE = ['received', 'spawn-intent', 'claimed', 'running', 'cancel-requested'];
 function recoveryWhitelistBlocker(state) {
-    if (state.cycle.status === 'BLOCKED')
-        return 'el ciclo está bloqueado';
-    if (state.requestProblems.length > 0)
+    if (state.cycle.status === 'BLOCKED') {
+        return state.cycle.blockedReason === 'recovery no autorizado: hay conflictos durables de requests'
+            ? 'hay conflictos durables de requests' : 'el ciclo está bloqueado';
+    }
+    if ((0, types_1.activeRequestProblems)(state).length > 0)
         return 'hay conflictos durables de requests';
     // Pending work is the normal reason to launch (or retry launching) the
     // controller.  It is not recovery evidence and therefore cannot turn a
@@ -414,7 +450,31 @@ class Supervisor {
         if (r0.corrupt || r0.state === null)
             throw new Error('journal corrupto: el supervisor no opera sobre corrupcion (R1.6)');
         const gen = (0, generations_1.activeGeneration)(r0.state);
-        (0, apply_1.consumePendingRequests)(this.repoRoot, this.branch, gen?.token ?? null);
+        let eventScope;
+        if ((this.cfg.provider === 'codex' || this.cfg.provider === 'claude-code') && this.cfg.routingIdentity) {
+            const asserted = (0, capabilities_1.validateRuntimeKey)({ target: this.cfg.provider, ...this.cfg.routingIdentity });
+            const event = (0, event_store_1.readStoredEventReceipt)(asserted);
+            if (event.state === 'present') {
+                const local = await (0, local_event_scope_1.queryLocalEventScope)(this.repoRoot, asserted.target, asserted.kind);
+                if (local.state === 'current' && JSON.stringify(local.scope.runtime) === JSON.stringify(asserted))
+                    eventScope = local.scope;
+            }
+        }
+        (0, apply_1.consumePendingRequests)(this.repoRoot, this.branch, gen?.token ?? null, eventScope);
+        const alertRead = (0, store_1.readJournal)(this.repoRoot, this.branch);
+        if (alertRead.corrupt || !alertRead.state)
+            throw new Error('routing alert cannot read durable journal');
+        const pendingAlerts = alertRead.state.routingIncidents?.filter(item => item.alertState === 'pending') ?? [];
+        if (pendingAlerts.length > 0) {
+            for (const incident of pendingAlerts) {
+                const alert = { id: incident.id, reasonCode: incident.reasonCode, selection: incident.selection,
+                    fallbackCount: incident.fallbackCount, remedy: `awm model-policy setup --provider ${incident.target} --json` };
+                process.stderr.write(`AWM routing alert ${JSON.stringify(alert)}\n`);
+                (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'routing-incident', ...alert });
+                incident.alertState = 'reported';
+            }
+            (0, store_1.writeJournal)(this.repoRoot, this.branch, alertRead.state);
+        }
         // P1/P2 (R4.1-R4.10): a lo sumo un side effect de bootstrap de tracks
         // por tick, ANTES de tocar jobs — mientras la cohorte está PREPARING,
         // ningún job de track se despacha (eso lo maneja `runnerTick` con los
@@ -674,8 +734,12 @@ async function runSupervisorLoop(repoRoot, branch, cfg, spawner = (0, runner_1.d
             // 'frozen' (Task 10): mismo camino de salida que 'complete' —
             // drenar ownership y liberar el lock, el track ya cumplió su
             // freeze y no debe seguir despachando ni corriendo su loop.
-            if (out === 'complete' || out === 'frozen')
+            if (out === 'complete' || out === 'frozen') {
+                const finalState = (0, store_1.readJournal)(repoRoot, branch);
+                if (!finalState.corrupt && finalState.state?.routingIncidents?.length)
+                    process.stderr.write(`AWM final routing summary ${JSON.stringify((0, journal_1.routingReport)(finalState.state))}\n`);
                 break;
+            }
             // 'custody': NO liberar lock, NO salir — seguir auditando (R4.5)
             await new Promise((resolve) => {
                 let settled = false;

package/dist/src/core/admission/index.js

@@ -246,20 +246,24 @@ async function admitPlan(input) {
                 : diagnostic('ADMISSION_CONTROLLER_AUTONOMY_REQUIRED', `Unattended dispatch on ${provider} requires an explicit controller autonomy posture; without it the controller blocks on its first tool call.`);
             return blocked(input, [reason], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness, sensors: input.verifySensors ? 'pass' : 'not-required', capabilityResolution: resolution });
         }
-        return completeAdmission(input, plan, provider, mode, journal, input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution, cliCurrentness);
+        const routing = plan.schema === 'compact-slices/v2' ? input.routing ?? await input.routingReader?.() : input.routing;
+        return completeAdmission({ ...input, routing, routingReader: undefined }, plan, provider, mode, journal, input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution, cliCurrentness);
     }
     const capabilities = exports.PROVIDER_EXECUTION_CAPABILITIES[provider];
     const resolution = { outcome: capabilities.interactiveExecution === 'supported' ? 'native' : 'blocked', provider, capabilities, evidenceVersion: 'r1-v1', diagnostics: [] };
     if (resolution.outcome === 'blocked')
         return blocked(input, [diagnostic('ADMISSION_CAPABILITY_UNVERIFIED', `Provider ${provider} has no verified interactive execution capability.`)], { planDigest: plan.planDigest, provider, executionMode: mode, capabilityResolution: resolution });
-    return completeAdmission(input, plan, provider, mode, 'not-required', input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution, cliCurrentness);
+    const routing = plan.schema === 'compact-slices/v2' ? input.routing ?? await input.routingReader?.() : input.routing;
+    return completeAdmission({ ...input, routing, routingReader: undefined }, plan, provider, mode, 'not-required', input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution, cliCurrentness);
 }
 function completeAdmission(input, plan, provider, executionMode, journal, currentness, sensors, capabilityResolution, cliCurrentness = 'not-checked') {
     if (plan.schema === 'compact-slices/v1')
         return { state: 'admitted', planState: 'valid', planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution, forecast: forecast(plan.manifest.slices.length), diagnostics: [] };
-    const routing = input.routing ?? input.routingReader?.();
-    if (!routing?.runtime || !routing.policy || !routing.capabilities)
-        return blocked(input, [diagnostic('ADMISSION_ROUTING_FACTS_REQUIRED', 'Compact v2 requires an approved policy, current capability receipt, and runtime identity.')], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution });
+    const routing = input.routing;
+    if (routing?.eventIssue)
+        return blocked(input, [diagnostic(routing.eventIssue.code, routing.eventIssue.message)], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution });
+    if (!routing?.runtime || !routing.policy || (!routing.capabilities && !(routing.eventReceipt && routing.eventScope)))
+        return blocked(input, [diagnostic('ADMISSION_ROUTING_FACTS_REQUIRED', 'Compact v2 requires an approved policy, current capability evidence, and runtime identity.')], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution });
     let runtime;
     try {
         runtime = (0, capabilities_1.validateRuntimeKey)(routing.runtime);
@@ -269,12 +273,22 @@ function completeAdmission(input, plan, provider, executionMode, journal, curren
     }
     if (runtime.target !== provider)
         return blocked(input, [diagnostic('ADMISSION_ROUTING_PROVIDER_MISMATCH', 'Compact v2 routing runtime target must exactly match the admitted provider.')], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution });
+    if (routing.eventReceipt && routing.eventScope && JSON.stringify(runtime) !== JSON.stringify(routing.eventScope.runtime))
+        return blocked(input, [diagnostic('ADMISSION_ROUTING_RUNTIME_MISMATCH', 'Event-scoped routing facts do not match the admitted runtime.')], { planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution });
     const now = routing.now ?? new Date();
     for (const slice of plan.manifest.slices) {
-        const resolved = (0, resolve_1.resolveSelection)({ role: 'implementer', requestedProfile: slice.implementerProfile, policy: routing.policy, capabilities: routing.capabilities, runtime, now });
+        const profile = slice.implementerProfile;
+        const resolved = routing.eventReceipt && routing.eventScope
+            ? (0, resolve_1.resolveEventWithFallback)({ role: 'implementer', requestedProfile: profile, policy: routing.policy, receipt: routing.eventReceipt, scope: routing.eventScope, now })
+            : (0, resolve_1.resolveSelection)({ role: 'implementer', requestedProfile: profile, policy: routing.policy, capabilities: routing.capabilities, runtime, now });
         if (resolved.state === 'blocked')
             return blocked(input, resolved.diagnostics, { planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution });
     }
+    if (routing.eventReceipt && routing.eventScope) {
+        const full = (0, resolve_1.resolveEventSelection)({ role: 'code-quality-reviewer', requestedProfile: 'full', policy: routing.policy, receipt: routing.eventReceipt, scope: routing.eventScope, now });
+        if (full.state === 'blocked')
+            return blocked(input, full.diagnostics, { planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution });
+    }
     return { state: 'admitted', planState: 'valid', planDigest: plan.planDigest, provider, executionMode, journal, currentness, cliCurrentness, sensors, capabilityResolution, forecast: forecast(plan.manifest.slices.length), routingForecast: routingForecast(plan, routing), diagnostics: [] };
 }
 // Structural exhaustiveness guard: adding an AgentTarget requires an explicit entry above.

package/dist/src/core/journal/requests.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.digestOf = digestOf;
 exports.emitRequest = emitRequest;
+exports.isWellFormedEnvelope = isWellFormedEnvelope;
 exports.listPendingRequests = listPendingRequests;
 exports.applyOutcome = applyOutcome;
 exports.ackFor = ackFor;

package/dist/src/core/journal/types.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GENERATION_STATES = exports.EXECUTION_STATES = void 0;
+exports.activeRequestProblems = activeRequestProblems;
 exports.isControllerRecoveryAction = isControllerRecoveryAction;
 exports.emptyState = emptyState;
 exports.isWellFormedState = isWellFormedState;
@@ -14,6 +15,7 @@ exports.isRoutingEnvelope = isRoutingEnvelope;
 exports.isWellFormedProcessRef = isWellFormedProcessRef;
 exports.isWellFormedJob = isWellFormedJob;
 const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
 const types_1 = require("../tracks/types");
 const paths_1 = require("./paths");
 exports.EXECUTION_STATES = [
@@ -35,6 +37,19 @@ const COHORT_PHASES = [
 ];
 const _cohortPhasesComplete = true;
 const VERIFICATION_KINDS = ['test', 'lint', 'sensors', 'review', 'qa', 'interlock', 'track-integration'];
+function activeRequestProblems(state) {
+    return state.requestProblems.filter(problem => {
+        const resolution = problem.resolution;
+        if (!resolution || !problem.requestId || !problem.taskId || !problem.generationToken
+            || path_1.default.basename(problem.file) !== `${problem.requestId}.json`
+            || resolution.generationToken !== problem.generationToken)
+            return true;
+        const applied = state.appliedRequests[resolution.replacementRequestId];
+        return applied?.outcome !== 'applied' || applied.resultRef !== problem.taskId
+            || applied.payloadDigest !== resolution.replacementPayloadDigest
+            || !state.tasks.some(task => task.id === problem.taskId);
+    });
+}
 function isControllerRecoveryAction(x) {
     return isObj(x) && Object.keys(x).length === 2
         && x.schema === 'controller-recovery/v1'
@@ -94,6 +109,8 @@ function isWellFormedState(x) {
         return false;
     if (x.routingAttempts !== undefined && (!Array.isArray(x.routingAttempts) || x.routingAttempts.length > 4096 || !x.routingAttempts.every(isWellFormedRoutingAttempt)))
         return false;
+    if (x.routingIncidents !== undefined && (!Array.isArray(x.routingIncidents) || x.routingIncidents.length > 4096 || !x.routingIncidents.every(isWellFormedRoutingIncident)))
+        return false;
     if (x.implementationLineages !== undefined && (!Array.isArray(x.implementationLineages) || x.implementationLineages.length > 4096 || !x.implementationLineages.every(isWellFormedImplementationLineage)))
         return false;
     if (!Array.isArray(x.requestProblems) || !x.requestProblems.every(isWellFormedRequestProblem))
@@ -211,20 +228,47 @@ function isWellFormedAppliedRequest(x) {
         && (x.resultRef === undefined || typeof x.resultRef === 'string');
 }
 function isWellFormedRoutingAttempt(x) {
-    return isObj(x) && Object.keys(x).every(key => ['schema', 'id', 'obligationId', 'lineageId', 'attempt', 'envelope', 'envelopeDigest', 'fingerprint', 'state', 'nativeAgentId', 'observed', 'verdict', 'reasonCode', 'administrativeRepair'].includes(key))
+    return isObj(x) && Object.keys(x).every(key => ['schema', 'id', 'obligationId', 'lineageId', 'attempt', 'envelope', 'envelopeDigest', 'fingerprint', 'state', 'reservedAt', 'nativeEvidenceRequired', 'nativeEventDigest', 'nativeAgentId', 'observed', 'observedBackendModel', 'verdict', 'reasonCode', 'administrativeRepair'].includes(key))
         && x.schema === 'routing-attempt/v1'
         && typeof x.id === 'string' && typeof x.obligationId === 'string' && typeof x.lineageId === 'string' && Number.isSafeInteger(x.attempt) && x.attempt > 0
         && typeof x.envelopeDigest === 'string' && /^[a-f0-9]{64}$/.test(x.envelopeDigest) && typeof x.fingerprint === 'string' && /^[a-f0-9]{64}$/.test(x.fingerprint)
-        && ['reserved', 'active', 'complete', 'blocked', 'unknown'].includes(String(x.state)) && (x.nativeAgentId === undefined || typeof x.nativeAgentId === 'string') && (x.observed === undefined || isRoutingSelection(x.observed)) && (x.verdict === undefined || ['pass', 'fail', 'inconclusive'].includes(String(x.verdict))) && (x.reasonCode === undefined || typeof x.reasonCode === 'string') && (x.administrativeRepair === undefined || x.administrativeRepair === true) && isRoutingEnvelope(x.envelope);
+        && ['reserved', 'active', 'complete', 'blocked', 'unknown'].includes(String(x.state)) && (x.reservedAt === undefined || (typeof x.reservedAt === 'string' && Number.isFinite(Date.parse(x.reservedAt)))) && (x.nativeEvidenceRequired === undefined || x.nativeEvidenceRequired === true) && (x.nativeEventDigest === undefined || isDigest(x.nativeEventDigest)) && (x.nativeAgentId === undefined || typeof x.nativeAgentId === 'string') && (x.observed === undefined || isRoutingSelection(x.observed)) && (x.observedBackendModel === undefined || (typeof x.observedBackendModel === 'string' && x.observedBackendModel.length > 0 && x.observedBackendModel.length <= 128)) && (x.verdict === undefined || ['pass', 'fail', 'inconclusive'].includes(String(x.verdict))) && (x.reasonCode === undefined || typeof x.reasonCode === 'string') && (x.administrativeRepair === undefined || x.administrativeRepair === true) && isRoutingEnvelope(x.envelope);
+}
+function isWellFormedRoutingIncident(x) {
+    if (!isObj(x) || Object.keys(x).length !== 12 || !Object.keys(x).every(key => ['schema', 'id', 'runStartedAt', 'target', 'selection', 'reasonCode', 'firstAt', 'lastAt', 'affectedObligations', 'fallbackCount', 'blockedCount', 'alertState'].includes(key)))
+        return false;
+    return x.schema === 'routing-incident/v1' && typeof x.id === 'string' && /^[a-f0-9]{24}$/.test(x.id)
+        && typeof x.runStartedAt === 'string' && Number.isFinite(Date.parse(x.runStartedAt))
+        && typeof x.target === 'string' && x.target.length > 0 && x.target.length <= 128
+        && isRoutingSelection(x.selection) && typeof x.reasonCode === 'string' && /^[A-Z0-9_]{3,64}$/.test(x.reasonCode)
+        && typeof x.firstAt === 'string' && Number.isFinite(Date.parse(x.firstAt))
+        && typeof x.lastAt === 'string' && Number.isFinite(Date.parse(x.lastAt))
+        && Number.isSafeInteger(x.affectedObligations) && x.affectedObligations > 0
+        && Number.isSafeInteger(x.fallbackCount) && x.fallbackCount >= 0
+        && Number.isSafeInteger(x.blockedCount) && x.blockedCount >= 0
+        && ['pending', 'reported'].includes(String(x.alertState));
 }
 function isDigest(value) { return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value); }
 function isRoutingSelection(x) { return isObj(x) && Object.keys(x).every(key => key === 'selector' || key === 'effort') && isObj(x.selector) && Object.keys(x.selector).every(key => key === 'kind' || key === 'id') && ['model', 'tier'].includes(String(x.selector.kind)) && typeof x.selector.id === 'string' && x.selector.id.length > 0 && x.selector.id.length <= 128 && isObj(x.effort) && ((x.effort.kind === 'runtime-default' && Object.keys(x.effort).length === 1) || (x.effort.kind === 'explicit' && Object.keys(x.effort).length === 2 && typeof x.effort.value === 'string' && x.effort.value.length > 0 && x.effort.value.length <= 128)); }
-function isRoutingEnvelope(x) { if (!isObj(x) || !Object.keys(x).every(key => ['schema', 'runtime', 'role', 'planDigest', 'executionDigest', 'sliceId', 'requestedProfile', 'effectiveProfile', 'resolved', 'policyDigest', 'capabilityDigest', 'outcome', 'unavailableEvidence'].includes(key)))
-    return false; const runtime = x.runtime; return x.schema === 'routing-envelope/v1' && isObj(runtime) && Object.keys(runtime).every(key => ['target', 'kind', 'version', 'accountScopeDigest'].includes(key)) && ['codex', 'claude-code', 'cursor', 'copilot', 'opencode', 'antigravity'].includes(String(runtime.target)) && typeof runtime.kind === 'string' && runtime.kind.length > 0 && runtime.kind.length <= 128 && typeof runtime.version === 'string' && runtime.version.length > 0 && runtime.version.length <= 128 && isDigest(runtime.accountScopeDigest) && typeof x.role === 'string' && ROUTING_ROLES.includes(x.role) && isDigest(x.planDigest) && isDigest(x.executionDigest) && (x.sliceId === undefined || (typeof x.sliceId === 'string' && x.sliceId.length > 0 && x.sliceId.length <= 128)) && ['mechanical', 'integration', 'judgment', 'full'].includes(String(x.requestedProfile)) && ['mechanical', 'integration', 'judgment', 'full'].includes(String(x.effectiveProfile)) && isRoutingSelection(x.resolved) && isDigest(x.policyDigest) && isDigest(x.capabilityDigest) && ['native', 'degraded'].includes(String(x.outcome)) && Array.isArray(x.unavailableEvidence) && x.unavailableEvidence.length <= UNAVAILABLE_EVIDENCE.length && x.unavailableEvidence.every(value => typeof value === 'string' && UNAVAILABLE_EVIDENCE.includes(value)); }
-function isWellFormedImplementationLineage(x) { return isObj(x) && Object.keys(x).every(key => ['id', 'obligationId', 'sliceId', 'planDigest', 'executionDigest', 'initialProfile', 'initialEffort', 'attempts'].includes(key)) && typeof x.id === 'string' && x.id.length > 0 && typeof x.obligationId === 'string' && x.obligationId.length > 0 && typeof x.sliceId === 'string' && x.sliceId.length > 0 && isDigest(x.planDigest) && isDigest(x.executionDigest) && ['mechanical', 'integration', 'judgment'].includes(String(x.initialProfile)) && ['medium', 'high'].includes(String(x.initialEffort)) && Number.isSafeInteger(x.attempts) && x.attempts >= 0 && x.attempts <= 3; }
+function isRoutingEnvelope(x) { if (!isObj(x) || !Object.keys(x).every(key => ['schema', 'runtime', 'role', 'planDigest', 'executionDigest', 'sliceId', 'requestedProfile', 'effectiveProfile', 'resolved', 'policyDigest', 'capabilityDigest', 'outcome', 'unavailableEvidence', 'nativeAgentType'].includes(key)))
+    return false; const runtime = x.runtime; return x.schema === 'routing-envelope/v1' && isObj(runtime) && Object.keys(runtime).every(key => ['target', 'kind', 'version', 'accountScopeDigest'].includes(key)) && ['codex', 'claude-code', 'cursor', 'copilot', 'opencode', 'antigravity'].includes(String(runtime.target)) && typeof runtime.kind === 'string' && runtime.kind.length > 0 && runtime.kind.length <= 128 && typeof runtime.version === 'string' && runtime.version.length > 0 && runtime.version.length <= 128 && isDigest(runtime.accountScopeDigest) && typeof x.role === 'string' && ROUTING_ROLES.includes(x.role) && isDigest(x.planDigest) && isDigest(x.executionDigest) && (x.sliceId === undefined || (typeof x.sliceId === 'string' && x.sliceId.length > 0 && x.sliceId.length <= 128)) && ['mechanical', 'integration', 'judgment', 'full'].includes(String(x.requestedProfile)) && ['mechanical', 'integration', 'judgment', 'full'].includes(String(x.effectiveProfile)) && isRoutingSelection(x.resolved) && isDigest(x.policyDigest) && isDigest(x.capabilityDigest) && ['native', 'degraded'].includes(String(x.outcome)) && Array.isArray(x.unavailableEvidence) && x.unavailableEvidence.length <= UNAVAILABLE_EVIDENCE.length && x.unavailableEvidence.every(value => typeof value === 'string' && UNAVAILABLE_EVIDENCE.includes(value)) && (x.nativeAgentType === undefined || (runtime.target === 'claude-code' && typeof x.nativeAgentType === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(x.nativeAgentType))); }
+function isWellFormedImplementationLineage(x) { return isObj(x) && Object.keys(x).every(key => ['id', 'obligationId', 'sliceId', 'planDigest', 'executionDigest', 'initialProfile', 'initialEffort', 'attempts'].includes(key)) && typeof x.id === 'string' && x.id.length > 0 && typeof x.obligationId === 'string' && x.obligationId.length > 0 && typeof x.sliceId === 'string' && x.sliceId.length > 0 && isDigest(x.planDigest) && isDigest(x.executionDigest) && ['mechanical', 'integration', 'judgment'].includes(String(x.initialProfile)) && ['medium', 'high', 'runtime-default'].includes(String(x.initialEffort)) && Number.isSafeInteger(x.attempts) && x.attempts >= 0 && x.attempts <= 3; }
 function isWellFormedRequestProblem(x) {
     return isObj(x) && typeof x.file === 'string' && (x.kind === 'corrupt' || x.kind === 'rejected')
-        && typeof x.detail === 'string' && typeof x.at === 'string';
+        && typeof x.detail === 'string' && typeof x.at === 'string'
+        && (x.requestId === undefined || typeof x.requestId === 'string')
+        && (x.taskId === undefined || typeof x.taskId === 'string')
+        && (x.generationToken === undefined || typeof x.generationToken === 'string')
+        && (x.resolution === undefined || (x.kind === 'rejected' && isObj(x.resolution)
+            && Object.keys(x.resolution).every(key => ['replacementRequestId', 'replacementPayloadDigest', 'reason', 'generationToken', 'at'].includes(key))
+            && typeof x.requestId === 'string' && x.requestId.length > 0
+            && typeof x.taskId === 'string' && x.taskId.length > 0
+            && typeof x.generationToken === 'string' && x.generationToken.length > 0
+            && typeof x.resolution.replacementRequestId === 'string' && x.resolution.replacementRequestId.length > 0
+            && typeof x.resolution.replacementPayloadDigest === 'string' && /^[a-f0-9]{64}$/.test(x.resolution.replacementPayloadDigest)
+            && typeof x.resolution.reason === 'string' && x.resolution.reason.trim().length > 0
+            && typeof x.resolution.generationToken === 'string' && x.resolution.generationToken.length > 0
+            && typeof x.resolution.at === 'string' && Number.isFinite(Date.parse(x.resolution.at))));
 }
 function isWellFormedCustodyDecision(x) {
     return isObj(x) && typeof x.at === 'string' && x.decision === 'resume'

package/dist/src/core/model-policy/capabilities-v2.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEventReceipt = validateEventReceipt;
+exports.evaluateEventReceipt = evaluateEventReceipt;
+const capabilities_1 = require("./capabilities");
+const validate_1 = require("./validate");
+function record(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    return value;
+}
+function exact(value, keys, label) {
+    if (Object.keys(value).length !== keys.length || Object.keys(value).some(key => !keys.includes(key)))
+        throw new Error(`${label} has unknown or missing fields`);
+}
+function digest(value, label) {
+    (0, validate_1.assertDigest)(value, label);
+    return value;
+}
+function selection(value) {
+    const item = record(value, 'selection');
+    exact(item, ['selector', 'effort'], 'selection');
+    const selector = record(item.selector, 'selection.selector');
+    exact(selector, ['kind', 'id'], 'selection.selector');
+    if (selector.kind !== 'model' && selector.kind !== 'tier')
+        throw new Error('selection.selector.kind is invalid');
+    if (typeof selector.id !== 'string' || selector.id.length === 0 || selector.id.length > 128 || /[\u0000-\u001f\u007f-\u009f]/.test(selector.id))
+        throw new Error('selection.selector.id is invalid');
+    const effort = record(item.effort, 'selection.effort');
+    if (effort.kind === 'runtime-default') {
+        exact(effort, ['kind'], 'selection.effort');
+        return { selector: { kind: selector.kind, id: selector.id }, effort: { kind: 'runtime-default' } };
+    }
+    exact(effort, ['kind', 'value'], 'selection.effort');
+    if (effort.kind !== 'explicit' || typeof effort.value !== 'string' || effort.value.length === 0 || effort.value.length > 128 || /[\u0000-\u001f\u007f-\u009f]/.test(effort.value))
+        throw new Error('selection.effort is invalid');
+    return { selector: { kind: selector.kind, id: selector.id }, effort: { kind: 'explicit', value: effort.value } };
+}
+function key(value) { return `${value.selector.kind}\0${value.selector.id}\0${value.effort.kind}\0${value.effort.kind === 'explicit' ? value.effort.value : ''}`; }
+function finiteTokens(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new Error(`${label} is invalid`);
+    return value;
+}
+/** Schema v2 is internal native evidence, never a candidate for v1 approval. */
+function validateEventReceipt(value) {
+    const item = record(value, 'event receipt');
+    exact(item, ['schema', 'runtime', 'binaryDigest', 'configDigest', 'recordedAt', 'claims'], 'event receipt');
+    if (item.schema !== 'routing-capabilities/v2')
+        throw new Error('event receipt schema is invalid');
+    const runtime = (0, capabilities_1.validateRuntimeKey)(item.runtime);
+    if (runtime.target !== 'codex' && runtime.target !== 'claude-code')
+        throw new Error('event receipt provider target is unsupported');
+    const binaryDigest = digest(item.binaryDigest, 'binaryDigest');
+    const configDigest = digest(item.configDigest, 'configDigest');
+    const recordedAt = (0, validate_1.canonicalUtcTimestamp)(item.recordedAt, 'recordedAt');
+    if (!Array.isArray(item.claims) || item.claims.length === 0 || item.claims.length > 64)
+        throw new Error('event receipt claims are invalid');
+    const claims = item.claims.map((raw, index) => {
+        const claim = record(raw, `claims[${index}]`);
+        exact(claim, claim.source === 'claude-assistant-transcript'
+            ? ['selection', 'mappingDigest', 'eventDigest', 'source', 'nativeAgentType', ...(claim.nativeAgentIdDigest === undefined ? [] : ['nativeAgentIdDigest']), ...(claim.nativeEvents === undefined ? [] : ['nativeEvents']), 'observedAt', 'actualModel', 'tokenUsage']
+            : ['selection', 'mappingDigest', 'eventDigest', 'source', 'observedAt', 'actualModel', 'tokenUsage'], `claims[${index}]`);
+        const selected = selection(claim.selection);
+        const mappingDigest = digest(claim.mappingDigest, `claims[${index}].mappingDigest`);
+        const eventDigest = digest(claim.eventDigest, `claims[${index}].eventDigest`);
+        if (claim.source !== 'codex-turn-context' && claim.source !== 'claude-assistant-transcript')
+            throw new Error(`claims[${index}].source is invalid`);
+        if ((runtime.target === 'codex') !== (claim.source === 'codex-turn-context'))
+            throw new Error(`claims[${index}].source does not match provider`);
+        if (claim.source === 'claude-assistant-transcript' && (typeof claim.nativeAgentType !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(claim.nativeAgentType)))
+            throw new Error(`claims[${index}].nativeAgentType is invalid`);
+        if (claim.nativeAgentIdDigest !== undefined) {
+            if (claim.source !== 'claude-assistant-transcript')
+                throw new Error(`claims[${index}].nativeAgentIdDigest is invalid`);
+            digest(claim.nativeAgentIdDigest, `claims[${index}].nativeAgentIdDigest`);
+        }
+        let nativeEvents;
+        if (claim.nativeEvents !== undefined) {
+            if (claim.source !== 'claude-assistant-transcript' || !Array.isArray(claim.nativeEvents)
+                || claim.nativeEvents.length === 0 || claim.nativeEvents.length > 64)
+                throw new Error(`claims[${index}].nativeEvents is invalid`);
+            nativeEvents = claim.nativeEvents.map((raw, eventIndex) => {
+                const event = record(raw, `claims[${index}].nativeEvents[${eventIndex}]`);
+                exact(event, ['nativeAgentIdDigest', 'eventDigest', 'observedAt'], `claims[${index}].nativeEvents[${eventIndex}]`);
+                const observedAt = (0, validate_1.canonicalUtcTimestamp)(event.observedAt, `claims[${index}].nativeEvents[${eventIndex}].observedAt`);
+                if (Date.parse(observedAt) > Date.parse(recordedAt))
+                    throw new Error('Claude native event is newer than receipt');
+                return { nativeAgentIdDigest: digest(event.nativeAgentIdDigest, 'nativeAgentIdDigest'),
+                    eventDigest: digest(event.eventDigest, 'eventDigest'), observedAt };
+            });
+            if (new Set(nativeEvents.map(event => event.nativeAgentIdDigest)).size !== nativeEvents.length
+                || new Set(nativeEvents.map(event => event.eventDigest)).size !== nativeEvents.length)
+                throw new Error('Claude native events are duplicated');
+        }
+        const observedAt = (0, validate_1.canonicalUtcTimestamp)(claim.observedAt, `claims[${index}].observedAt`);
+        if (Date.parse(observedAt) > Date.parse(recordedAt))
+            throw new Error(`claims[${index}] is newer than receipt`);
+        let actualModel;
+        if (claim.actualModel === 'unverified')
+            actualModel = 'unverified';
+        else {
+            const actual = record(claim.actualModel, `claims[${index}].actualModel`);
+            exact(actual, ['id', 'evidenceDigest'], `claims[${index}].actualModel`);
+            if (claim.source !== 'claude-assistant-transcript' || typeof actual.id !== 'string' || actual.id.length === 0 || actual.id.length > 128)
+                throw new Error(`claims[${index}].actualModel is invalid`);
+            actualModel = { id: actual.id, evidenceDigest: digest(actual.evidenceDigest, `claims[${index}].actualModel.evidenceDigest`) };
+        }
+        let tokenUsage;
+        if (claim.tokenUsage === 'unknown')
+            tokenUsage = 'unknown';
+        else {
+            const usage = record(claim.tokenUsage, `claims[${index}].tokenUsage`);
+            exact(usage, ['input', 'output'], `claims[${index}].tokenUsage`);
+            tokenUsage = { input: finiteTokens(usage.input, 'input tokens'), output: finiteTokens(usage.output, 'output tokens') };
+        }
+        return { selection: selected, mappingDigest, eventDigest, source: claim.source,
+            ...(claim.source === 'claude-assistant-transcript' ? { nativeAgentType: claim.nativeAgentType,
+                ...(claim.nativeAgentIdDigest === undefined ? {} : { nativeAgentIdDigest: claim.nativeAgentIdDigest }),
+                ...(nativeEvents === undefined ? {} : { nativeEvents }) } : {}), observedAt, actualModel, tokenUsage };
+    });
+    if (new Set(claims.map(claim => key(claim.selection))).size !== claims.length)
+        throw new Error('event receipt has duplicate selections');
+    return { schema: 'routing-capabilities/v2', runtime, binaryDigest, configDigest, recordedAt, claims };
+}
+/** Local, read-only comparison: no TTL, network call, rewrite or paid probe. */
+function evaluateEventReceipt(value, scopeValue, selectedValue, mappingDigestValue, now) {
+    const receipt = validateEventReceipt(value);
+    const scope = record(scopeValue, 'event scope');
+    exact(scope, ['runtime', 'binaryDigest', 'configDigest'], 'event scope');
+    const runtime = (0, capabilities_1.validateRuntimeKey)(scope.runtime);
+    const binaryDigest = digest(scope.binaryDigest, 'binaryDigest');
+    const configDigest = digest(scope.configDigest, 'configDigest');
+    const selected = selection(selectedValue);
+    const mappingDigest = digest(mappingDigestValue, 'mappingDigest');
+    if (!(now instanceof Date) || !Number.isFinite(now.getTime()))
+        throw new Error('event currentness clock is invalid');
+    if (Date.parse(receipt.recordedAt) > now.getTime())
+        return { state: 'drift', reason: 'FUTURE_EVIDENCE' };
+    if (receipt.runtime.target !== runtime.target || receipt.runtime.kind !== runtime.kind || receipt.runtime.version !== runtime.version || receipt.binaryDigest !== binaryDigest)
+        return { state: 'drift', reason: 'RUNTIME_DRIFT' };
+    if (receipt.runtime.accountScopeDigest !== runtime.accountScopeDigest)
+        return { state: 'drift', reason: 'ACCOUNT_DRIFT' };
+    if (receipt.configDigest !== configDigest)
+        return { state: 'drift', reason: 'CONFIG_DRIFT' };
+    const claim = receipt.claims.find(item => key(item.selection) === key(selected));
+    if (!claim)
+        return { state: 'drift', reason: 'SELECTION_UNENROLLED' };
+    if (claim.mappingDigest !== mappingDigest)
+        return { state: 'drift', reason: 'POLICY_DRIFT' };
+    return { state: 'current' };
+}

package/dist/src/core/model-policy/capabilities.js

@@ -8,6 +8,7 @@ exports.capabilityReceiptDigest = capabilityReceiptDigest;
 exports.validateCapabilityReceipt = validateCapabilityReceipt;
 exports.receiptIsCurrent = receiptIsCurrent;
 exports.routingDiagnostic = routingDiagnostic;
+exports.storedCapabilityPath = storedCapabilityPath;
 exports.capabilityReceiptPath = capabilityReceiptPath;
 exports.readCapabilities = readCapabilities;
 exports.approveCapabilities = approveCapabilities;
@@ -107,7 +108,12 @@ function validateCapabilityReceipt(value) {
 }
 function receiptIsCurrent(receipt, runtime, now) { return receipt.runtime.target === runtime.target && receipt.runtime.kind === runtime.kind && receipt.runtime.version === runtime.version && receipt.runtime.accountScopeDigest === runtime.accountScopeDigest && Number.isFinite(now.getTime()) && Date.parse(receipt.recordedAt) <= now.getTime() && now.getTime() <= Date.parse(receipt.expiresAt); }
 function routingDiagnostic(code, message) { return { code, message }; }
-function capabilityReceiptPath(runtime) { const valid = validateRuntimeKey(runtime); return path_1.default.join((0, paths_1.awmHome)(), 'routing-capabilities', valid.target, `${valid.kind}.json`); }
+function storedCapabilityPath(target, kind) {
+    if (typeof target !== 'string' || !providers_1.AGENT_TARGETS.includes(target) || typeof kind !== 'string' || !RUNTIME_KIND.test(kind))
+        throw new Error('stored capability target or kind is invalid');
+    return path_1.default.join((0, paths_1.awmHome)(), 'routing-capabilities', target, `${kind}.json`);
+}
+function capabilityReceiptPath(runtime) { const valid = validateRuntimeKey(runtime); return storedCapabilityPath(valid.target, valid.kind); }
 function safeParents(file) { for (let dir = path_1.default.dirname(path_1.default.resolve(file));; dir = path_1.default.dirname(dir)) {
     try {
         const stat = fs_1.default.lstatSync(dir);

package/dist/src/core/model-policy/claude-hook-events.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordClaudeHookStart = recordClaudeHookStart;
+exports.readClaudeHookPair = readClaudeHookPair;
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+const json_1 = require("../plan/json");
+const native_bridge_1 = require("../secure-fs/native-bridge");
+const machine_key_1 = require("./machine-key");
+const native_claude_1 = require("./native-claude");
+const DOMAIN = 'AWM Claude hook start/v1\0';
+const MAX_BYTES = 8192;
+function id(value, label) {
+    if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value))
+        throw new Error(`${label} is invalid`);
+    return value;
+}
+function event(value, kind) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || value.hook_event_name !== kind)
+        throw new Error(`Claude ${kind} hook is invalid`);
+    const row = value;
+    id(row.session_id, 'Claude session id');
+    id(row.agent_id, 'Claude agent id');
+    if (typeof row.agent_type !== 'string' || row.agent_type.length === 0 || row.agent_type.length > 128
+        || /[\u0000-\u001f\u007f-\u009f]/.test(row.agent_type))
+        throw new Error('Claude agent type is invalid');
+    return row;
+}
+function fileFor(sessionId, agentId) {
+    const digest = (0, crypto_1.createHash)('sha256').update(`${sessionId}\0${agentId}`).digest('hex');
+    return path_1.default.join((0, paths_1.awmHome)(), 'claude-hook-starts', `${digest}.json`);
+}
+function mac(value, key) { return (0, crypto_1.createHmac)('sha256', key).update(DOMAIN).update(JSON.stringify(value)).digest('hex'); }
+function safeDirectory(dir, create) {
+    const chain = [];
+    for (let current = dir;; current = path_1.default.dirname(current)) {
+        chain.unshift(current);
+        if (current === path_1.default.dirname(current))
+            break;
+    }
+    for (const item of chain) {
+        try {
+            const stat = fs_1.default.lstatSync(item);
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                throw new Error('Claude hook event has unsafe ancestor');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT' || !create)
+                throw error;
+            fs_1.default.mkdirSync(item, { mode: 0o700 });
+        }
+    }
+}
+/** Persist bounded hook identity only; never a prompt, transcript or account ID. */
+function recordClaudeHookStart(value, now) {
+    const row = event(value, 'SubagentStart');
+    if (!(now instanceof Date) || !Number.isFinite(now.getTime()))
+        throw new Error('Claude hook clock is invalid');
+    const root = (0, paths_1.awmHome)();
+    const key = (0, machine_key_1.readMachineKey)(root);
+    if (!key)
+        throw new Error('Claude hook enrollment requires explicit machine setup');
+    const start = { hook_event_name: 'SubagentStart', session_id: row.session_id, agent_id: row.agent_id,
+        agent_type: row.agent_type, recorded_at: now.toISOString() };
+    const file = fileFor(start.session_id, start.agent_id);
+    native_bridge_1.secureFs.withProjectLease(root, () => {
+        safeDirectory(path_1.default.dirname(file), true);
+        const content = Buffer.from(`${JSON.stringify({ start, mac: mac(start, key) })}\n`);
+        let observed = null;
+        try {
+            const stat = fs_1.default.lstatSync(file);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                throw new Error('Claude hook start is unsafe');
+            observed = native_bridge_1.secureFs.readRegularFile(file, MAX_BYTES);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        native_bridge_1.secureFs.writeProjectTransaction(root, path_1.default.relative(root, file).split(path_1.default.sep).join('/'), content, observed ? { mode: 'replace', createParents: false, expected: observed.bytes, expectedIdentity: observed.identity } : { mode: 'create', createParents: false });
+    });
+}
+/** Link Stop to a sealed Start event on this machine. Pending events expire
+ * after one day; this is not the capability receipt lifetime. */
+function readClaudeHookPair(stopValue, now) {
+    const stop = event(stopValue, 'SubagentStop');
+    if (!(now instanceof Date) || !Number.isFinite(now.getTime()))
+        throw new Error('Claude hook clock is invalid');
+    const key = (0, machine_key_1.readMachineKey)((0, paths_1.awmHome)());
+    if (!key)
+        throw new Error('Claude hook machine key is missing');
+    const file = fileFor(stop.session_id, stop.agent_id);
+    safeDirectory(path_1.default.dirname(file), false);
+    const stat = fs_1.default.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error('Claude hook start is unsafe');
+    const parsed = (0, json_1.parseJsonNoDuplicate)(new TextDecoder('utf-8', { fatal: true }).decode(native_bridge_1.secureFs.readRegularFile(file, MAX_BYTES).bytes));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('Claude hook start envelope is invalid');
+    const envelope = parsed;
+    if (Object.keys(envelope).length !== 2 || typeof envelope.mac !== 'string' || !/^[a-f0-9]{64}$/.test(envelope.mac)
+        || !envelope.start || typeof envelope.start !== 'object' || Array.isArray(envelope.start))
+        throw new Error('Claude hook start seal is invalid');
+    const start = envelope.start;
+    if (Object.keys(start).length !== 5 || start.hook_event_name !== 'SubagentStart' || typeof start.recorded_at !== 'string'
+        || !Number.isFinite(Date.parse(start.recorded_at)) || start.session_id !== stop.session_id || start.agent_id !== stop.agent_id)
+        throw new Error('Claude hook start identity is invalid');
+    if (!(0, crypto_1.timingSafeEqual)(Buffer.from(envelope.mac, 'hex'), Buffer.from(mac(start, key), 'hex')))
+        throw new Error('Claude hook start seal does not match');
+    const ageMs = now.getTime() - Date.parse(start.recorded_at);
+    if (ageMs < 0 || ageMs > 24 * 60 * 60 * 1000)
+        throw new Error('Claude hook start is stale');
+    const lifecycle = (0, native_claude_1.normalizeClaudeSubagentLifecycle)(start, stop);
+    return { lifecycle, transcriptPath: stop.agent_transcript_path };
+}