agentic-workflow-manager 9.12.3 → 9.12.5

package/dist/src/commands/watch/admission-recovery.js

@@ -32,7 +32,12 @@ function sameContext(a, b) {
         && a.runtime?.accountScopeDigest === b.runtime?.accountScopeDigest;
 }
 function admissionCustodyCause(reason) {
-    if (!reason || (reason.match(/ADMISSION_[A-Z_]+/g) ?? []).length !== 1)
+    if (!reason)
+        return undefined;
+    if (reason === 'runtime local cambió durante generacion admitida'
+        || /^runtime local no verificable: (?:NATIVE_QUERY_FAILED|ACCOUNT_UNVERIFIED|MACHINE_KEY_MISSING|HOOK_CAPTURE_FAILED)$/.test(reason))
+        return 'runtime';
+    if ((reason.match(/ADMISSION_[A-Z_]+/g) ?? []).length !== 1)
         return undefined;
     const old = reason.startsWith('admisión compacta desatendida bloqueada antes de dispatch: ');
     if ((old || reason.startsWith('admisión currentness no verificable tras 3 reintentos: '))
@@ -46,6 +51,12 @@ function admissionCustodyCause(reason) {
 function assertNoAmbiguousWork(repoRoot, branch, state) {
     if ((0, types_1.activeRequestProblems)(state).length > 0)
         throw new Error('recovery bloqueado: request rechazada o corrupta activa');
+    if (state.routingAttempts?.some(attempt => attempt.state !== 'reserved'
+        || attempt.nativeAgentId !== undefined || attempt.nativeEventDigest !== undefined
+        || attempt.observed !== undefined))
+        throw new Error('recovery bloqueado: intento nativo activo o ambiguo');
+    if (state.dispatches.some(dispatch => dispatch.routingAttemptId !== undefined))
+        throw new Error('recovery bloqueado: dispatch nativo ACK-applied sin prueba de child terminado');
     for (const generation of state.generations) {
         if ((0, generations_1.controllerGenerationHasUnresolvedClaim)(repoRoot, branch, generation))
             throw new Error('recovery bloqueado: claim de controller sin identidad demostrable');
@@ -87,7 +98,7 @@ async function recoverAdmissionCustody(repoRoot, branch, input, dispatchAdmissio
             && sameContext(previous.context, context))
             return 'already-recovered';
         if (state.cycle.status !== 'BLOCKED' || !admissionCustodyCause(state.cycle.blockedReason)) {
-            throw new Error('recovery solo admite custodia causada por admisión currentness o sensores');
+            throw new Error('recovery solo admite custodia causada por admisión currentness, sensores o runtime local verificable');
         }
         const latest = state.generations.at(-1);
         if (latest?.token !== input.generationToken || (latest === undefined && input.generationToken !== undefined)) {

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

@@ -29,6 +29,7 @@ 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");
+const process_1 = require("../../core/journal/process");
 function now() { return new Date().toISOString(); }
 function currentNativeAttempt(repoRoot, envelope, eventScope, at) {
     if (!eventScope || JSON.stringify(eventScope.runtime) !== JSON.stringify(envelope.runtime))
@@ -494,7 +495,80 @@ function applyRequestToState(s, env, digest, repoRoot, eventScope) {
             }
             else if (p.routingAttemptId !== undefined)
                 throw new Error('register --entity dispatch: routingAttemptId solo para compact v2');
+            const noLiveJobs = () => Object.values(s.jobs).every(job => ['exited', 'cancelled'].includes(job.executionState)
+                && [job.processRef, job.wrapperRef].every(ref => !ref || (!(0, process_1.refIsAlive)(ref) && (0, process_1.groupIsGone)(ref.processGroup))));
+            const historical = v2 ? s.dispatches.filter(d => d.taskId === taskId && !d.routingAttemptId) : [];
+            // A blocked routing verdict does not prove its native child has
+            // stopped. This migration permits exactly the first linked handoff;
+            // a subsequent retry needs a separately verified ownership path.
+            if (historical.some(d => d.id !== dispatchId))
+                throw new Error('register --entity dispatch: historical unlinked dispatch ID conflictivo');
             const existing = s.dispatches.find(d => d.id === dispatchId);
+            // A 9.12.2 controller could ACK the unlinked intent before it
+            // reserved the native route. Keep that record and ACK as history;
+            // only a fresh request can create the first linked handoff.
+            if (v2 && existing?.taskId === taskId && !existing.routingAttemptId && !existing.dispatchRequestId && routingAttemptId) {
+                const attempt = s.routingAttempts.find(candidate => candidate.id === routingAttemptId);
+                const linkedReplay = s.dispatches.find(d => d.dispatchRequestId === env.requestId);
+                if (linkedReplay) {
+                    const replayAck = s.appliedRequests[env.requestId];
+                    if (linkedReplay.taskId !== taskId || linkedReplay.routingAttemptId !== routingAttemptId
+                        || replayAck?.outcome !== 'applied' || replayAck.idempotencyKey !== env.idempotencyKey
+                        || replayAck.payloadDigest !== digest || replayAck.resultRef !== linkedReplay.id)
+                        throw new Error('register --entity dispatch: routed replay conflictivo');
+                    (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: linkedReplay.id });
+                    return;
+                }
+                const linkedPrior = s.dispatches.find(d => d.routingAttemptId === routingAttemptId);
+                if (linkedPrior) {
+                    const priorAck = linkedPrior.dispatchRequestId ? s.appliedRequests[linkedPrior.dispatchRequestId] : undefined;
+                    if (linkedPrior.taskId !== taskId || priorAck?.outcome !== 'applied'
+                        || priorAck.idempotencyKey !== env.idempotencyKey || priorAck.payloadDigest !== digest)
+                        throw new Error('register --entity dispatch: routed replay conflictivo');
+                    (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: linkedPrior.id });
+                    return;
+                }
+                const oldAt = Date.parse(existing.at);
+                const reservedAt = Date.parse(attempt.reservedAt ?? '');
+                // 9.12.2 emits {...JSON.parse(--json), entity}; JSON.stringify
+                // preserves caller key order. The old record has no request
+                // link, so accept only permutations of these exact three
+                // fields, not an unrelated resultRef or extra payload fields.
+                const legacyDigests = [
+                    { entity: 'dispatch', dispatchId: existing.id, taskId },
+                    { entity: 'dispatch', taskId, dispatchId: existing.id },
+                    { dispatchId: existing.id, entity: 'dispatch', taskId },
+                    { dispatchId: existing.id, taskId, entity: 'dispatch' },
+                    { taskId, entity: 'dispatch', dispatchId: existing.id },
+                    { taskId, dispatchId: existing.id, entity: 'dispatch' },
+                ].map(payload => (0, requests_1.digestOf)(payload));
+                const appliedAcks = Object.values(s.appliedRequests);
+                const oldAckIndex = appliedAcks.findIndex(ack => ack.outcome === 'applied'
+                    && ack.resultRef === existing.id && legacyDigests.includes(ack.payloadDigest));
+                const reservationAckIndex = appliedAcks.findIndex(ack => ack.requestId === attempt.reservationRequestId);
+                // The single writer appends ACKs to appliedRequests and persists
+                // their insertion order. Equal millisecond timestamps need this
+                // additional durable ordering evidence, not an inferred child.
+                const legacyPrecedesReservation = oldAt < reservedAt
+                    || (oldAt === reservedAt && oldAckIndex >= 0 && reservationAckIndex > oldAckIndex);
+                const safeLegacy = reservedForNewDispatch && Number.isFinite(oldAt) && Number.isFinite(reservedAt)
+                    && legacyPrecedesReservation
+                    && oldAckIndex >= 0
+                    && s.dispatches.filter(d => d.taskId === taskId).length === 1
+                    && s.tasks.find(t => t.id === taskId)?.attempts === 1
+                    && s.tasks.find(t => t.id === taskId)?.status === 'in-progress'
+                    && noLiveJobs()
+                    && !s.routingAttempts?.some(candidate => candidate.envelope.sliceId === taskId
+                        && (candidate.nativeAgentId || candidate.nativeEventDigest || candidate.observed));
+                if (!safeLegacy)
+                    throw new Error('register --entity dispatch: legacy handoff no reconciliable sin evidencia exclusiva');
+                const linkedId = `routed-${crypto_1.default.createHash('sha256').update(env.requestId).digest('hex').slice(0, 32)}`;
+                if (s.dispatches.some(d => d.id === linkedId) || s.dispatches.some(d => d.routingAttemptId === routingAttemptId))
+                    throw new Error('register --entity dispatch: routed ID o reservation conflictivo');
+                s.dispatches.push({ id: linkedId, taskId, at: now(), routingAttemptId, dispatchRequestId: env.requestId });
+                (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: linkedId });
+                return;
+            }
             if (existing && (existing.taskId !== taskId || existing.routingAttemptId !== routingAttemptId)) {
                 throw new Error('register --entity dispatch: dispatchId conflictivo');
             }

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

@@ -53,7 +53,7 @@ function routingFacts(provider, identity, cwd, deps = {}) {
         capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined, now: at };
 }
 function defaultDispatchAdmission(repoRoot, branch, provider, identity, deps = {}, autonomy) {
-    return async () => {
+    return async (request = {}) => {
         const observed = (0, store_1.readJournal)(repoRoot, branch);
         const binding = observed.state?.schema === 2 ? observed.state.planBinding : undefined;
         if (!binding || binding.executionMode !== 'desatendido') {
@@ -92,6 +92,7 @@ function defaultDispatchAdmission(repoRoot, branch, provider, identity, deps = {
             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,
+            freshSensorsRequired: request.freshSensorsRequired === true,
             journalState: observed.state, journalCorrupt: observed.corrupt, planPath: binding.path,
             routing,
             controllerAutonomy: autonomy });
@@ -370,11 +371,17 @@ class Supervisor {
                 try {
                     local = await (0, local_event_scope_1.queryLocalEventScope)(this.repoRoot, expected.target, expected.kind);
                 }
-                catch (error) {
-                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, `runtime local no verificable: ${error.message}`);
+                catch {
+                    // Stable, non-sensitive custody reason remains recoverable
+                    // after a transient native query or permission failure.
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'runtime local no verificable: NATIVE_QUERY_FAILED');
+                    return 'custody';
+                }
+                if (local.state !== 'current') {
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, `runtime local no verificable: ${local.reason}`);
                     return 'custody';
                 }
-                if (local.state !== 'current' || JSON.stringify(local.scope.runtime) !== JSON.stringify(expected)) {
+                if (JSON.stringify(local.scope.runtime) !== JSON.stringify(expected)) {
                     (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'runtime local cambió durante generacion admitida');
                     return 'custody';
                 }
@@ -814,7 +821,7 @@ class Supervisor {
         // after RED edits, runtime drift, or a currentness change.
         let replacementAdmission;
         try {
-            replacementAdmission = await this.dispatchAdmission();
+            replacementAdmission = await this.dispatchAdmission({ freshSensorsRequired: true });
         }
         catch (error) {
             (0, generations_1.enterCustody)(this.repoRoot, this.branch, `admisión de reemplazo no verificable: ${error.message}`);
@@ -822,7 +829,7 @@ class Supervisor {
         }
         if (replacementAdmission.state !== 'admitted' || replacementAdmission.executionMode !== 'desatendido'
             || replacementAdmission.currentness !== 'current' || replacementAdmission.sensors !== 'pass'
-            || replacementAdmission.journal !== 'current') {
+            || replacementAdmission.journal !== 'current' || replacementAdmission.sensorEvidence === 'generation-bound') {
             (0, generations_1.enterCustody)(this.repoRoot, this.branch, `admisión de reemplazo bloqueada antes de dispatch: ${replacementAdmission.diagnostics.map(d => `${d.code}: ${d.message}`).join('; ')}`);
             return 'custody';
         }

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

@@ -166,6 +166,8 @@ function sanitizeAdmissionReport(report) {
         invalidAdmission();
     if (value.cliCurrentness !== undefined && !CLI_CURRENTNESS.has(value.cliCurrentness))
         invalidAdmission();
+    if (value.sensorEvidence !== undefined && value.sensorEvidence !== 'generation-bound')
+        invalidAdmission();
     if (value.planDigest !== undefined && (typeof value.planDigest !== 'string' || !/^[a-f0-9]{64}$/.test(value.planDigest)))
         invalidAdmission();
     if (value.executionMode !== undefined && value.executionMode !== 'interactivo' && value.executionMode !== 'desatendido')

package/dist/src/core/admission/registry-contracts.js

@@ -19,6 +19,10 @@ const versioning_1 = require("../versioning");
 const check_1 = require("../currentness/check");
 const run_1 = require("../../commands/sensors/run");
 const index_1 = require("./index");
+const store_1 = require("../journal/store");
+const paths_1 = require("../journal/paths");
+const generations_1 = require("../../commands/watch/generations");
+const process_1 = require("../journal/process");
 const FRAMEWORK_CONTRACTS = ['using-awm', 'writing-plans', 'development-process', 'subagent-driven-development', 'executing-plans', 'post-implementation-qa', 'post-implementation-docs', 'harness-retro', 'finishing-a-development-branch'];
 const MAX_CONTRACT_BYTES = 1024 * 1024;
 const MAX_MANIFEST_BYTES = 256 * 1024;
@@ -217,6 +221,56 @@ function registryCompatibility(registries, consumed) {
     }
     return diagnostics;
 }
+/** A controller may ask for admission while its supervisor is writing journal
+ * events. The already-launched generation passed sensors before launch; its
+ * durable intent plus verified live process identity is the evidence, not a
+ * second tree snapshot. A claim alone never certifies process ownership. */
+function hasOwnedGenerationAdmission(input) {
+    if (!input.verifySensors || input.freshSensorsRequired || input.executionMode !== 'desatendido' || input.plan.state !== 'valid'
+        || input.journalCorrupt || !input.journalState || input.journalState.schema !== 2
+        || input.journalState.cycle.status !== 'IN_PROGRESS'
+        || input.journalState.admissionContext?.provider !== input.provider
+        || input.journalState.admissionContext.controllerAutonomy !== input.controllerAutonomy)
+        return false;
+    const observed = input.journalState;
+    const binding = observed.planBinding;
+    if (!binding)
+        return false;
+    if (input.plan.schema === 'compact-slices/v2' && !observed.admissionContext?.runtime)
+        return false;
+    let expectedPath;
+    try {
+        expectedPath = (0, paths_1.bindingPlanPath)(input.planPath ?? '');
+    }
+    catch {
+        return false;
+    }
+    if (binding.path !== expectedPath || binding.digest !== input.plan.planDigest || binding.schema !== input.plan.schema
+        || (binding.executionDigest !== undefined && binding.executionDigest !== input.plan.executionDigest))
+        return false;
+    let fresh;
+    try {
+        fresh = (0, store_1.readJournal)(input.cwd, observed.branch);
+    }
+    catch {
+        return false;
+    }
+    if (fresh.corrupt || !fresh.state || fresh.state.cycle.status !== 'IN_PROGRESS'
+        || fresh.state.revision < observed.revision || JSON.stringify(fresh.state.planBinding) !== JSON.stringify(binding)
+        || JSON.stringify(fresh.state.admissionContext) !== JSON.stringify(observed.admissionContext))
+        return false;
+    const generation = (0, generations_1.activeGeneration)(fresh.state);
+    if (!generation || generation !== fresh.state.generations.at(-1)
+        || generation.provider !== input.provider || !generation.controllerJobId || !generation.launchArgvDigest)
+        return false;
+    const prior = observed.generations.find(item => item.token === generation.token);
+    if (!prior || prior.controllerJobId !== generation.controllerJobId || prior.launchArgvDigest !== generation.launchArgvDigest)
+        return false;
+    return (generation.processRef !== undefined && generation.processRef.spawnNonce === generation.spawnNonce
+        && generation.processRef.argvDigest === generation.launchArgvDigest && (0, process_1.refIsAlive)(generation.processRef))
+        || (generation.wrapperRef !== undefined && generation.wrapperRef.spawnNonce === generation.spawnNonce
+            && (0, process_1.refIsAlive)(generation.wrapperRef));
+}
 /** One admission authority for the public command AND actual watch dispatch.
  * No empirical execution occurs before provenance/currentness/CLI-floor gates. */
 async function admitRegistryPlan(input, dependencies = {}) {
@@ -253,12 +307,14 @@ async function admitRegistryPlan(input, dependencies = {}) {
         }
         return scope.provenance === 'proven';
     };
+    let generationBound = false;
     const compose = async (fields) => {
         const report = await admission({ ...input, provenance: scope.provenance, consumedRegistryComponents: scope.consumedRegistryComponents, ...fields });
+        const withEvidence = generationBound && report.sensors === 'pass' ? { ...report, sensorEvidence: 'generation-bound' } : report;
         if (scope.provenanceDiagnostic && report.diagnostics.some(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED')) {
-            return { ...report, diagnostics: report.diagnostics.map(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED' ? scope.provenanceDiagnostic : diagnostic) };
+            return { ...withEvidence, diagnostics: report.diagnostics.map(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED' ? scope.provenanceDiagnostic : diagnostic) };
         }
-        return report;
+        return withEvidence;
     };
     let currentness = input.currentness;
     let compatibilityDiagnostics;
@@ -277,7 +333,10 @@ async function admitRegistryPlan(input, dependencies = {}) {
         if (compatibilityGate.currentness !== 'current')
             return compatibilityGate;
     }
-    const sensors = input.verifySensors ? input.sensors ?? await (dependencies.runSensors ?? run_1.runSensors)({ cwd: input.cwd, all: true, readOnly: true }) : undefined;
+    generationBound = input.sensors === undefined && hasOwnedGenerationAdmission(input);
+    const sensors = input.verifySensors ? input.sensors ?? (generationBound
+        ? { sensors: [], overall: 'pass', reason: 'generation-bound-admission' }
+        : await (dependencies.runSensors ?? run_1.runSensors)({ cwd: input.cwd, all: true, readOnly: true })) : undefined;
     if (input.requireCurrent && input.verifySensors) {
         if (!refresh())
             return compose({ currentness, sensors });
@@ -286,5 +345,17 @@ async function admitRegistryPlan(input, dependencies = {}) {
             return currentnessGate;
         compatibilityDiagnostics = registryCompatibility(registries, scope.consumedRegistryComponents);
     }
+    if (generationBound && input.plan.schema === 'compact-slices/v2') {
+        const routing = input.routing ?? await dependencies.readRouting?.();
+        const expected = input.journalState?.admissionContext?.runtime;
+        if (!expected || !routing?.runtime || routing.runtime.target !== input.provider
+            || routing.runtime.kind !== expected.kind || routing.runtime.version !== expected.version
+            || routing.runtime.accountScopeDigest !== expected.accountScopeDigest) {
+            return compose({ currentness, compatibilityDiagnostics, sensors,
+                routing: { ...routing, eventIssue: { code: 'ADMISSION_GENERATION_RUNTIME_MISMATCH',
+                        message: 'Live runtime identity differs from the admitted controller generation; stop and recover with a fresh admission.' } } });
+        }
+        return compose({ currentness, compatibilityDiagnostics, sensors, routing });
+    }
     return compose({ currentness, compatibilityDiagnostics, sensors, ...(dependencies.readRouting ? { routingReader: dependencies.readRouting } : {}) });
 }

package/dist/tests/commands/watch/admission-recovery.test.js

@@ -51,6 +51,7 @@ const supervisor_1 = require("../../../src/commands/watch/supervisor");
 const admission_recovery_1 = require("../../../src/commands/watch/admission-recovery");
 const watch_1 = require("../../../src/commands/watch");
 const supervisorModule = __importStar(require("../../../src/commands/watch/supervisor"));
+const routing_approval_1 = require("../../helpers/routing-approval");
 const DIGEST = 'a'.repeat(64);
 const identity = { kind: 'native', version: '1.0.0', accountScopeDigest: DIGEST };
 const input = { provider: 'codex', routingIdentity: identity, controllerAutonomy: 'approval-free',
@@ -157,6 +158,29 @@ describe('issue #196: admission custody recovery', () => {
         expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
         expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).toBe('recovered');
     });
+    test.each([
+        'runtime local no verificable: NATIVE_QUERY_FAILED',
+        'runtime local cambió durante generacion admitida',
+    ])('runtime custody %s recovers only after strict offline revalidation', async (reason) => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'plans', 'cycle.md'), fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v2/valid.md'), 'utf8'));
+        const v2Plan = (0, validate_1.validatePlanFile)('plans/cycle.md', repo);
+        if (v2Plan.state !== 'valid' || !v2Plan.executionDigest)
+            throw new Error('invalid v2 recovery fixture');
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        state.planBinding = { ...state.planBinding, schema: v2Plan.schema, digest: v2Plan.planDigest,
+            executionDigest: v2Plan.executionDigest, executionIdentitySchema: 'awm-plan-execution/v1' };
+        state.cycle.blockedReason = reason;
+        (0, store_1.writeJournal)(repo, 'main', state);
+        const revision = (0, store_1.readJournal)(repo, 'main').state.revision;
+        await expect((0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, blocked('ADMISSION_SENSORS_BLOCKED', 'current', 'not-certified'))).rejects.toThrow();
+        expect((0, store_1.readJournal)(repo, 'main').state.revision).toBe(revision);
+        expect(await (0, admission_recovery_1.recoverAdmissionCustody)(repo, 'main', input, admitted)).toBe('recovered');
+        const recovered = (0, store_1.readJournal)(repo, 'main').state;
+        expect(recovered.cycle.status).toBe('IN_PROGRESS');
+        expect(recovered.planBinding?.schema).toBe('compact-slices/v2');
+        expect(recovered.admissionRecoveries?.at(-1)?.blockedReason).toBe(reason);
+        expect(recovered.generations).toEqual(state.generations);
+    });
     test('changed binding, active request problem, pending job and identity mismatch all fail closed', async () => {
         const check = async (mutate, pattern) => {
             const state = (0, store_1.readJournal)(repo, 'main').state;
@@ -181,6 +205,26 @@ describe('issue #196: admission custody recovery', () => {
         const sJob = (0, store_1.readJournal)(repo, 'main').state;
         sJob.jobs = {};
         (0, store_1.writeJournal)(repo, 'main', sJob);
+        await check(state => {
+            state.routingAttempts = [{ schema: 'routing-attempt/v1', id: 'route-1',
+                    obligationId: 'S1-implementer', lineageId: 'S1', attempt: 1, envelope: routing_approval_1.routingEnvelope,
+                    envelopeDigest: 'e'.repeat(64), fingerprint: 'f'.repeat(64), state: 'active',
+                    nativeAgentId: 'native-child' }];
+        }, /nativ|routing|attempt|intento/i);
+        const sRouting = (0, store_1.readJournal)(repo, 'main').state;
+        sRouting.routingAttempts = [];
+        (0, store_1.writeJournal)(repo, 'main', sRouting);
+        await check(state => {
+            state.routingAttempts = [{ schema: 'routing-attempt/v1', id: 'route-1',
+                    obligationId: 'S1-implementer', lineageId: 'S1', attempt: 1, envelope: routing_approval_1.routingEnvelope,
+                    envelopeDigest: 'e'.repeat(64), fingerprint: 'f'.repeat(64), state: 'reserved' }];
+            state.dispatches.push({ id: 'linked', taskId: 'S1', at: new Date().toISOString(),
+                routingAttemptId: 'route-1', dispatchRequestId: 'linked-ack' });
+        }, /nativ|routing|attempt|intento|dispatch/i);
+        const sPendingChild = (0, store_1.readJournal)(repo, 'main').state;
+        sPendingChild.routingAttempts = [];
+        sPendingChild.dispatches = [];
+        (0, store_1.writeJournal)(repo, 'main', sPendingChild);
         await check(state => { state.generations[0].processRef = (0, process_1.captureSelfRef)('recovery-test'); }, /controller/i);
         const sController = (0, store_1.readJournal)(repo, 'main').state;
         sController.generations[0].processRef = undefined;

package/dist/tests/commands/watch/reopened-196.test.js

@@ -55,6 +55,7 @@ const supervisor_1 = require("../../../src/commands/watch/supervisor");
 const supervisorModule = __importStar(require("../../../src/commands/watch/supervisor"));
 const generationModule = __importStar(require("../../../src/commands/watch/generations"));
 const adapterModule = __importStar(require("../../../src/core/journal/adapter"));
+const registry_contracts_1 = require("../../../src/core/admission/registry-contracts");
 const routing_approval_1 = require("../../helpers/routing-approval");
 const routing_approval_2 = require("../../helpers/routing-approval");
 const canonical_1 = require("../../../src/core/model-policy/canonical");
@@ -67,6 +68,7 @@ const localScope = __importStar(require("../../../src/core/model-policy/local-ev
 const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
 const paths_1 = require("../../../src/core/journal/paths");
 const paths_2 = require("../../../src/core/journal/paths");
+const process_1 = require("../../../src/core/journal/process");
 function v2State() {
     const state = (0, types_1.emptyState)('main');
     state.schema = 2;
@@ -90,6 +92,11 @@ function dispatch(state, payload) {
         generationToken: 'g1', idempotencyKey: 'dispatch-key', payload: { entity: 'dispatch',
             dispatchId: 'dispatch-S1', taskId: 'S1', ...payload } }, 'd'.repeat(64), process.cwd());
 }
+function legacyDispatchDigest(rawJson = '{"dispatchId":"dispatch-S1","taskId":"S1"}') {
+    // 9.12.2 job register emits { ...JSON.parse(--json), entity: --entity }.
+    // Preserve the caller's key order: digestOf uses JSON.stringify bytes.
+    return (0, requests_1.digestOf)({ ...JSON.parse(rawJson), entity: 'dispatch' });
+}
 function boundRepo(version = 'v1') {
     const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-196-bound-'));
     (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'main'], { cwd: repo });
@@ -181,6 +188,169 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
         expect(state.dispatches).toHaveLength(1);
         expect(state.tasks[0].attempts).toBe(1);
     });
+    test('9.12.2 unlinked S1 dispatch is preserved while a fresh routed dispatch gets its own real ACK', () => {
+        expect(legacyDispatchDigest()).toBe('01edb739d12771ff6ffea2ea4296bf477b745f76afb66b4b20cb90cd470f5666');
+        const state = v2State();
+        const oldAt = new Date(Date.parse(state.routingAttempts[0].reservedAt) - 60_000).toISOString();
+        state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1', at: oldAt });
+        state.tasks[0].attempts = 1;
+        state.tasks[0].status = 'in-progress';
+        state.jobs['completed-test'] = { id: 'completed-test', fingerprint: 'fixture', commandDigest: 'fixture',
+            argv: ['true'], cwd: '.', paths: [], expandedPaths: [], executionState: 'exited',
+            observationState: 'progressing', phaseTimestamps: { exited: new Date().toISOString() } };
+        state.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+            idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(), outcome: 'applied', resultRef: 'dispatch-S1' };
+        state.appliedRequests['old-dispatch-retry'] = { ...state.appliedRequests['old-dispatch-request'], requestId: 'old-dispatch-retry' };
+        const oldRecord = structuredClone(state.dispatches[0]);
+        const oldAck = structuredClone(state.appliedRequests['old-dispatch-request']);
+        const retryAck = structuredClone(state.appliedRequests['old-dispatch-retry']);
+        dispatch(state, { routingAttemptId: 'route-1' });
+        expect(state.dispatches[0]).toEqual(oldRecord);
+        expect(state.appliedRequests['old-dispatch-request']).toEqual(oldAck);
+        expect(state.appliedRequests['old-dispatch-retry']).toEqual(retryAck);
+        expect(state.dispatches).toHaveLength(2);
+        const linked = state.dispatches[1];
+        expect(linked).toMatchObject({ taskId: 'S1', routingAttemptId: 'route-1', dispatchRequestId: 'dispatch-request' });
+        expect(linked.id).not.toBe('dispatch-S1');
+        expect(state.appliedRequests['dispatch-request']).toMatchObject({ outcome: 'applied', resultRef: linked.id });
+        expect(state.tasks[0].attempts).toBe(1);
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        dispatch(state, { routingAttemptId: 'route-1' });
+        expect(state.dispatches).toHaveLength(2);
+        expect(state.tasks[0].attempts).toBe(1);
+        expect(() => (0, apply_1.applyRequestToState)(state, { kind: 'register-entity', requestId: 'unrelated-dispatch-request',
+            generationToken: 'g1', idempotencyKey: 'different-dispatch-key', payload: { entity: 'dispatch',
+                dispatchId: 'dispatch-S1', taskId: 'S1', routingAttemptId: 'route-1' } }, 'd'.repeat(64), process.cwd()))
+            .toThrow(/conflictivo/);
+        expect(state.dispatches).toHaveLength(2);
+    });
+    test('equal-millisecond legacy timestamps reconcile only when the durable dispatch ACK precedes the reservation ACK', () => {
+        const state = v2State();
+        const at = state.routingAttempts[0].reservedAt;
+        state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1', at });
+        state.tasks[0].attempts = 1;
+        state.tasks[0].status = 'in-progress';
+        const reservationAck = state.appliedRequests['reserve-1'];
+        const historicalAck = { requestId: 'old-dispatch-request', idempotencyKey: 'old-dispatch-key',
+            payloadDigest: legacyDispatchDigest(), outcome: 'applied', resultRef: 'dispatch-S1' };
+        state.appliedRequests = { 'old-dispatch-request': historicalAck, 'reserve-1': reservationAck };
+        const durable = JSON.parse(JSON.stringify(state));
+        expect(Object.keys(durable.appliedRequests)).toEqual(['old-dispatch-request', 'reserve-1']);
+        dispatch(durable, { routingAttemptId: 'route-1' });
+        expect(durable.dispatches).toHaveLength(2);
+        expect(durable.dispatches[0]).toEqual({ id: 'dispatch-S1', taskId: 'S1', at });
+        expect(durable.appliedRequests['old-dispatch-request']).toEqual(historicalAck);
+        expect(durable.tasks[0].attempts).toBe(1);
+        expect((0, types_1.isWellFormedState)(durable)).toBe(true);
+    });
+    test('equal-millisecond legacy timestamps do not infer order from a later dispatch ACK', () => {
+        const state = v2State();
+        state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1', at: state.routingAttempts[0].reservedAt });
+        state.tasks[0].attempts = 1;
+        state.tasks[0].status = 'in-progress';
+        state.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+            idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(),
+            outcome: 'applied', resultRef: 'dispatch-S1' };
+        expect(() => dispatch(state, { routingAttemptId: 'route-1' })).toThrow(/legacy handoff/);
+        expect(state.dispatches).toHaveLength(1);
+        expect(state.appliedRequests['dispatch-request']).toBeUndefined();
+    });
+    test('historical ACK matching is independent of JSON key order but not payload identity', () => {
+        for (const rawJson of [
+            '{"taskId":"S1","dispatchId":"dispatch-S1"}',
+            '{"entity":"dispatch","taskId":"S1","dispatchId":"dispatch-S1"}',
+        ]) {
+            const state = v2State();
+            state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1',
+                at: new Date(Date.parse(state.routingAttempts[0].reservedAt) - 60_000).toISOString() });
+            state.tasks[0].status = 'in-progress';
+            state.tasks[0].attempts = 1;
+            state.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+                idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(rawJson),
+                outcome: 'applied', resultRef: 'dispatch-S1' };
+            dispatch(state, { routingAttemptId: 'route-1' });
+            expect(state.dispatches).toHaveLength(2);
+            expect(state.appliedRequests['dispatch-request']).toMatchObject({ outcome: 'applied', resultRef: state.dispatches[1].id });
+        }
+    });
+    test('historical unlinked S1 cannot be bypassed with a different requested dispatch ID', () => {
+        const state = v2State();
+        state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1',
+            at: new Date(Date.parse(state.routingAttempts[0].reservedAt) - 60_000).toISOString() });
+        state.tasks[0].status = 'in-progress';
+        state.tasks[0].attempts = 1;
+        state.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+            idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(), outcome: 'applied', resultRef: 'dispatch-S1' };
+        expect(() => dispatch(state, { dispatchId: 'new-S1', routingAttemptId: 'route-1' })).toThrow(/legacy|historical|conflict/i);
+        expect(state.dispatches).toHaveLength(1);
+        expect(state.tasks[0].attempts).toBe(1);
+        expect(state.appliedRequests['dispatch-request']).toBeUndefined();
+    });
+    test('historical handoff requires a matching applied legacy dispatch ACK', () => {
+        for (const ack of ['missing', 'unrelated', 'rejected']) {
+            const state = v2State();
+            state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1',
+                at: new Date(Date.parse(state.routingAttempts[0].reservedAt) - 60_000).toISOString() });
+            state.tasks[0].status = 'in-progress';
+            state.tasks[0].attempts = 1;
+            if (ack !== 'missing')
+                state.appliedRequests['old-dispatch-request'] = {
+                    requestId: 'old-dispatch-request', idempotencyKey: 'old-dispatch-key',
+                    payloadDigest: ack === 'unrelated' ? (0, requests_1.digestOf)({ entity: 'task', taskId: 'S1' }) : legacyDispatchDigest(),
+                    outcome: ack === 'rejected' ? 'rejected-stale-generation' : 'applied', resultRef: 'dispatch-S1',
+                };
+            expect(() => dispatch(state, { routingAttemptId: 'route-1' })).toThrow(/legacy|historical|ACK|evidencia/i);
+            expect(state.dispatches).toHaveLength(1);
+            expect(state.appliedRequests['dispatch-request']).toBeUndefined();
+        }
+    });
+    test('a failed linked handoff does not authorize another child without native ownership proof', () => {
+        const state = v2State();
+        state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1',
+            at: new Date(Date.parse(state.routingAttempts[0].reservedAt) - 60_000).toISOString() });
+        state.tasks[0].status = 'in-progress';
+        state.tasks[0].attempts = 1;
+        state.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+            idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(), outcome: 'applied', resultRef: 'dispatch-S1' };
+        dispatch(state, { routingAttemptId: 'route-1' });
+        state.routingAttempts[0].state = 'blocked';
+        state.routingAttempts[0].verdict = 'fail';
+        state.routingAttempts.push({ ...state.routingAttempts[0], id: 'route-2', state: 'reserved',
+            verdict: undefined, reservationRequestId: 'reserve-2' });
+        state.appliedRequests['reserve-2'] = { requestId: 'reserve-2', idempotencyKey: 'reserve-2',
+            payloadDigest: 'd'.repeat(64), outcome: 'applied', resultRef: 'route-2' };
+        expect(() => (0, apply_1.applyRequestToState)(state, { kind: 'register-entity', requestId: 'dispatch-request-2',
+            generationToken: 'g1', idempotencyKey: 'dispatch-key-2', payload: { entity: 'dispatch',
+                dispatchId: 'dispatch-S1-retry', taskId: 'S1', routingAttemptId: 'route-2' } }, 'd'.repeat(64), process.cwd()))
+            .toThrow(/historical|conflict/i);
+        expect(state.dispatches).toHaveLength(2);
+        expect(state.tasks[0].attempts).toBe(1);
+        expect(state.appliedRequests['dispatch-request-2']).toBeUndefined();
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+    });
+    test('legacy dispatch reconciliation refuses ambiguous or already-observed work', () => {
+        for (const scenario of ['two-old-dispatches', 'observed', 'wrong-order', 'existing-job']) {
+            const state = v2State();
+            state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1',
+                at: new Date(Date.parse(state.routingAttempts[0].reservedAt) - 60_000).toISOString() });
+            state.tasks[0].attempts = 1;
+            state.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+                idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(), outcome: 'applied', resultRef: 'dispatch-S1' };
+            if (scenario === 'two-old-dispatches')
+                state.dispatches.push({ id: 'other-old', taskId: 'S1', at: state.dispatches[0].at });
+            if (scenario === 'observed')
+                state.routingAttempts[0].nativeAgentId = 'native-child';
+            if (scenario === 'wrong-order')
+                state.dispatches[0].at = new Date(Date.parse(state.routingAttempts[0].reservedAt) + 60_000).toISOString();
+            if (scenario === 'existing-job')
+                state.jobs['unreconciled'] = { id: 'unreconciled',
+                    fingerprint: 'fixture', commandDigest: 'fixture', argv: ['true'], cwd: '.', paths: [], expandedPaths: [],
+                    executionState: 'received', observationState: 'progressing', phaseTimestamps: {} };
+            expect(() => dispatch(state, { routingAttemptId: 'route-1' })).toThrow();
+            expect(state.dispatches.some(item => item.routingAttemptId === 'route-1')).toBe(false);
+            expect(state.appliedRequests['dispatch-request']).toBeUndefined();
+        }
+    });
     test('an exact dispatch replay after native observation does not duplicate S1', () => {
         const state = v2State();
         dispatch(state, { routingAttemptId: 'route-1' });
@@ -336,6 +506,118 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             fs_1.default.rmSync(repo, { recursive: true, force: true });
         }
     });
