agentic-workflow-manager 9.11.11 → 9.12.0

package/dist/src/core/model-policy/native-routing-observe.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observeNativeRoutingChild = observeNativeRoutingChild;
+const crypto_1 = require("crypto");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+const capabilities_v2_1 = require("./capabilities-v2");
+const event_store_1 = require("./event-store");
+const local_event_scope_1 = require("./local-event-scope");
+const machine_key_1 = require("./machine-key");
+const capabilities_1 = require("./capabilities");
+const native_codex_1 = require("./native-codex");
+const native_routing_proof_1 = require("./native-routing-proof");
+const selection_policy_digest_1 = require("./selection-policy-digest");
+const store_1 = require("./store");
+function sameSelection(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+/** A bounded, read-mostly native observation for an already-dispatched child.
+ * Codex may refresh only its matching claim; Claude's Stop hook is the writer.
+ * No inference is started here. */
+async function observeNativeRoutingChild(input) {
+    if (!input || !input.attempt?.nativeEvidenceRequired || !input.attempt.reservedAt || input.attempt.state !== 'reserved'
+        || typeof input.nativeAgentId !== 'string' || input.nativeAgentId.length === 0 || input.nativeAgentId.length > 128
+        || typeof input.cwd !== 'string' || !path_1.default.isAbsolute(input.cwd) || !(input.now instanceof Date) || !Number.isFinite(input.now.getTime())
+        || !Array.isArray(input.consumedEventDigests) || input.consumedEventDigests.length > 4096
+        || input.consumedEventDigests.some(item => typeof item !== 'string' || !/^[a-f0-9]{64}$/.test(item)))
+        throw new Error('native routing observation is invalid');
+    const key = (0, machine_key_1.readMachineKey)((0, paths_1.awmHome)());
+    if (!key)
+        throw new Error('native routing machine key is missing');
+    const envelope = input.attempt.envelope;
+    const local = await (0, local_event_scope_1.queryLocalEventScope)(input.cwd, envelope.runtime.target, envelope.runtime.kind);
+    if (local.state !== 'current' || JSON.stringify(local.scope.runtime) !== JSON.stringify(envelope.runtime))
+        throw new Error('native routing runtime or account scope drifted');
+    const policy = (0, store_1.readEffectivePolicy)(input.cwd);
+    if (policy.state !== 'approved' || policy.policy.contentDigest !== envelope.policyDigest)
+        throw new Error('native routing policy drifted');
+    const mapping = policy.policy.content.mappings.find(row => row.target === envelope.runtime.target && row.runtimeKind === envelope.runtime.kind);
+    if (!mapping)
+        throw new Error('native routing mapping is absent');
+    const receipt = (0, event_store_1.readStoredEventReceipt)((0, capabilities_1.validateRuntimeKey)(envelope.runtime));
+    if (receipt.state !== 'present')
+        throw new Error('native routing receipt is absent or invalid');
+    const currentness = (0, capabilities_v2_1.evaluateEventReceipt)(receipt.receipt, local.scope, envelope.resolved, (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, envelope.resolved), input.now);
+    if (currentness.state !== 'current')
+        throw new Error(`native routing receipt drifted: ${currentness.reason}`);
+    let observed;
+    let observedAt;
+    let eventDigest;
+    let source;
+    let actualModel;
+    if (envelope.runtime.target === 'codex') {
+        if (typeof input.parentThreadId !== 'string' || input.parentThreadId.length === 0 || input.parentThreadId.length > 128)
+            throw new Error('Codex parent thread identity is required');
+        const child = await (0, native_codex_1.queryCodexChildThreadObservation)({ command: 'codex', args: ['app-server', '--stdio'], timeoutMs: 10000,
+            parentThreadId: input.parentThreadId, childThreadId: input.nativeAgentId,
+            codexHome: path_1.default.resolve(process.env.CODEX_HOME ?? path_1.default.join(os_1.default.homedir(), '.codex')) });
+        if (!child.acceptedSelectionVerified || child.childRuntimeVersion !== envelope.runtime.version || !child.observedAt)
+            throw new Error('Codex child turn selection is not natively verified');
+        observed = child.configuredSelection;
+        observedAt = child.observedAt;
+        const codexObservedMs = Date.parse(observedAt);
+        if (!Number.isFinite(codexObservedMs) || codexObservedMs < Date.parse(input.attempt.reservedAt)
+            || codexObservedMs > input.now.getTime() + 60_000 || input.now.getTime() - codexObservedMs > 15 * 60_000)
+            throw new Error('Codex native child turn is stale or predates reservation');
+        eventDigest = (0, crypto_1.createHash)('sha256').update(JSON.stringify({ parent: child.parentThreadId, child: child.childThreadId,
+            turn: child.turnId, selection: observed, runtimeVersion: child.childRuntimeVersion,
+            accountScopeDigest: local.scope.runtime.accountScopeDigest })).digest('hex');
+        source = 'codex-turn-context';
+        if (input.consumedEventDigests.includes(eventDigest))
+            throw new Error('Codex native child turn was already consumed');
+        if (sameSelection(observed, envelope.resolved)) {
+            (0, event_store_1.publishCodexObservation)({ scope: local.scope, observation: child, expectedSelection: envelope.resolved,
+                mappingDigest: (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, envelope.resolved), now: input.now });
+        }
+    }
+    else if (envelope.runtime.target === 'claude-code') {
+        const claim = receipt.receipt.claims.find(item => sameSelection(item.selection, envelope.resolved));
+        const agentDigest = (0, event_store_1.claudeAgentIdDigest)(input.nativeAgentId, key);
+        const event = claim?.nativeEvents?.find(item => item.nativeAgentIdDigest === agentDigest)
+            ?? (claim?.nativeAgentIdDigest === agentDigest ? { eventDigest: claim.eventDigest, observedAt: claim.observedAt } : undefined);
+        if (!claim || claim.source !== 'claude-assistant-transcript' || claim.nativeAgentType !== envelope.nativeAgentType || !event)
+            throw new Error('Claude Stop hook does not match this routed native child');
+        observed = claim.selection;
+        observedAt = event.observedAt;
+        eventDigest = event.eventDigest;
+        source = 'claude-assistant-transcript';
+        if (claim.actualModel !== 'unverified')
+            actualModel = claim.actualModel.id;
+        if (input.consumedEventDigests.includes(eventDigest))
+            throw new Error('Claude native child event was already consumed');
+    }
+    else
+        throw new Error('native routing provider is unsupported');
+    const observedMs = Date.parse(observedAt);
+    if (!Number.isFinite(observedMs) || observedMs < Date.parse(input.attempt.reservedAt)
+        || observedMs > input.now.getTime() + 60_000 || input.now.getTime() - observedMs > 15 * 60_000)
+        throw new Error('native routing event is stale or predates reservation');
+    return (0, native_routing_proof_1.signNativeRoutingProof)({ attemptId: input.attempt.id, nativeAgentId: input.nativeAgentId, source,
+        eventDigest, observedAt, selection: observed, ...(actualModel === undefined ? {} : { actualModel }) }, key);
+}

package/dist/src/core/model-policy/native-routing-proof.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signNativeRoutingProof = signNativeRoutingProof;
+exports.verifyNativeRoutingProof = verifyNativeRoutingProof;
+const crypto_1 = require("crypto");
+const types_1 = require("../journal/types");
+const DOMAIN = 'AWM native routing attempt/v1\0';
+function validBody(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const row = value;
+    return Object.keys(row).length === (row.actualModel === undefined ? 6 : 7) && Object.keys(row).every(key => ['attemptId', 'nativeAgentId', 'source', 'eventDigest', 'observedAt', 'selection', 'actualModel'].includes(key))
+        && typeof row.attemptId === 'string' && row.attemptId.length > 0 && row.attemptId.length <= 128
+        && typeof row.nativeAgentId === 'string' && row.nativeAgentId.length > 0 && row.nativeAgentId.length <= 128
+        && (row.source === 'codex-turn-context' || row.source === 'claude-assistant-transcript')
+        && typeof row.eventDigest === 'string' && /^[a-f0-9]{64}$/.test(row.eventDigest)
+        && typeof row.observedAt === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(row.observedAt)
+        && Number.isFinite(Date.parse(row.observedAt)) && (0, types_1.isRoutingSelection)(row.selection)
+        && (row.actualModel === undefined || (row.source === 'claude-assistant-transcript' && typeof row.actualModel === 'string' && row.actualModel.length > 0 && row.actualModel.length <= 128));
+}
+function signature(body, key) {
+    if (!Buffer.isBuffer(key) || key.length !== 32)
+        throw new Error('native routing machine key is invalid');
+    return (0, crypto_1.createHmac)('sha256', key).update(DOMAIN).update(JSON.stringify(body)).digest('hex');
+}
+function signNativeRoutingProof(input, key) {
+    if (!validBody(input))
+        throw new Error('native routing proof body is invalid');
+    const body = { attemptId: input.attemptId, nativeAgentId: input.nativeAgentId, source: input.source,
+        eventDigest: input.eventDigest, observedAt: input.observedAt, selection: input.selection,
+        ...(input.actualModel === undefined ? {} : { actualModel: input.actualModel }) };
+    return { schema: 'native-routing-proof/v1', ...body, mac: signature(body, key) };
+}
+function verifyNativeRoutingProof(value, expected, key, now) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || !expected || typeof expected !== 'object'
+        || !(now instanceof Date) || !Number.isFinite(now.getTime()))
+        return false;
+    const row = value;
+    if (Object.keys(row).length !== (row.actualModel === undefined ? 8 : 9) || row.schema !== 'native-routing-proof/v1' || typeof row.mac !== 'string' || !/^[a-f0-9]{64}$/.test(row.mac))
+        return false;
+    const body = { attemptId: row.attemptId, nativeAgentId: row.nativeAgentId, source: row.source,
+        eventDigest: row.eventDigest, observedAt: row.observedAt, selection: row.selection,
+        ...(row.actualModel === undefined ? {} : { actualModel: row.actualModel }) };
+    if (!validBody(body) || body.attemptId !== expected.attemptId || body.nativeAgentId !== expected.nativeAgentId
+        || !(0, types_1.isRoutingSelection)(expected.selection)
+        || typeof expected.reservedAt !== 'string' || !Number.isFinite(Date.parse(expected.reservedAt)))
+        return false;
+    const observedMs = Date.parse(body.observedAt);
+    if (observedMs < Date.parse(expected.reservedAt) || observedMs > now.getTime() + 60_000 || now.getTime() - observedMs > 15 * 60_000)
+        return false;
+    return (0, crypto_1.timingSafeEqual)(Buffer.from(row.mac, 'hex'), Buffer.from(signature(body, key), 'hex'));
+}

