agentic-workflow-manager 9.11.11 → 9.12.0

package/dist/src/commands/plan/index.js

@@ -23,6 +23,8 @@ const store_2 = require("../../core/model-policy/store");
 const capabilities_1 = require("../../core/model-policy/capabilities");
 const resolve_1 = require("../../core/model-policy/resolve");
 const journal_1 = require("../../core/model-policy/journal");
+const event_store_1 = require("../../core/model-policy/event-store");
+const local_event_scope_1 = require("../../core/model-policy/local-event-scope");
 const SUPPORTED_SCHEMA = 'compact-slices/v1, compact-slices/v2';
 const MAX_PATH_LENGTH = 4096;
 const MAX_DIAGNOSTICS = 20;
@@ -145,7 +147,7 @@ function registerPlanCommand(program, deps = { validatePlanFile: validate_1.vali
         throw new Error('program must be a Commander command');
     assertDependencies(deps);
     const plan = program.command('plan').description('inspect plan contracts');
-    plan.command('resolve <plan-path>').requiredOption('--provider <target>').requiredOption('--runtime-kind <kind>').requiredOption('--runtime-version <version>').requiredOption('--account-scope-digest <sha>').requiredOption('--role <role>').option('--opt-in-v1').option('--slice <id>').option('--lineage <id>').option('--cwd <path>').option('--json').action((planPath, options) => {
+    plan.command('resolve <plan-path>').requiredOption('--provider <target>').requiredOption('--runtime-kind <kind>').requiredOption('--runtime-version <version>').requiredOption('--account-scope-digest <sha>').requiredOption('--role <role>').option('--opt-in-v1').option('--slice <id>').option('--lineage <id>').option('--cwd <path>').option('--json').action(async (planPath, options) => {
         assertText(planPath, 'plan path');
         for (const [value, label] of [[options.provider, '--provider'], [options.runtimeKind, '--runtime-kind'], [options.runtimeVersion, '--runtime-version'], [options.accountScopeDigest, '--account-scope-digest'], [options.role, '--role']])
             assertText(value, label);
@@ -184,11 +186,31 @@ function registerPlanCommand(program, deps = { validatePlanFile: validate_1.vali
         if (!roles.includes(options.role))
             throw new Error('--role is invalid');
         const runtime = (0, capabilities_1.validateRuntimeKey)({ target: options.provider, kind: options.runtimeKind, version: options.runtimeVersion, accountScopeDigest: options.accountScopeDigest });
+        let eventFacts;
+        if (report.schema === 'compact-slices/v2' && (runtime.target === 'codex' || runtime.target === 'claude-code')) {
+            const stored = (deps.readStoredEventReceipt ?? event_store_1.readStoredEventReceipt)(runtime);
+            if (stored.state === 'invalid') {
+                process.stdout.write(`${JSON.stringify({ state: 'blocked', diagnostics: [{ code: 'ROUTING_CAPABILITY_INVALID', message: 'Native event receipt is invalid.' }] })}\n`);
+                process.exitCode = 2;
+                return;
+            }
+            if (stored.state === 'present') {
+                const local = await (runtime.target === 'codex' && deps.queryLocalCodexScope ? deps.queryLocalCodexScope(path_1.default.resolve(cwd), runtime.kind) : (0, local_event_scope_1.queryLocalEventScope)(path_1.default.resolve(cwd), runtime.target, runtime.kind));
+                if (local.state !== 'current' || JSON.stringify(local.scope.runtime) !== JSON.stringify(runtime)) {
+                    const reason = local.state === 'unverified' ? local.reason : 'RUNTIME_IDENTITY_MISMATCH';
+                    process.stdout.write(`${JSON.stringify({ state: 'blocked', diagnostics: [{ code: `ROUTING_${reason}`, message: `Current local ${runtime.target} scope cannot be verified (${reason}); run awm model-policy setup --provider ${runtime.target} --json.` }] })}\n`);
+                    process.exitCode = 2;
+                    return;
+                }
+                eventFacts = { eventReceipt: stored.receipt, eventScope: local.scope };
+            }
+        }
+        const circuitIncidents = report.schema === 'compact-slices/v2' ? journalObservation(cwd).journalState?.routingIncidents : undefined;
         const result = report.schema === 'compact-slices/v1' && !options.optInV1 ? (0, resolve_1.resolveDispatch)({ plan: report, role: options.role, policy: undefined, capabilities: undefined, runtime, now: new Date(), optInV1: false }) : (() => {
             const policy = (deps.readEffectivePolicy ?? store_2.readEffectivePolicy)(cwd);
-            const capabilities = (deps.readCapabilities ?? capabilities_1.readCapabilities)(runtime, new Date());
+            const capabilities = eventFacts ? { state: 'absent' } : (deps.readCapabilities ?? capabilities_1.readCapabilities)(runtime, new Date());
             if (!options.lineage) {
-                const first = (0, resolve_1.resolveDispatch)({ plan: report, role: options.role, sliceId: options.slice, policy: policy.state === 'approved' ? policy.policy : undefined, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined, runtime, now: new Date(), optInV1: options.optInV1 === true });
+                const first = (0, resolve_1.resolveDispatch)({ plan: report, role: options.role, sliceId: options.slice, policy: policy.state === 'approved' ? policy.policy : undefined, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined, ...eventFacts, circuitIncidents, runtime, now: new Date(), optInV1: options.optInV1 === true });
                 // The consumer forwards THIS envelope to `job routing-reserve`, which
                 // is what creates the lineage the --lineage escalation path below
                 // then reads. Emitting it only there made the first attempt of any
@@ -204,18 +226,15 @@ function registerPlanCommand(program, deps = { validatePlanFile: validate_1.vali
                 const requestedProfile = options.role === 'implementer' ? slice?.implementerProfile : 'full';
                 if (requestedProfile === undefined)
                     return first;
-                return { ...first, envelope: { schema: 'routing-envelope/v1', runtime, role: options.role, planDigest: report.planDigest, executionDigest: report.executionDigest, ...(options.slice === undefined ? {} : { sliceId: options.slice }), requestedProfile, effectiveProfile: first.effectiveProfile, resolved: first.selection, policyDigest: first.policyDigest, capabilityDigest: first.capabilityDigest, outcome: first.outcome, unavailableEvidence: first.unavailableEvidence } };
+                return { ...first, envelope: { schema: 'routing-envelope/v1', runtime, role: options.role, planDigest: report.planDigest, executionDigest: report.executionDigest, ...(options.slice === undefined ? {} : { sliceId: options.slice }), requestedProfile, effectiveProfile: first.effectiveProfile, resolved: first.selection, policyDigest: first.policyDigest, capabilityDigest: first.capabilityDigest, outcome: first.outcome, unavailableEvidence: first.unavailableEvidence, ...(first.nativeAgentType ? { nativeAgentType: first.nativeAgentType } : {}) } };
             }
             const state = journalObservation(cwd).journalState;
             const lineage = state.implementationLineages.find(candidate => candidate.id === options.lineage);
             const next = (0, journal_1.resolveLineageEscalation)(state, options.lineage, lineage.initialProfile);
-            const resolved = (0, resolve_1.resolveSelection)({ role: 'implementer', requestedProfile: next.profile, policy: policy.state === 'approved' ? policy.policy : undefined, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined, runtime, now: new Date() });
+            const resolved = (0, resolve_1.resolveEscalatedSelection)({ role: 'implementer', requestedProfile: next.profile, expectedEffort: next.effort, policy: policy.state === 'approved' ? policy.policy : undefined, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined, ...eventFacts, circuitIncidents, runtime, now: new Date() });
             if (resolved.state === 'blocked')
                 return resolved;
-            const highRequiresFull = next.effort !== 'high' || (policy.state === 'approved' && (() => { const full = policy.policy.content.mappings.find(row => row.target === runtime.target && row.runtimeKind === runtime.kind)?.fullCapability; return full?.selector.kind === resolved.selection.selector.kind && full.selector.id === resolved.selection.selector.id && full.effort.kind === 'explicit' && full.effort.value === 'high'; })());
-            if (resolved.selection.effort.kind !== 'explicit' || resolved.selection.effort.value !== next.effort || !highRequiresFull)
-                return { state: 'blocked', diagnostics: [{ code: 'ROUTING_ESCALATION_EFFORT_UNAVAILABLE', message: 'The approved selected effort does not match the next lineage escalation.' }] };
-            return { ...resolved, envelope: { schema: 'routing-envelope/v1', runtime, role: 'implementer', planDigest: report.planDigest, executionDigest: report.executionDigest, sliceId: lineage.sliceId, requestedProfile: lineage.initialProfile, effectiveProfile: next.profile, resolved: resolved.selection, policyDigest: resolved.policyDigest, capabilityDigest: resolved.capabilityDigest, outcome: resolved.outcome, unavailableEvidence: resolved.unavailableEvidence }, custodyHandoff: { kind: 'routing-reserve', obligationId: lineage.obligationId, lineageId: lineage.id } };
+            return { ...resolved, envelope: { schema: 'routing-envelope/v1', runtime, role: 'implementer', planDigest: report.planDigest, executionDigest: report.executionDigest, sliceId: lineage.sliceId, requestedProfile: lineage.initialProfile, effectiveProfile: resolved.effectiveProfile, resolved: resolved.selection, policyDigest: resolved.policyDigest, capabilityDigest: resolved.capabilityDigest, outcome: resolved.outcome, unavailableEvidence: resolved.unavailableEvidence, ...(resolved.nativeAgentType ? { nativeAgentType: resolved.nativeAgentType } : {}) }, custodyHandoff: { kind: 'routing-reserve', obligationId: lineage.obligationId, lineageId: lineage.id } };
         })();
         process.stdout.write(options.json ? `${JSON.stringify(result)}\n` : `Plan routing: ${result.state}\n`);
         if (result.state === 'blocked')
@@ -293,9 +312,31 @@ function registerPlanCommand(program, deps = { validatePlanFile: validate_1.vali
             process.exitCode = 2;
             return;
         }
-        const readRouting = () => { if (!options.runtimeKind || !options.runtimeVersion || !options.accountScopeDigest)
-            return undefined; const runtime = (0, capabilities_1.validateRuntimeKey)({ target: options.provider, kind: options.runtimeKind, version: options.runtimeVersion, accountScopeDigest: options.accountScopeDigest }); const policy = (deps.readEffectivePolicy ?? store_2.readEffectivePolicy)(options.cwd); const at = deps.routingNow?.() ?? new Date(); if (!(at instanceof Date) || !Number.isFinite(at.getTime()))
-            throw new Error('routingNow must return a finite Date'); const capabilities = (deps.readCapabilities ?? capabilities_1.readCapabilities)(runtime, at); return { runtime, policy: policy.state === 'approved' ? policy.policy : undefined, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined, now: at }; };
+        const readRouting = async () => {
+            if (!options.runtimeKind || !options.runtimeVersion || !options.accountScopeDigest)
+                return undefined;
+            const runtime = (0, capabilities_1.validateRuntimeKey)({ target: options.provider, kind: options.runtimeKind, version: options.runtimeVersion, accountScopeDigest: options.accountScopeDigest });
+            const policy = (deps.readEffectivePolicy ?? store_2.readEffectivePolicy)(options.cwd);
+            const at = deps.routingNow?.() ?? new Date();
+            if (!(at instanceof Date) || !Number.isFinite(at.getTime()))
+                throw new Error('routingNow must return a finite Date');
+            const base = { runtime, policy: policy.state === 'approved' ? policy.policy : undefined, now: at };
+            if (runtime.target === 'codex' || runtime.target === 'claude-code') {
+                const stored = (deps.readStoredEventReceipt ?? event_store_1.readStoredEventReceipt)(runtime);
+                if (stored.state === 'invalid')
+                    return { ...base, eventIssue: { code: 'ROUTING_CAPABILITY_INVALID', message: 'Sealed native event receipt is invalid.' } };
+                if (stored.state === 'present') {
+                    const local = await (runtime.target === 'codex' && deps.queryLocalCodexScope ? deps.queryLocalCodexScope(path_1.default.resolve(options.cwd), runtime.kind) : (0, local_event_scope_1.queryLocalEventScope)(path_1.default.resolve(options.cwd), runtime.target, runtime.kind));
+                    if (local.state !== 'current' || JSON.stringify(local.scope.runtime) !== JSON.stringify(runtime)) {
+                        const reason = local.state === 'unverified' ? local.reason : 'RUNTIME_IDENTITY_MISMATCH';
+                        return { ...base, eventIssue: { code: `ROUTING_${reason}`, message: `Local ${runtime.target} scope cannot be verified (${reason}); run awm model-policy setup --provider ${runtime.target} --json.` } };
+                    }
+                    return { ...base, eventReceipt: stored.receipt, eventScope: local.scope };
+                }
+            }
+            const capabilities = (deps.readCapabilities ?? capabilities_1.readCapabilities)(runtime, at);
+            return { ...base, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined };
+        };
         if (options.controllerAutonomy !== undefined && !(0, adapter_1.isControllerAutonomy)(options.controllerAutonomy))
             throw new Error(`--controller-autonomy is invalid: ${options.controllerAutonomy} (valid: ${adapter_1.CONTROLLER_AUTONOMIES.join(', ')})`);
         const report = await (0, registry_contracts_1.admitRegistryPlan)({ plan: planReport, provider: options.provider, cwd: options.cwd, enabledAgents, executionMode, planPath: normalizedPlanPath, ...journal, requireCurrent: options.requireCurrent === true, verifySensors: options.verifySensors === true, ...(options.controllerAutonomy === undefined ? {} : { controllerAutonomy: options.controllerAutonomy }) }, { admitPlan: admission, listRegistries: registryInventory, checkCurrentness: currentnessCheck, runSensors: sensorRun, readRouting });

package/dist/src/commands/preflight/checks.js

@@ -17,7 +17,24 @@ const registries_1 = require("../../core/registries");
 const inspect_1 = require("../../core/context-kernel/inspect");
 const registries_2 = require("../../core/registries");
 const check_1 = require("../../core/currentness/check");
+const store_1 = require("../../core/model-policy/store");
+const setup_readiness_1 = require("../../core/model-policy/setup-readiness");
 const MANIFEST = path_1.default.join('.awm', 'sensors.json');
+function checkRoutingSetup(cwd) {
+    const guidance = (0, setup_readiness_1.routingSetupGuidance)((0, store_1.readEffectivePolicy)(cwd));
+    if (guidance.length === 0)
+        return [];
+    const invalid = guidance.find(item => item.state === 'policy-invalid');
+    if (invalid?.state === 'policy-invalid')
+        return [{ id: 'routing-setup', ok: false, advisory: true, detail: 'approved routing policy is invalid', remedy: 'repair the model policy before using routed subagents' }];
+    const targets = guidance.filter((item) => item.state === 'needs-evidence');
+    if (targets.length === 0)
+        return [{ id: 'routing-setup', ok: true, advisory: true,
+                detail: 'sealed routing selections are covered locally; doctor/preflight do not verify current runtime/account/config scope (checked at routed dispatch)' }];
+    return [{ id: 'routing-setup', ok: false, advisory: true,
+            detail: `routing machine evidence needs a native check for ${targets.map(item => `${item.target}/${item.runtimeKind}`).join(', ')}`,
+            remedy: targets[0].command }];
+}
 /**
  * The agent needs project context delivered every session. A repo with neither file
  * hands every agent — and every teammate's agent — a blank slate.
@@ -472,6 +489,7 @@ async function preflight(cwd = process.cwd(), opts = {}) {
         ...(opts.verifySensors === true ? [await checkSensorExecution(cwd)] : []),
         // Strict mode is the only path that contacts authoritative npm/Git sources.
         ...(opts.requireCurrent === true ? [checkCompatibility()] : []),
+        ...checkRoutingSetup(cwd),
         // Runs unconditionally — orthogonal to sensor configuration entirely, this is
         // about PR/MR tooling, not sensors.
         checkHost(cwd),

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

@@ -20,7 +20,30 @@ const redact_1 = require("../../core/journal/redact");
 const git_1 = require("../../core/tracks/git");
 const types_1 = require("../../core/journal/types");
 const journal_1 = require("../../core/model-policy/journal");
+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 capabilities_v2_1 = require("../../core/model-policy/capabilities-v2");
+const machine_key_1 = require("../../core/model-policy/machine-key");
+const paths_2 = require("../../core/paths");
+const native_routing_proof_1 = require("../../core/model-policy/native-routing-proof");
+const selection_policy_digest_1 = require("../../core/model-policy/selection-policy-digest");
 function now() { return new Date().toISOString(); }
+function currentNativeAttempt(repoRoot, envelope, eventScope, at) {
+    if (!eventScope || JSON.stringify(eventScope.runtime) !== JSON.stringify(envelope.runtime))
+        return false;
+    try {
+        const stored = (0, event_store_1.readStoredEventReceipt)((0, capabilities_1.validateRuntimeKey)(envelope.runtime));
+        const approved = (0, store_2.readEffectivePolicy)(repoRoot);
+        if (stored.state !== 'present' || approved.state !== 'approved' || approved.policy.contentDigest !== envelope.policyDigest)
+            return false;
+        const mapping = approved.policy.content.mappings.find(row => row.target === envelope.runtime.target && row.runtimeKind === envelope.runtime.kind);
+        return !!mapping && (0, capabilities_v2_1.evaluateEventReceipt)(stored.receipt, eventScope, envelope.resolved, (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, envelope.resolved), at).state === 'current';
+    }
+    catch {
+        return false;
+    }
+}
 const VERIFICATION_KINDS = ['test', 'lint', 'sensors', 'review', 'qa', 'interlock', 'track-integration'];
 function verificationItems(value, field) {
     if (!Array.isArray(value) || !value.every((item) => typeof item === 'object' && item !== null
@@ -105,7 +128,7 @@ function registerTrackIntegrationItems(state) {
 function trackWorktreePath(repoRoot, trackId) {
     return path_1.default.join(path_1.default.dirname(repoRoot), `${path_1.default.basename(repoRoot)}.track-${trackId}`);
 }
-function applyRequestToState(s, env, digest, repoRoot) {
+function applyRequestToState(s, env, digest, repoRoot, eventScope) {
     const base = { requestId: env.requestId, idempotencyKey: env.idempotencyKey, payloadDigest: digest };
     if (env.kind === 'controller-heartbeat') {
         s.controllerHeartbeatAt = now();
@@ -116,7 +139,21 @@ function applyRequestToState(s, env, digest, repoRoot) {
         const p = env.payload;
         if (typeof p.obligationId !== 'string' || typeof p.lineageId !== 'string' || !(0, types_1.isRoutingEnvelope)(p.envelope) || typeof p.fingerprint !== 'string' || (p.at !== undefined && typeof p.at !== 'string'))
             throw new Error('routing-reserve requiere payload estricto');
-        const reserved = (0, journal_1.reserveRoutingAttempt)(s, { obligationId: p.obligationId, lineageId: p.lineageId, envelope: p.envelope, fingerprint: p.fingerprint }, p.at ?? now());
+        const envelope = p.envelope;
+        const reserved = (0, journal_1.reserveRoutingAttempt)(s, { obligationId: p.obligationId, lineageId: p.lineageId, envelope, fingerprint: p.fingerprint, approval: () => {
+                const checkedAt = new Date();
+                const policy = (0, store_2.readEffectivePolicy)(repoRoot);
+                const event = (0, event_store_1.readStoredEventReceipt)((0, capabilities_1.validateRuntimeKey)(envelope.runtime));
+                if (event.state === 'invalid')
+                    throw new Error('routing native event receipt is invalid');
+                if (event.state === 'present') {
+                    if (!eventScope)
+                        throw new Error('routing native event scope is unverified');
+                    return { checkedAt, policy: policy.state === 'approved' ? policy.policy : undefined, eventReceipt: event.receipt, eventScope };
+                }
+                const capabilities = (0, capabilities_1.readCapabilities)((0, capabilities_1.validateRuntimeKey)(envelope.runtime), checkedAt);
+                return { checkedAt, policy: policy.state === 'approved' ? policy.policy : undefined, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined };
+            } }, p.at ?? now());
         Object.assign(s, reserved.state);
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: reserved.attemptId });
         return;
@@ -125,7 +162,36 @@ function applyRequestToState(s, env, digest, repoRoot) {
         const p = env.payload;
         if (typeof p.attemptId !== 'string' || typeof p.nativeAgentId !== 'string' || (p.observed !== undefined && !(0, types_1.isRoutingSelection)(p.observed)) || (p.unavailableReason !== undefined && typeof p.unavailableReason !== 'string') || (p.at !== undefined && typeof p.at !== 'string'))
             throw new Error('routing-observe requiere payload estricto');
-        const observed = (0, journal_1.observeRoutingAttempt)(s, { attemptId: p.attemptId, nativeAgentId: p.nativeAgentId, ...(p.observed === undefined ? {} : { observed: p.observed }), ...(p.unavailableReason === undefined ? {} : { unavailableReason: p.unavailableReason }) }, p.at ?? now());
+        const attempt = s.routingAttempts?.find(item => item.id === p.attemptId);
+        if (!attempt)
+            throw new Error('routing-observe attempt is unknown');
+        let key = null;
+        if (attempt.nativeEvidenceRequired) {
+            try {
+                key = (0, machine_key_1.readMachineKey)((0, paths_2.awmHome)());
+            }
+            catch { /* missing/unsafe machine key is recorded as PROVENANCE_MISSING */ }
+        }
+        const proof = p.nativeProof;
+        const nativeProof = proof;
+        const checkedAt = new Date();
+        const validProof = attempt.nativeEvidenceRequired && key && attempt.reservedAt
+            ? (0, native_routing_proof_1.verifyNativeRoutingProof)(proof, { attemptId: p.attemptId, nativeAgentId: p.nativeAgentId,
+                reservedAt: attempt.reservedAt, selection: attempt.envelope.resolved }, key, checkedAt)
+                && checkedAt.getTime() - Date.parse(nativeProof.observedAt) <= 15 * 60_000
+                && currentNativeAttempt(repoRoot, attempt.envelope, eventScope, checkedAt)
+                && (attempt.envelope.runtime.target === 'codex' ? nativeProof?.source === 'codex-turn-context' : nativeProof?.source === 'claude-assistant-transcript')
+                && p.observed !== undefined && JSON.stringify(p.observed) === JSON.stringify(nativeProof?.selection)
+                && !s.routingAttempts?.some(item => item.id !== attempt.id && item.nativeEvidenceRequired
+                    && (item.nativeAgentId === p.nativeAgentId || item.nativeEventDigest === nativeProof?.eventDigest))
+            : false;
+        const observed = (0, journal_1.observeRoutingAttempt)(s, { attemptId: p.attemptId, nativeAgentId: p.nativeAgentId,
+            ...(validProof ? { observed: nativeProof.selection, nativeEventDigest: nativeProof.eventDigest,
+                ...(nativeProof.actualModel === undefined ? {} : { observedBackendModel: nativeProof.actualModel }) }
+                : attempt.nativeEvidenceRequired ? {} : p.observed === undefined ? {} : { observed: p.observed }),
+            ...(attempt.nativeEvidenceRequired
+                ? validProof ? {} : { unavailableReason: p.unavailableReason === 'PROVIDER_REJECTED' ? 'PROVIDER_REJECTED' : 'PROVENANCE_MISSING' }
+                : p.unavailableReason === undefined ? {} : { unavailableReason: p.unavailableReason }) }, p.at ?? now());
         Object.assign(s, observed);
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: p.attemptId });
         return;
@@ -533,7 +599,7 @@ function applyRequestToState(s, env, digest, repoRoot) {
 /** Consume TODAS las requests pendientes en orden. ORDEN CRITICO (R1.3,
  *  bloqueador 4): (1) mutar estado, (2) writeJournal, (3) borrar archivos,
  *  (4) fsync del directorio. Solo el supervisor llama esto (single-writer). */
-function consumePendingRequests(repoRoot, branch, activeToken) {
+function consumePendingRequests(repoRoot, branch, activeToken, eventScope) {
     const r = (0, store_1.readJournal)(repoRoot, branch);
     if (r.corrupt || r.state === null)
         throw new Error('journal corrupto: el supervisor no opera sobre corrupcion (R1.6)');
@@ -591,7 +657,7 @@ function consumePendingRequests(repoRoot, branch, activeToken) {
                 // nunca deja un estado parcialmente contaminado que luego no se
                 // pueda serializar o reintentar.
                 const candidate = structuredClone(s);
-                applyRequestToState(candidate, env, digest, repoRoot);
+                applyRequestToState(candidate, env, digest, repoRoot, eventScope);
                 s = candidate;
                 applied++;
                 stateTouched = true;

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

@@ -15,6 +15,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");
@@ -56,10 +59,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 });
     };
 }
@@ -414,7 +446,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 +730,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/types.js

@@ -94,6 +94,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,17 +213,31 @@ 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';