+    test('controller admission reuses only an owned generation sensor pass, never a new generation', async () => {
+        const repo = boundRepo();
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => { });
+            const state = (0, store_1.readJournal)(repo, 'main').state;
+            const generation = state.generations[0];
+            const claim = (0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'main'), generation.controllerJobId, generation.spawnNonce);
+            fs_1.default.writeFileSync(claim, '{}');
+            generation.wrapperRef = (0, process_1.captureSelfRef)(generation.spawnNonce);
+            state.admissionContext = { provider: 'codex', controllerAutonomy: 'approval-free' };
+            (0, store_1.writeJournal)(repo, 'main', state);
+            const sensorRun = jest.fn(async () => ({ sensors: [], overall: 'not_certified',
+                projectRoot: repo, manifestPath: path_1.default.join(repo, '.awm', 'sensors.json'), mode: 'project-sensors' }));
+            const admit = async (freshSensorsRequired = false) => (0, registry_contracts_1.admitRegistryPlan)({
+                plan: (0, validate_1.validatePlanFile)('plans/cycle.md', repo), provider: 'codex', cwd: repo,
+                executionMode: 'desatendido', planPath: 'plans/cycle.md', journalState: (0, store_1.readJournal)(repo, 'main').state,
+                verifySensors: true, controllerAutonomy: 'approval-free',
+                ...(freshSensorsRequired ? { freshSensorsRequired: true } : {}),
+            }, { runSensors: sensorRun });
+            const active = await admit();
+            expect(active.state).toBe('admitted');
+            expect(active).toHaveProperty('sensorEvidence', 'generation-bound');
+            expect(sensorRun).not.toHaveBeenCalled();
+            const replacement = await admit(true);
+            expect(replacement).toMatchObject({ state: 'blocked', sensors: 'not-certified' });
+            expect(sensorRun).toHaveBeenCalledTimes(1);
+            const claimOnly = (0, store_1.readJournal)(repo, 'main').state;
+            claimOnly.generations[0].wrapperRef = undefined;
+            (0, store_1.writeJournal)(repo, 'main', claimOnly);
+            expect(await admit()).toMatchObject({ state: 'blocked', sensors: 'not-certified' });
+            expect(sensorRun).toHaveBeenCalledTimes(2);
+            const mismatched = (0, store_1.readJournal)(repo, 'main').state;
+            mismatched.generations[0].processRef = (0, process_1.captureSelfRef)('different-nonce');
+            (0, store_1.writeJournal)(repo, 'main', mismatched);
+            expect(await admit()).toMatchObject({ state: 'blocked', sensors: 'not-certified' });
+            expect(sensorRun).toHaveBeenCalledTimes(3);
+            fs_1.default.unlinkSync(claim);
+            const unowned = await admit();
+            expect(unowned).toMatchObject({ state: 'blocked', sensors: 'not-certified' });
+            expect(sensorRun).toHaveBeenCalledTimes(4);
+            const stale = (0, store_1.readJournal)(repo, 'main').state;
+            stale.generations[0].processRef = { pid: 99999997, processGroup: 99999997,
+                startTime: 'Thu Sep 24 20:00:00 2026', spawnNonce: generation.spawnNonce,
+                argvDigest: generation.launchArgvDigest, psArgsDigest: 'b'.repeat(64) };
+            (0, store_1.writeJournal)(repo, 'main', stale);
+            expect(await admit()).toMatchObject({ state: 'blocked', sensors: 'not-certified' });
+            expect(sensorRun).toHaveBeenCalledTimes(5);
+            (0, generations_1.beginGeneration)(repo, 'main');
+            const next = await admit();
+            expect(next).toMatchObject({ state: 'blocked', sensors: 'not-certified' });
+            expect(sensorRun).toHaveBeenCalledTimes(6);
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('generation-bound sensor reuse rejects a changed live v2 runtime', async () => {
+        const repo = boundRepo('v2');
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => { });
+            const state = (0, store_1.readJournal)(repo, 'main').state;
+            const generation = state.generations[0];
+            fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'main'), generation.controllerJobId, generation.spawnNonce), '{}');
+            generation.wrapperRef = (0, process_1.captureSelfRef)(generation.spawnNonce);
+            state.admissionContext = { provider: 'codex', controllerAutonomy: 'approval-free',
+                runtime: { kind: 'native', version: '0.156.0', accountScopeDigest: 'a'.repeat(64) } };
+            (0, store_1.writeJournal)(repo, 'main', state);
+            const sensorRun = jest.fn(async () => ({ sensors: [], overall: 'not_certified' }));
+            const report = await (0, registry_contracts_1.admitRegistryPlan)({ plan: (0, validate_1.validatePlanFile)('plans/cycle.md', repo),
+                provider: 'codex', cwd: repo, executionMode: 'desatendido', planPath: 'plans/cycle.md',
+                journalState: (0, store_1.readJournal)(repo, 'main').state, verifySensors: true, controllerAutonomy: 'approval-free',
+            }, { runSensors: sensorRun, readRouting: async () => ({ runtime: { target: 'codex', kind: 'native',
+                        version: '0.157.0', accountScopeDigest: 'a'.repeat(64) } }) });
+            expect(report.state).toBe('blocked');
+            expect(report.diagnostics).toEqual(expect.arrayContaining([expect.objectContaining({ code: 'ADMISSION_GENERATION_RUNTIME_MISMATCH' })]));
+            expect(sensorRun).not.toHaveBeenCalled();
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    test('active v2 controller admission reuses owned sensors while still checking routing evidence', async () => {
+        const repo = boundRepo('v2');
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => { });
+            const state = (0, store_1.readJournal)(repo, 'main').state;
+            const generation = state.generations[0];
+            fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'main'), generation.controllerJobId, generation.spawnNonce), '{}');
+            generation.wrapperRef = (0, process_1.captureSelfRef)(generation.spawnNonce);
+            state.admissionContext = { provider: 'codex', controllerAutonomy: 'approval-free',
+                runtime: { kind: routing_approval_1.routingEnvelope.runtime.kind, version: routing_approval_1.routingEnvelope.runtime.version,
+                    accountScopeDigest: routing_approval_1.routingEnvelope.runtime.accountScopeDigest } };
+            (0, store_1.writeJournal)(repo, 'main', state);
+            const evidence = (0, routing_approval_2.routingApproval)();
+            const sensorRun = jest.fn(async () => ({ sensors: [], overall: 'not_certified' }));
+            const readRouting = jest.fn(async () => ({ runtime: routing_approval_1.routingEnvelope.runtime,
+                policy: evidence.policy, capabilities: evidence.capabilities, now: evidence.checkedAt }));
+            const report = await (0, registry_contracts_1.admitRegistryPlan)({ plan: (0, validate_1.validatePlanFile)('plans/cycle.md', repo),
+                provider: 'codex', cwd: repo, executionMode: 'desatendido', planPath: 'plans/cycle.md',
+                journalState: (0, store_1.readJournal)(repo, 'main').state, verifySensors: true, controllerAutonomy: 'approval-free',
+            }, { runSensors: sensorRun, readRouting });
+            expect(report).toMatchObject({ state: 'admitted', sensors: 'pass', sensorEvidence: 'generation-bound' });
+            expect(sensorRun).not.toHaveBeenCalled();
+            expect(readRouting).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
     test('the same RED continuation applies to compact v2 with unchanged native scope', async () => {
         const repo = boundRepo('v2');
         try {
@@ -381,6 +663,33 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             fs_1.default.rmSync(repo, { recursive: true, force: true });
         }
     });