package/dist/src/core/model-policy/native-runtime.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRuntimeExecutable = queryRuntimeExecutable;
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function executablePath(command) {
+    if (typeof command !== 'string' || command.length === 0 || command.length > 4096 || /[\u0000-\u001f\u007f-\u009f]/.test(command))
+        throw new Error('runtime executable command is invalid');
+    const names = process.platform === 'win32' && path_1.default.extname(command) === '' ? [command, `${command}.exe`] : [command];
+    const candidates = path_1.default.isAbsolute(command) ? names : (process.env.PATH ?? '').split(path_1.default.delimiter).filter(Boolean).flatMap(dir => names.map(name => path_1.default.join(dir, name)));
+    for (const candidate of candidates) {
+        try {
+            fs_1.default.accessSync(candidate, fs_1.default.constants.X_OK);
+            const real = fs_1.default.realpathSync(candidate);
+            if (!fs_1.default.statSync(real).isFile())
+                continue;
+            return real;
+        }
+        catch { /* keep looking */ }
+    }
+    throw new Error('runtime executable is unavailable');
+}
+function versionOf(file, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(file, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'], shell: false });
+        let settled = false;
+        let output = '';
+        const finish = (error, version) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error) {
+                child.kill();
+                reject(error);
+            }
+            else
+                resolve(version);
+        };
+        const timer = setTimeout(() => finish(new Error('runtime version query timed out')), timeoutMs);
+        child.on('error', () => finish(new Error('runtime executable could not start')));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => { output += chunk; if (output.length > 4096)
+            finish(new Error('runtime version output exceeds limit')); });
+        child.on('exit', code => {
+            if (code !== 0)
+                return finish(new Error('runtime version command failed'));
+            const match = output.match(/\b(?:v)?(\d+\.\d+\.\d+)\b/);
+            if (!match)
+                return finish(new Error('runtime version is unavailable'));
+            finish(undefined, match[1]);
+        });
+    });
+}
+function hashFile(file) {
+    return new Promise((resolve, reject) => {
+        const before = fs_1.default.statSync(file);
+        if (!before.isFile() || before.size > 512 * 1024 * 1024)
+            return reject(new Error('runtime executable file is invalid or too large'));
+        const hash = (0, crypto_1.createHash)('sha256');
+        const stream = fs_1.default.createReadStream(file);
+        stream.on('data', chunk => hash.update(chunk));
+        stream.on('error', () => reject(new Error('runtime executable could not be read')));
+        stream.on('end', () => {
+            const after = fs_1.default.statSync(file);
+            if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs)
+                return reject(new Error('runtime executable changed while hashing'));
+            resolve(hash.digest('hex'));
+        });
+    });
+}
+/** Fingerprint the executable reached by PATH and query only --version. */
+async function queryRuntimeExecutable(input) {
+    if (!input || typeof input !== 'object' || !Array.isArray(input.args) || input.args.length !== 1 || input.args[0] !== '--version'
+        || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 30000)
+        throw new Error('runtime version query is invalid');
+    const file = executablePath(input.command);
+    const version = await versionOf(file, input.timeoutMs);
+    const binaryDigest = await hashFile(file);
+    return { version, binaryDigest, inferenceDispatched: false };
+}

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