+    test.each(['unverified', 'throws'])('an active v2 generation records an inconclusive local runtime query (%s) without claiming drift', async (scenario) => {
+        const repo = boundRepo('v2');
+        try {
+            (0, generations_1.beginGeneration)(repo, 'main');
+            (0, generations_1.launchControllerGeneration)(repo, 'main', 'codex', { schema: 'controller-recovery/v1', kind: 'resume-cycle' }, () => { });
+            const gen = (0, store_1.readJournal)(repo, 'main').state.generations[0];
+            fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'main'), gen.controllerJobId, gen.spawnNonce), '{}');
+            const query = jest.spyOn(localScope, 'queryLocalEventScope');
+            if (scenario === 'throws')
+                query.mockRejectedValue(new Error('permission denied while reading a private path'));
+            else
+                query.mockResolvedValue({ state: 'unverified', reason: 'NATIVE_QUERY_FAILED' });
+            const expected = routing_approval_1.routingEnvelope.runtime;
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, routingIdentity: {
+                    kind: expected.kind, version: expected.version, accountScopeDigest: expected.accountScopeDigest,
+                }, controllerAutonomy: 'approval-free' };
+            let spawns = 0;
+            expect(await new supervisor_1.Supervisor(repo, 'main', cfg, () => { spawns++; }, undefined, async () => admitted, true).tick()).toBe('custody');
+            const final = (0, store_1.readJournal)(repo, 'main').state;
+            expect(final.cycle.blockedReason).toBe('runtime local no verificable: NATIVE_QUERY_FAILED');
+            expect(spawns).toBe(0);
+        }
+        finally {
+            jest.restoreAllMocks();
+            fs_1.default.rmSync(repo, { recursive: true, force: true });
+        }
+    });
     test('an active v2 generation refuses dispatch when local runtime identity drifts', async () => {
         const repo = boundRepo('v2');
         try {
@@ -433,15 +742,14 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             (0, request_1.requestJob)(repo, 'main', state.generations[0].token, [process.execPath, '-e', 'process.exit(0)'], [], '.');
             const adapter = adapterModule.adapterFor('codex');
             jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter, activity: () => null, safeToReplace: () => 'safe' });
-            jest.spyOn(generationModule, 'resolveGeneration').mockImplementation(async () => {
-                const current = (0, store_1.readJournal)(repo, 'main').state;
-                current.generations[0].state = 'terminated';
-                (0, store_1.writeJournal)(repo, 'main', current);
-                return 'proven-dead';
-            });
+            jest.spyOn(generationModule, 'resolveGeneration').mockResolvedValue('proven-dead');
             let admissions = 0;
             let jobSpawns = 0;
-            const sup = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, heartbeatTimeoutMs: 0, activityWindowMs: 0 }, () => { jobSpawns += 1; }, undefined, async () => { admissions += 1; return redSensor; }, true);
+            const sup = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, heartbeatTimeoutMs: 0, activityWindowMs: 0 }, () => { jobSpawns += 1; }, undefined, async (request) => {
+                admissions += 1;
+                expect(request).toMatchObject({ freshSensorsRequired: true });
+                return { ...admitted, sensorEvidence: 'generation-bound' };
+            }, true);
             expect(await sup.tick()).toBe('custody');
             expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(1);
             expect(admissions).toBe(1);