@@ -1,11 +1,125 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEventSelection = resolveEventSelection;
+exports.resolveEventWithFallback = resolveEventWithFallback;
+exports.resolveEscalatedSelection = resolveEscalatedSelection;
 exports.resolveDispatch = resolveDispatch;
 exports.resolveV1Dispatch = resolveV1Dispatch;
 exports.resolveSelection = resolveSelection;
+const crypto_1 = require("crypto");
 const capabilities_1 = require("./capabilities");
+const capabilities_v2_1 = require("./capabilities-v2");
+const selection_policy_digest_1 = require("./selection-policy-digest");
 const validate_1 = require("./validate");
 const validate_2 = require("../plan/validate");
+/** Event-scoped v2 evidence has no clock expiry. It is never converted into a
+ * v1 approval or promoted to backend-model proof. */
+function resolveEventSelection(input) {
+    if (!input || typeof input !== 'object' || !input.scope || !(input.now instanceof Date) || !Number.isFinite(input.now.getTime()))
+        throw new Error('event selection requires scope and finite clock');
+    if (!['implementer', 'specification-reviewer', 'code-quality-reviewer', 'final-reviewer', 'architecture', 'track-a-qa', 'track-b-qa', 'controller', 'documentation', 'retro', 'finishing'].includes(input.role))
+        throw new Error('event selection role is invalid');
+    if (!['mechanical', 'integration', 'judgment', 'full'].includes(input.requestedProfile))
+        throw new Error('event selection profile is invalid');
+    if (!input.policy)
+        return blocked('ROUTING_POLICY_ABSENT', 'An approved routing policy is required.');
+    if (!input.receipt)
+        return blocked('ROUTING_CAPABILITY_ABSENT', 'Native event enrollment is absent.');
+    let policy;
+    try {
+        policy = (0, validate_1.validateApprovedPolicy)(input.policy);
+    }
+    catch {
+        return blocked('ROUTING_POLICY_INVALID', 'Approved routing policy is corrupt.');
+    }
+    const mapping = policy.content.mappings.find(row => row.target === input.scope.runtime.target && row.runtimeKind === input.scope.runtime.kind);
+    if (!mapping)
+        return blocked('ROUTING_POLICY_MAPPING_ABSENT', 'Approved policy has no exact target/runtime mapping.');
+    const effectiveProfile = input.role === 'implementer' ? input.requestedProfile : 'full';
+    const wanted = effectiveProfile === 'full' ? mapping.fullCapability : mapping.profiles[effectiveProfile];
+    let receipt;
+    try {
+        receipt = (0, capabilities_v2_1.validateEventReceipt)(input.receipt);
+    }
+    catch {
+        return blocked('ROUTING_CAPABILITY_INVALID', 'Native event enrollment is corrupt.');
+    }
+    let currentness;
+    try {
+        currentness = (0, capabilities_v2_1.evaluateEventReceipt)(receipt, input.scope, wanted, (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, wanted), input.now);
+    }
+    catch {
+        return blocked('ROUTING_CAPABILITY_INVALID', 'Native event enrollment or scope is invalid.');
+    }
+    if (currentness.state === 'drift')
+        return blocked(`ROUTING_${currentness.reason}`, `Native event enrollment is not current: ${currentness.reason}.`);
+    const claim = receipt.claims.find(item => equal(item.selection, wanted));
+    if (!claim)
+        return blocked('ROUTING_SELECTION_UNENROLLED', 'Approved selection has no native event enrollment.');
+    if (input.scope.runtime.target === 'claude-code' && !claim.nativeAgentType)
+        return blocked('ROUTING_AGENT_TYPE_UNVERIFIED', 'Claude native agent type is not bound to the enrolled selection.');
+    if (claim.actualModel === 'unverified') {
+        if (!mapping.degradation.allowMissingObservedIdentity)
+            return blocked('ROUTING_OBSERVED_IDENTITY_UNAVAILABLE', 'Actual backend model is unverified and policy does not permit operational routing.');
+        return { state: 'resolved', selection: wanted, effectiveProfile, outcome: 'degraded', policyDigest: policy.contentDigest,
+            capabilityDigest: (0, crypto_1.createHash)('sha256').update(JSON.stringify(receipt)).digest('hex'), unavailableEvidence: ['observedModelEvidence'], ...(claim.nativeAgentType ? { nativeAgentType: claim.nativeAgentType } : {}) };
+    }
+    if (wanted.selector.kind !== 'model' || claim.actualModel.id !== wanted.selector.id)
+        return blocked('ROUTING_SELECTION_MISMATCH', 'Native backend model does not match the approved selection.');
+    return { state: 'resolved', selection: wanted, effectiveProfile, outcome: 'native', policyDigest: policy.contentDigest,
+        capabilityDigest: (0, crypto_1.createHash)('sha256').update(JSON.stringify(receipt)).digest('hex'), unavailableEvidence: [], ...(claim.nativeAgentType ? { nativeAgentType: claim.nativeAgentType } : {}) };
+}
+function resolveEventWithFallback(input) {
+    const preferred = resolveEventSelection(input);
+    if ((preferred.state === 'resolved' && !input.circuitReason) || input.role !== 'implementer' || input.requestedProfile === 'full')
+        return preferred;
+    const full = resolveEventSelection({ ...input, role: 'code-quality-reviewer', requestedProfile: 'full' });
+    const reason = input.circuitReason ?? (preferred.state === 'blocked' ? preferred.diagnostics[0].code : 'PROVENANCE_MISSING');
+    if (full.state === 'blocked')
+        return blocked('ROUTING_FALLBACK_UNAVAILABLE', `Optimized route ${reason} and full fallback ${full.diagnostics[0].code}; enroll the missing selection with awm model-policy setup.`);
+    return { ...full, effectiveProfile: 'full', outcome: 'degraded', fallbackReason: reason };
+}
+function resolveEscalatedSelection(input) {
+    if (!input || input.role !== 'implementer' || !['medium', 'high', 'runtime-default'].includes(input.expectedEffort))
+        throw new Error('escalated selection requires an implementer and a supported effort');
+    const selected = resolveConfiguredSelection(input);
+    if (selected.state === 'blocked')
+        return selected;
+    if (selected.fallbackReason)
+        return selected;
+    const effort = selected.selection.effort;
+    if (input.expectedEffort === 'runtime-default')
+        return effort.kind === 'runtime-default' ? selected : blocked('ROUTING_ESCALATION_EFFORT_UNAVAILABLE', 'The approved selected effort does not match runtime-default escalation.');
+    if (input.requestedProfile !== 'judgment')
+        return effort.kind === 'explicit' && effort.value === input.expectedEffort ? selected : blocked('ROUTING_ESCALATION_EFFORT_UNAVAILABLE', 'The approved selected effort does not match the next lineage escalation.');
+    if (effort.kind === 'explicit' && effort.value === 'medium' && input.expectedEffort === 'medium')
+        return selected;
+    const full = resolveConfiguredSelection({ ...input, role: 'code-quality-reviewer', requestedProfile: 'full' });
+    if (full.state === 'blocked')
+        return full;
+    const sameModel = full.selection.selector.kind === selected.selection.selector.kind && full.selection.selector.id === selected.selection.selector.id;
+    if (!sameModel || full.selection.effort.kind !== 'explicit' || full.selection.effort.value !== 'high')
+        return blocked('ROUTING_ESCALATION_EFFORT_UNAVAILABLE', 'Judgment high requires the same approved full-capability model at explicit high effort.');
+    if (effort.kind === 'explicit' && effort.value === 'high')
+        return selected;
+    if (effort.kind === 'explicit' && effort.value === 'medium' && input.expectedEffort === 'high')
+        return { ...full, effectiveProfile: 'judgment' };
+    return blocked('ROUTING_ESCALATION_EFFORT_UNAVAILABLE', 'The approved selected effort does not match the next lineage escalation.');
+}
+function resolveConfiguredSelection(input) {
+    if (input.eventReceipt !== undefined || input.eventScope !== undefined) {
+        if (!input.eventReceipt || !input.eventScope)
+            return blocked('ROUTING_EVENT_SCOPE_MISSING', 'Event-scoped routing requires both a receipt and local scope.');
+        const mapping = input.policy?.content.mappings.find(item => item.target === input.eventScope?.runtime.target && item.runtimeKind === input.eventScope?.runtime.kind);
+        const wanted = mapping && input.role === 'implementer' && input.requestedProfile !== 'full' ? mapping.profiles[input.requestedProfile] : undefined;
+        const incident = wanted && input.circuitIncidents?.find(item => item.target === input.eventScope?.runtime.target
+            && equal(item.selection, wanted)
+            && ['PROVIDER_REJECTED', 'SELECTION_MISMATCH', 'PROVENANCE_MISSING'].includes(item.reasonCode));
+        const circuitReason = incident?.reasonCode;
+        return resolveEventWithFallback({ role: input.role, requestedProfile: input.requestedProfile, policy: input.policy, receipt: input.eventReceipt, scope: input.eventScope, now: input.now, circuitReason });
+    }
+    return resolveSelection(input);
+}
 /** Resolve only from the immutable validator report; a reopened plan may never
  * provide a routing profile after validation. */
 function resolveDispatch(input) {
@@ -25,14 +139,14 @@ function resolveDispatch(input) {
             throw new Error('local routing requires a valid slice');
         if (!local && input.sliceId !== undefined)
             throw new Error('slice is only valid for local routing');
-        return resolveSelection({ ...input, requestedProfile: 'full' });
+        return resolveConfiguredSelection({ ...input, requestedProfile: 'full' });
     }
     if (typeof input.sliceId !== 'string' || input.sliceId.length === 0)
         throw new Error('implementer routing requires a slice');
     const slice = input.plan.manifest.slices.find(candidate => candidate.id === input.sliceId);
     if (!slice)
         throw new Error('routing slice does not exist in the validated plan');
-    return resolveSelection({ ...input, requestedProfile: slice.implementerProfile });
+    return resolveConfiguredSelection({ ...input, requestedProfile: slice.implementerProfile });
 }
 function resolveV1Dispatch(input) {
     if (!input.plan || input.plan.schema !== 'compact-slices/v1')
@@ -40,7 +154,7 @@ function resolveV1Dispatch(input) {
     (0, validate_2.assertVerifiedValidPlanReport)(input.plan);
     if (!input.optInV1)
         return { state: 'not-required', reason: 'v1-without-opt-in' };
-    return resolveSelection({ ...input, requestedProfile: 'full' });
+    return resolveConfiguredSelection({ ...input, requestedProfile: 'full' });
 }
 function equal(left, right) { return left.selector.kind === right.selector.kind && left.selector.id === right.selector.id && left.effort.kind === right.effort.kind && (left.effort.kind !== 'explicit' || left.effort.value === right.effort.value); }
 function blocked(code, message) { return { state: 'blocked', diagnostics: [(0, capabilities_1.routingDiagnostic)(code, message)] }; }

package/dist/src/core/model-policy/selection-policy-digest.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectionPolicyDigest = selectionPolicyDigest;
+const crypto_1 = require("crypto");
+const validate_1 = require("./validate");
+function same(left, right) {
+    return left.selector.kind === right.selector.kind && left.selector.id === right.selector.id
+        && left.effort.kind === right.effort.kind
+        && (left.effort.kind !== 'explicit' || left.effort.value === right.effort.value);
+}
+/** This digest binds what native work proved: the selected model and effort.
+ * Degradation permission is evaluated at dispatch and may be approved later
+ * without forcing a second native run for the same selection. */
+function selectionPolicyDigest(mapping, selection) {
+    const validated = (0, validate_1.validatePolicyContent)({ schema: 'model-policy/v1', mappings: [mapping],
+        implementationBudget: { maxAttempts: 3, escalation: ['mechanical', 'integration', 'judgment'], judgmentEfforts: ['medium', 'high'] } }).mappings[0];
+    const requested = [validated.profiles.mechanical, validated.profiles.integration, validated.profiles.judgment, validated.fullCapability];
+    const found = requested.find(item => same(item, selection));
+    if (!found)
+        throw new Error('selection is not approved in this mapping');
+    return (0, crypto_1.createHash)('sha256').update(JSON.stringify({ target: validated.target, runtimeKind: validated.runtimeKind, selection: found })).digest('hex');
+}

package/dist/src/core/model-policy/setup-readiness.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routingSetupGuidance = routingSetupGuidance;
+const store_1 = require("./store");
+const capabilities_1 = require("./capabilities");
+const json_1 = require("../plan/json");
+const event_store_1 = require("./event-store");
+const capabilities_v2_1 = require("./capabilities-v2");
+const selection_policy_digest_1 = require("./selection-policy-digest");
+/** Local guidance only: no provider process, inference, approval or filesystem write. */
+function locallyCurrentReceipt(mapping, now) {
+    try {
+        const raw = (0, store_1.readBoundedCandidate)((0, capabilities_1.storedCapabilityPath)(mapping.target, mapping.runtimeKind));
+        if (raw === null)
+            return false;
+        const receipt = (0, capabilities_1.validateCapabilityReceipt)((0, json_1.parseJsonNoDuplicate)(raw));
+        const caps = receipt.capabilities;
+        return receipt.runtime.target === mapping.target && receipt.runtime.kind === mapping.runtimeKind
+            && (0, capabilities_1.receiptIsCurrent)(receipt, receipt.runtime, now)
+            && caps.nativeSubagents === 'supported' && caps.modelOverride === 'supported' && caps.effortOverride === 'supported'
+            && (caps.observedModelEvidence === 'supported' || mapping.degradation.allowMissingObservedIdentity);
+    }
+    catch {
+        return false;
+    }
+}
+/** Passive diagnostics can check sealed coverage, but only dispatch recomputes
+ * runtime/account/config fingerprints. No provider process runs here. */
+function locallyEnrolledEvent(mapping, now, reader) {
+    if (mapping.target !== 'codex' && mapping.target !== 'claude-code')
+        return 'absent';
+    try {
+        const stored = reader({ target: mapping.target, kind: mapping.runtimeKind, version: '0.0.0', accountScopeDigest: '0'.repeat(64) });
+        if (stored.state !== 'present')
+            return stored.state;
+        const receipt = stored.receipt;
+        if (receipt.runtime.target !== mapping.target || receipt.runtime.kind !== mapping.runtimeKind)
+            return 'uncovered';
+        const scope = { runtime: receipt.runtime, binaryDigest: receipt.binaryDigest, configDigest: receipt.configDigest };
+        const selections = [...Object.values(mapping.profiles), mapping.fullCapability];
+        return selections.every(selected => {
+            const current = (0, capabilities_v2_1.evaluateEventReceipt)(receipt, scope, selected, (0, selection_policy_digest_1.selectionPolicyDigest)(mapping, selected), now);
+            if (current.state !== 'current')
+                return false;
+            const claim = receipt.claims.find(item => JSON.stringify(item.selection) === JSON.stringify(selected));
+            return claim !== undefined && (claim.actualModel !== 'unverified' || mapping.degradation.allowMissingObservedIdentity);
+        }) ? 'covered' : 'uncovered';
+    }
+    catch {
+        return 'invalid';
+    }
+}
+function routingSetupGuidance(policy, now = new Date(), deps = {}) {
+    if (!policy || typeof policy !== 'object' || !('state' in policy))
+        throw new Error('routing policy state is invalid');
+    if (!(now instanceof Date) || !Number.isFinite(now.getTime()))
+        throw new Error('routing setup clock must be finite');
+    if (policy.state === 'absent')
+        return [];
+    if (policy.state === 'invalid') {
+        if (typeof policy.reason !== 'string' || policy.reason.length === 0 || policy.reason.length > 4096)
+            throw new Error('routing policy invalid reason is malformed');
+        return [{ state: 'policy-invalid', reason: policy.reason }];
+    }
+    if (policy.state !== 'approved' || !policy.policy || !Array.isArray(policy.policy.content?.mappings))
+        throw new Error('approved routing policy state is malformed');
+    return policy.policy.content.mappings.flatMap(mapping => {
+        if (typeof mapping.target !== 'string' || typeof mapping.runtimeKind !== 'string' || !/^[a-z0-9][a-z0-9_-]{0,127}$/.test(mapping.runtimeKind))
+            throw new Error('routing policy mapping is malformed');
+        const event = locallyEnrolledEvent(mapping, now, deps.readStoredEventReceipt ?? event_store_1.readStoredEventReceipt);
+        if (event === 'covered')
+            return [{ target: mapping.target, runtimeKind: mapping.runtimeKind, state: 'coverage-only' }];
+        if (event === 'absent' && locallyCurrentReceipt(mapping, now))
+            return [];
+        return [{ target: mapping.target, runtimeKind: mapping.runtimeKind, state: 'needs-evidence', command: `awm model-policy setup --provider ${mapping.target} --json` }];
+    });
+}

package/dist/src/providers/index.js

@@ -53,10 +53,12 @@ const CONFIG_HOME = {
     // Una corrida del playbook en una maquina con CODEX_HOME seteado encontro el hook
     // instalado donde Codex no mira. Ver docs/decisions.md D-011.
     codex: { envVar: 'CODEX_HOME', dir: '.codex' },
+    // Claude Code documenta CLAUDE_CONFIG_DIR para mover toda su configuracion,
+    // incluidos settings.json y transcripciones de subagentes.
+    'claude-code': { envVar: 'CLAUDE_CONFIG_DIR', dir: '.claude' },
     // Los demas usan su directorio por defecto. `null` es una afirmacion honesta —
     // "no le conocemos override"— y no un "no tiene". Cuando se confirme uno contra su
     // binario, se cambia aca y el guard obliga a que todas sus rutas lo sigan.
-    'claude-code': { envVar: null, dir: '.claude' },
     opencode: { envVar: null, dir: '.config/opencode' },
     cursor: { envVar: null, dir: '.cursor' },
     copilot: { envVar: null, dir: '.github' },

package/dist/tests/commands/doctor-routing.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const doctor_1 = require("../../src/commands/doctor");
+describe('doctor routing setup', () => {
+    it('adds a pending, non-degrading machine configuration action only to the mapped provider', () => {
+        const report = {
+            overall: 'healthy', providers: [
+                { id: 'codex', label: 'Codex', tier: 'hooks-native', checks: [] },
+                { id: 'claude-code', label: 'Claude Code', tier: 'hooks-native', checks: [] },
+            ],
+        };
+        const updated = (0, doctor_1.attachRoutingSetupGuidance)(report, [
+            { target: 'codex', runtimeKind: 'native', state: 'needs-evidence', command: 'awm model-policy discover --provider codex --json' },
+        ]);
+        expect(updated.providers[0].checks).toEqual([
+            { id: 'routing.machine', state: 'pending', detail: 'native routing evidence not checked for native', remediationCode: 'awm model-policy discover --provider codex --json' },
+        ]);
+        expect(updated.providers[1].checks).toEqual([]);
+        expect(updated.overall).toBe('healthy');
+        expect(report.providers[0].checks).toEqual([]);
+    });
+});

package/dist/tests/commands/doctor.test.js

@@ -39,6 +39,11 @@ describe('runDoctor legacy JSON fixtures', () => {
         }
     });
 });