@@ -625,7 +933,7 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             fs_1.default.rmSync(repo, { recursive: true, force: true });
         }
     }, 10000);
-    test('recovered v2 S1 uses real CLI reservation, dispatch ack, observation and one continuation', async () => {
+    test('recovered historical v2 S1 uses real CLI reservation, new dispatch ack, observation and one continuation', async () => {
         const repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-196-integral-'));
         const previousHome = process.env.AWM_HOME;
         const operator = path_1.default.join(repo, 'operator');
@@ -695,6 +1003,16 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
             expect((0, store_1.readJournal)(repo, 'main').state.requestProblems).toEqual([]);
             expect(cli('ack', task.requestId).state).toBe('applied');
+            // Durable 9.12.2 intent and ACK precede the route reservation.
+            // Equal timestamp granularity alone must not imply a child.
+            const historical = (0, store_1.readJournal)(repo, 'main').state;
+            let historicalAt = new Date(Date.now() - 60_000).toISOString();
+            historical.dispatches.push({ id: 'dispatch-S1', taskId: 'S1', at: historicalAt });
+            historical.tasks[0].attempts = 1;
+            historical.tasks[0].status = 'in-progress';
+            historical.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+                idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(), outcome: 'applied', resultRef: 'dispatch-S1' };
+            (0, store_1.writeJournal)(repo, 'main', historical);
             const reserve = cli('routing-reserve', '--generation', generation.token, '--obligation', 'S1-implementer', '--lineage', 'lineage-S1', '--envelope-file', envelopeFile, '--fingerprint', 'f'.repeat(64));
             expect(cli('ack', reserve.requestId).state).toBe('pending');
             (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
@@ -702,12 +1020,22 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             const reservation = cli('ack', reserve.requestId);
             expect(reservation.state).toBe('applied');
             const attemptId = reservation.resultRef;
+            // Reproduce the real journal's millisecond tie without changing
+            // the durable ACK order or adding any native evidence.
+            const tied = (0, store_1.readJournal)(repo, 'main').state;
+            historicalAt = tied.routingAttempts.find(attempt => attempt.id === attemptId).reservedAt;
+            tied.dispatches[0].at = historicalAt;
+            expect(Object.keys(tied.appliedRequests).indexOf('old-dispatch-request'))
+                .toBeLessThan(Object.keys(tied.appliedRequests).indexOf(reserve.requestId));
+            (0, store_1.writeJournal)(repo, 'main', tied);
             const dispatchPayload = JSON.stringify({ dispatchId: 'dispatch-S1', taskId: 'S1', routingAttemptId: attemptId });
             const queuedDispatch = cli('register', '--generation', generation.token, '--entity', 'dispatch', '--json', dispatchPayload);
             expect(cli('ack', queuedDispatch.requestId).state).toBe('pending');
             expect(fs_1.default.existsSync(path_1.default.join(repo, 's1-red.test.ts'))).toBe(false);
             (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
-            expect(cli('ack', queuedDispatch.requestId)).toMatchObject({ state: 'applied', resultRef: 'dispatch-S1' });
+            const routedAck = cli('ack', queuedDispatch.requestId);
+            expect(routedAck.state).toBe('applied');
+            expect(routedAck.resultRef).not.toBe('dispatch-S1');
             const worker = (0, child_process_1.spawnSync)(process.execPath, ['-e', `require('fs').writeFileSync(${JSON.stringify(path_1.default.join(repo, 's1-red.test.ts'))}, 'test("RED", () => { throw new Error("RED"); });\\n')`], {
                 cwd: repo, encoding: 'utf8', env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' },
             });
@@ -722,7 +1050,7 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             expect(cli('ack', observation.requestId).state).toBe('applied');
             const replay = cli('register', '--generation', generation.token, '--entity', 'dispatch', '--json', dispatchPayload);
             (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
-            expect(cli('ack', replay.requestId).state).toBe('applied');
+            expect(cli('ack', replay.requestId)).toMatchObject({ state: 'applied', resultRef: routedAck.resultRef });
             expect(cli('reconcile').nextAction).toBeTruthy();
             const unsupported = (0, child_process_1.spawnSync)(process.execPath, [compiled, 'job', 'reconcile', '--generation', generation.token], {
                 cwd: repo, encoding: 'utf8', env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' },
@@ -731,7 +1059,11 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             expect(unsupported.stderr).toMatch(/generation|unknown option/i);
             const final = (0, store_1.readJournal)(repo, 'main').state;
             expect(final.tasks).toHaveLength(1);
-            expect(final.dispatches).toHaveLength(1);
+            expect(final.dispatches).toHaveLength(2);
+            expect(final.dispatches[0]).toEqual({ id: 'dispatch-S1', taskId: 'S1', at: historicalAt });
+            expect(final.appliedRequests['old-dispatch-request']).toEqual(historical.appliedRequests['old-dispatch-request']);
+            expect(final.dispatches[1]).toMatchObject({ id: routedAck.resultRef,
+                taskId: 'S1', routingAttemptId: attemptId, dispatchRequestId: queuedDispatch.requestId });
             expect(final.routingAttempts).toHaveLength(1);
             expect(final.routingAttempts[0].state).toBe('active');
             expect(final.tasks[0].attempts).toBe(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.12.3",
+  "version": "9.12.5",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"