+test('doctor labels sealed routing coverage as local-only without asking for recurring setup', () => {
+    const report = (0, doctor_1.attachRoutingSetupGuidance)({ overall: 'healthy', providers: [{ id: 'codex', label: 'Codex', tier: 'hooks-native', checks: [] }] }, [{ target: 'codex', runtimeKind: 'native', state: 'coverage-only' }]);
+    expect(report.providers[0].checks).toEqual([{ id: 'routing.machine', state: 'supported',
+            detail: 'sealed selection coverage for native only; current runtime/account/config scope is checked at routed dispatch' }]);
+});
 describe('runDoctor dashboard modes', () => {
     it('CLI rejects --html without an argument before collection or writes', async () => {
         const program = new commander_1.Command();

package/dist/tests/commands/hooks/install.test.js

@@ -59,6 +59,10 @@ describe('installHook (happy path + merge)', () => {
         expect(settings.hooks.SessionStart).toHaveLength(1);
         expect(settings.hooks.SessionStart[0].matcher).toBe('startup|clear|compact');
         expect(settings.hooks.SessionStart[0].hooks[0].command).toContain('run-hook.cmd');
+        expect(settings.hooks.SubagentStart[0].hooks[0].command).toBe('awm model-policy hook-event --event start');
+        expect(settings.hooks.SubagentStop[0].hooks[0].command).toBe('awm model-policy hook-event --event stop');
+        expect(settings.hooks.SubagentStart[0].hooks[0].async).toBe(false);
+        expect(settings.hooks.SubagentStop[0].hooks[0].async).toBe(false);
         expect(result.backupPath).toBeNull();
     });
     it('merges with pre-existing SessionStart entry from another plugin', () => {
@@ -96,6 +100,8 @@ describe('installHook (happy path + merge)', () => {
         expect(result2.status).toBe('already-up-to-date');
         const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf-8'));
         expect(settings.hooks.SessionStart).toHaveLength(1);
+        expect(settings.hooks.SubagentStart).toHaveLength(1);
+        expect(settings.hooks.SubagentStop).toHaveLength(1);
     });
     it('replaces a stale AWM entry when paths change', () => {
         const claudeDir = path_1.default.join(tmpHome, '.claude');

package/dist/tests/commands/hooks/resync.test.js

@@ -66,6 +66,9 @@ describe('resyncInstalledHooks', () => {
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
         ]);
+        const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf8'));
+        expect(settings.hooks.SubagentStart[0].hooks[0].command).toBe('awm model-policy hook-event --event start');
+        expect(settings.hooks.SubagentStop[0].hooks[0].command).toBe('awm model-policy hook-event --event stop');
         const synced = fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8');
         expect(synced).toContain('NEW VERSION');
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(false);

package/dist/tests/commands/hooks/status.test.js

@@ -42,7 +42,9 @@ describe('computeHookStatus', () => {
                 SessionStart: [{
                         matcher: 'startup|clear|compact',
                         hooks: [{ type: 'command', command: `${hooksDir}/run-hook.cmd session-start`, async: false }]
-                    }]
+                    }],
+                SubagentStart: [{ matcher: '.+', hooks: [{ type: 'command', command: 'awm model-policy hook-event --event start', async: false }] }],
+                SubagentStop: [{ matcher: '.+', hooks: [{ type: 'command', command: 'awm model-policy hook-event --event stop', async: false }] }]
             }
         }, null, 2));
     }
@@ -56,6 +58,15 @@ describe('computeHookStatus', () => {
         expect(result.checks.runHookWrapper.ok).toBe(true);
         expect(result.checks.settingsEntry.ok).toBe(true);
     });
+    it('does not certify a non-command routing hook with matching command text', () => {
+        setupInstalledHook();
+        const settings = path_1.default.join(tmpHome, '.claude/settings.json');
+        const parsed = JSON.parse(fs_1.default.readFileSync(settings, 'utf8'));
+        parsed.hooks.SubagentStart[0].hooks[0].type = 'prompt';
+        fs_1.default.writeFileSync(settings, JSON.stringify(parsed));
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        expect(computeHookStatus('claude-code').checks.routingCapture.ok).toBe(false);
+    });
     it('reports DEGRADED when bootstrap skill is missing', () => {
         setupInstalledHook();
         fs_1.default.unlinkSync(path_1.default.join(tmpHome, '.awm/hooks/using-awm.md'));