agentic-workflow-manager 9.12.2 → 9.12.4

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

@@ -251,6 +251,67 @@ function registerJobCommand(program) {
         assertAuthenticatedCwd(repo, branch);
         process.stdout.write(JSON.stringify((0, query_1.queryPs)(repo, branch), null, 2) + '\n');
     });
+    job.command('ack')
+        .description('consulta read-only el acuse durable de una request por ID exacto')
+        .argument('<requestId>')
+        .action((requestId) => {
+        if (!/^req-[A-Za-z0-9-]{1,124}$/.test(requestId))
+            throw new Error('requestId invalido');
+        const repo = process.cwd();
+        const branch = branchOf(repo);
+        assertAuthenticatedCwd(repo, branch);
+        const read = (0, store_1.readJournal)(repo, branch);
+        if (read.corrupt || !read.state) {
+            process.stdout.write(JSON.stringify({ requestId, state: 'unverifiable', journal: read.corrupt ? 'corrupt' : 'absent' }) + '\n');
+            process.exitCode = 1;
+            return;
+        }
+        (0, lock_1.verifyBranchInvariant)(repo, read.state.branch);
+        const ack = (0, requests_1.ackFor)(read.state, requestId);
+        if (ack) {
+            process.stdout.write(JSON.stringify({ requestId, state: ack.outcome === 'applied' ? 'applied' : 'rejected',
+                outcome: ack.outcome, ...(ack.resultRef ? { resultRef: ack.resultRef } : {}) }) + '\n');
+            if (ack.outcome !== 'applied')
+                process.exitCode = 1;
+            return;
+        }
+        const problem = read.state.requestProblems.find(item => item.requestId === requestId
+            || (item.kind === 'corrupt' && path_1.default.basename(item.file) === `${requestId}.json`));
+        if (problem) {
+            process.stdout.write(JSON.stringify({ requestId, state: problem.kind === 'corrupt' ? 'unverifiable' : 'rejected', reasonCode: problem.kind }) + '\n');
+            process.exitCode = 1;
+            return;
+        }
+        let pending;
+        try {
+            pending = (0, requests_1.listPendingRequests)(repo, branch).find(item => item.requestId === requestId
+                || (item.corrupt && path_1.default.basename(item.file) === `${requestId}.json`));
+        }
+        catch {
+            process.stdout.write(JSON.stringify({ requestId, state: 'unverifiable', reasonCode: 'request-directory' }) + '\n');
+            process.exitCode = 1;
+            return;
+        }
+        // The supervisor may have consumed the request between the first
+        // journal snapshot and the queue read. Recheck before saying unknown.
+        const latest = (0, store_1.readJournal)(repo, branch);
+        if (latest.corrupt || !latest.state) {
+            process.stdout.write(JSON.stringify({ requestId, state: 'unverifiable', journal: latest.corrupt ? 'corrupt' : 'absent' }) + '\n');
+            process.exitCode = 1;
+            return;
+        }
+        const latestAck = (0, requests_1.ackFor)(latest.state, requestId);
+        if (latestAck) {
+            process.stdout.write(JSON.stringify({ requestId, state: latestAck.outcome === 'applied' ? 'applied' : 'rejected',
+                outcome: latestAck.outcome, ...(latestAck.resultRef ? { resultRef: latestAck.resultRef } : {}) }) + '\n');
+            if (latestAck.outcome !== 'applied')
+                process.exitCode = 1;
+            return;
+        }
+        process.stdout.write(JSON.stringify({ requestId, state: pending?.corrupt ? 'unverifiable' : pending ? 'pending' : 'unknown' }) + '\n');
+        if (!pending || pending.corrupt)
+            process.exitCode = 1;
+    });
     job.command('list').action(() => {
         const repo = process.cwd();
         const branch = branchOf(repo);

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))
@@ -155,6 +156,14 @@ function applyRequestToState(s, env, digest, repoRoot, eventScope) {
                 const capabilities = (0, capabilities_1.readCapabilities)((0, capabilities_1.validateRuntimeKey)(envelope.runtime), checkedAt);
                 return { checkedAt, policy: policy.state === 'approved' ? policy.policy : undefined, capabilities: capabilities.state === 'current' ? capabilities.receipt : undefined };
             } }, p.at ?? now());
+        const routingAttempt = reserved.state.routingAttempts?.find(item => item.id === reserved.attemptId);
+        if (!routingAttempt)
+            throw new Error('routing reservation produced no attempt');
+        const priorReservationAck = routingAttempt.reservationRequestId === undefined ? undefined
+            : reserved.state.appliedRequests[routingAttempt.reservationRequestId];
+        if (!priorReservationAck || priorReservationAck.outcome !== 'applied' || priorReservationAck.resultRef !== routingAttempt.id) {
+            routingAttempt.reservationRequestId = env.requestId;
+        }
         Object.assign(s, reserved.state);
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: reserved.attemptId });
         return;
@@ -166,6 +175,15 @@ function applyRequestToState(s, env, digest, repoRoot, eventScope) {
         const attempt = s.routingAttempts?.find(item => item.id === p.attemptId);
         if (!attempt)
             throw new Error('routing-observe attempt is unknown');
+        if (s.planBinding?.schema === 'compact-slices/v2' && attempt.envelope.role === 'implementer') {
+            if (attempt.nativeEvidenceRequired !== true)
+                throw new Error('routing-observe v2 requires a native event receipt');
+            const dispatch = s.dispatches.find(item => item.routingAttemptId === attempt.id);
+            const ack = dispatch?.dispatchRequestId ? s.appliedRequests[dispatch.dispatchRequestId] : undefined;
+            if (!dispatch || ack?.outcome !== 'applied' || ack.requestId !== dispatch.dispatchRequestId
+                || ack.resultRef !== dispatch.id)
+                throw new Error('routing-observe requires applied dispatch ack');
+        }
         let key = null;
         if (attempt.nativeEvidenceRequired) {
             try {
@@ -454,8 +472,106 @@ function applyRequestToState(s, env, digest, repoRoot, eventScope) {
             const taskId = p.taskId;
             if (!s.tasks.some((task) => task.id === taskId))
                 throw new Error('register --entity dispatch: taskId desconocido');
-            if (!s.dispatches.some((d) => d.id === dispatchId)) {
-                s.dispatches.push({ id: dispatchId, taskId, at: now() });
+            const v2 = s.planBinding?.schema === 'compact-slices/v2';
+            let routingAttemptId;
+            let reservedForNewDispatch = true;
+            if (v2) {
+                if (typeof p.routingAttemptId !== 'string' || p.routingAttemptId.length === 0)
+                    throw new Error('register --entity dispatch v2 requiere routingAttemptId');
+                const attempt = s.routingAttempts?.find(candidate => candidate.id === p.routingAttemptId);
+                if (!attempt || attempt.envelope.role !== 'implementer'
+                    || attempt.envelope.sliceId !== taskId || attempt.envelope.planDigest !== s.planBinding.digest
+                    || attempt.envelope.executionDigest !== s.planBinding.executionDigest
+                    || !attempt.reservationRequestId
+                    || s.appliedRequests[attempt.reservationRequestId]?.outcome !== 'applied'
+                    || s.appliedRequests[attempt.reservationRequestId]?.requestId !== attempt.reservationRequestId
+                    || s.appliedRequests[attempt.reservationRequestId]?.resultRef !== attempt.id) {
+                    throw new Error('register --entity dispatch: routing reservation for this slice and plan lacks applied ack');
+                }
+                routingAttemptId = attempt.id;
+                if (attempt.nativeEvidenceRequired !== true)
+                    throw new Error('register --entity dispatch v2 requires native event receipt');
+                reservedForNewDispatch = attempt.state === 'reserved';
+            }
+            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 oldAckApplied = Object.values(s.appliedRequests).some(ack => ack.outcome === 'applied'
+                    && ack.resultRef === existing.id && legacyDigests.includes(ack.payloadDigest));
+                const safeLegacy = reservedForNewDispatch && Number.isFinite(oldAt) && Number.isFinite(reservedAt)
+                    && oldAt < reservedAt
+                    && oldAckApplied
+                    && 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');
+            }
+            if (!existing) {
+                if (routingAttemptId && s.dispatches.some(d => d.routingAttemptId === routingAttemptId)) {
+                    throw new Error('register --entity dispatch: routing reservation ya tiene un dispatch');
+                }
+                if (!reservedForNewDispatch)
+                    throw new Error('register --entity dispatch: routing attempt ya no esta reservado');
+                s.dispatches.push({ id: dispatchId, taskId, at: now(), ...(routingAttemptId ? { routingAttemptId, dispatchRequestId: env.requestId } : {}) });
                 const task = s.tasks.find((t) => t.id === taskId);
                 if (task !== undefined)
                     task.attempts += 1;

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

@@ -95,7 +95,7 @@ function promptForGeneration(gen) {
         'resume-next-action': 'Retoma el next_action vigente del journal.',
         'reconcile-active-jobs': 'Reconcilia los jobs activos existentes del journal sin duplicarlos.',
     };
-    return `${instructions[gen.resumeAction.kind]}\nGeneracion activa: ${gen.token}. Incluye --generation ${gen.token} en cada comando awm job.`;
+    return `${instructions[gen.resumeAction.kind]}\nGeneracion activa: ${gen.token}. Incluye --generation ${gen.token} solo en awm job request, register, verdict, controller-heartbeat, routing-reserve y routing-observe. Ejecuta awm job reconcile sin --generation; awm job ack <requestId> tambien es de solo lectura y no acepta ese flag. En compact v2: espera el ack applied de routing-reserve, toma su resultRef como routingAttemptId, registra dispatch con ese routingAttemptId y espera su ack applied antes de lanzar al implementador nativo. Ningun implementador escribe antes de ese ack. Luego emite routing-observe y espera su ack; un recibo de emision no es un ack aplicado.`;
 }
 function recoveryAction(action) {
     if (!(0, types_1.isControllerRecoveryAction)(action))

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

@@ -143,8 +143,18 @@ function registerWatchCommand(program) {
             ...(opts.controllerAutonomy === undefined ? {} : { controllerAutonomy: opts.controllerAutonomy }),
         };
         process.stdout.write(`awm watch: supervisor activo (${cfg.provider}) — Ctrl-C para terminar\n`);
-        await (0, supervisor_1.runSupervisorLoop)(repo, branch, cfg);
-        process.stdout.write('gate verde: ciclo COMPLETE — drenado, lock liberado, apagando\n');
+        const outcome = await (0, supervisor_1.runSupervisorLoop)(repo, branch, cfg);
+        const final = (0, archive_unused_1.watchJournalStatus)(repo, branch);
+        if (outcome === 'complete' && final.state === 'present' && final.cycleState === 'COMPLETE') {
+            process.stdout.write('gate verde: ciclo COMPLETE — drenado, lock liberado, apagando\n');
+        }
+        else {
+            process.stdout.write(`awm watch: ${outcome === 'stopped' ? 'detenido' : 'track congelado'}; ciclo ${final.cycleState ?? final.state} — sin certificacion de cierre\n`);
+            if (outcome === 'stopped')
+                process.exitCode = 130;
+            else if (outcome === 'complete' || final.state !== 'present')
+                process.exitCode = 1;
+        }
     });
     watch.command('recover-request')
         .description('reconcilia una task rechazada con una request correctiva aplicada bajo lock exclusivo')

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 });
@@ -341,12 +342,67 @@ class Supervisor {
             if (before0.corrupt || !before0.state)
                 throw new Error('journal no verificable tras vincular identidad de admisión');
         }
-        if (before0.state.admissionRetry && Date.now() < Date.parse(before0.state.admissionRetry.nextRetryAt))
+        // Full sensor admission belongs to the launch boundary. Once that
+        // generation has a durable controller launch intent, RED edits are
+        // normal work, not a new pre-dispatch baseline. Preserve binding
+        // checks while it runs; the next generation gets a fresh admission.
+        const binding = before0.state.planBinding;
+        if (!binding)
+            throw new Error('binding compacto ausente tras lectura del journal');
+        const launched = (0, generations_1.activeGeneration)(before0.state);
+        const ownedLaunch = launched !== undefined && (launched.processRef !== undefined || launched.wrapperRef !== undefined
+            || (0, generations_1.controllerGenerationHasUnresolvedClaim)(this.repoRoot, this.branch, launched));
+        const generationAdmitted = launched?.controllerJobId !== undefined && launched.launchArgvDigest !== undefined && ownedLaunch;
+        if (generationAdmitted) {
+            const plan = (0, validate_1.validatePlanFile)(binding.path, this.repoRoot);
+            if (plan.state !== 'valid' || plan.planDigest !== binding.digest || plan.schema !== binding.schema
+                || (binding.executionDigest !== undefined && plan.executionDigest !== binding.executionDigest)) {
+                (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'binding del plan alterado durante generacion admitida');
+                return 'custody';
+            }
+            if (binding.schema === 'compact-slices/v2') {
+                const asserted = assertedContext.runtime;
+                if (!asserted) {
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'runtime de routing ausente durante generacion v2');
+                    return 'custody';
+                }
+                const expected = (0, capabilities_1.validateRuntimeKey)({ target: assertedContext.provider, ...asserted });
+                let local;
+                try {
+                    local = await (0, local_event_scope_1.queryLocalEventScope)(this.repoRoot, expected.target, expected.kind);
+                }
+                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 (JSON.stringify(local.scope.runtime) !== JSON.stringify(expected)) {
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'runtime local cambió durante generacion admitida');
+                    return 'custody';
+                }
+                const stored = (0, event_store_1.readStoredEventReceipt)(expected);
+                if (stored.state === 'invalid' || (stored.state === 'present' &&
+                    (stored.receipt.binaryDigest !== local.scope.binaryDigest || stored.receipt.configDigest !== local.scope.configDigest))) {
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'recibo nativo cambió durante generacion admitida');
+                    return 'custody';
+                }
+                if (stored.state === 'absent' && (0, capabilities_1.readCapabilities)(expected, new Date()).state !== 'current') {
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'capacidades de routing no verificables durante generacion admitida');
+                    return 'custody';
+                }
+            }
+        }
+        if (!generationAdmitted && before0.state.admissionRetry && Date.now() < Date.parse(before0.state.admissionRetry.nextRetryAt))
             return 'continue';
         // A controller can create jobs and runnerTick can start them. Both are
         // downstream of the same full compact unattended admission, so it must
         // complete before any reconciliation path that could dispatch either.
-        if (before0.state.schema === 2 && before0.state.planBinding) {
+        if (!generationAdmitted) {
             let admission;
             try {
                 admission = await this.dispatchAdmission();
@@ -359,7 +415,6 @@ class Supervisor {
                 || admission.currentness !== 'current' || admission.sensors !== 'pass' || admission.journal !== 'current') {
                 const kind = transientAdmission(admission);
                 if (kind) {
-                    const binding = before0.state.planBinding;
                     const plan = (0, validate_1.validatePlanFile)(binding.path, this.repoRoot);
                     if (plan.state !== 'valid' || plan.planDigest !== binding.digest || plan.schema !== binding.schema
                         || (binding.executionDigest !== undefined && plan.executionDigest !== binding.executionDigest)
@@ -565,6 +620,10 @@ class Supervisor {
         const finalizing = afterRequests.state?.cohortPhase === 'FINAL_INTEGRATION' || afterRequests.state?.cohortPhase === 'FINAL_INTERLOCK';
         if (!finalizing && afterRequests.state !== null && (0, generations_1.activeGeneration)(afterRequests.state) === undefined
             && afterRequests.state.generations.length > 0 && afterRequests.state.cycle.status === 'IN_PROGRESS') {
+            // The current tick used its launched generation's admission. A
+            // replacement must wait until the next tick's full admission.
+            if (generationAdmitted)
+                return 'continue';
             (0, generations_1.beginGeneration)(this.repoRoot, this.branch);
             if (this.ensureController(resumeAction) === 'custody')
                 return 'custody';
@@ -577,12 +636,15 @@ class Supervisor {
         const freezeCheck = (0, store_1.readJournal)(this.repoRoot, this.branch);
         const freezing = !freezeCheck.corrupt && freezeCheck.state !== null
             && freezeCheck.state.freezeRequested === true && freezeCheck.state.frozen === undefined;
+        // Reconcile controller ownership and, if needed, freshly admit its
+        // replacement before runnerTick can launch received jobs.
+        const supervision = await this.superviseController();
+        if (supervision === 'custody')
+            return 'custody';
         (0, runner_1.runnerTick)(this.repoRoot, this.branch, this.spawner, {
-            reconcileGraceMs: this.cfg.reconcileGraceMs, stallObservationMs: this.cfg.jobStallObservationMs, dispatch: !freezing,
+            reconcileGraceMs: this.cfg.reconcileGraceMs, stallObservationMs: this.cfg.jobStallObservationMs,
+            dispatch: !freezing && supervision === 'ok',
         });
-        const custody = await this.superviseController();
-        if (custody)
-            return 'custody';
         if (freezing)
             return this.attemptFreeze();
         const r = (0, store_1.readJournal)(this.repoRoot, this.branch);
@@ -695,15 +757,23 @@ class Supervisor {
         (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'track-frozen', headSha: s.frozen.headSha });
         return 'frozen'; // paso 6 ("libera el lock y sale"): runSupervisorLoop trata 'frozen' igual que 'complete'
     }
-    /** true => custodia (el caller NO libera lock ni sale). */
+    /** Deferred ownership drains existing jobs but never starts new work. */
     async superviseController() {
         const r = (0, store_1.readJournal)(this.repoRoot, this.branch);
         if (r.corrupt || r.state === null)
             throw new Error('journal corrupto (R1.6)');
         const s = r.state;
         const gen = (0, generations_1.activeGeneration)(s);
-        if (gen?.processRef === undefined)
-            return false; // sin controlador propio: nada que supervisar
+        // Track worktrees may be driven by the plan controller without a
+        // local generation. The canonical final-integration job also runs
+        // after the plan controller is deliberately paused. An existing but
+        // unadopted launch is different: claim recovery/backoff must never
+        // dispatch received jobs under that generation.
+        if (gen === undefined)
+            return s.trackContext || s.cohortPhase === 'FINAL_INTEGRATION'
+                || s.cohortPhase === 'FINAL_INTERLOCK' ? 'ok' : 'deferred';
+        if (gen.processRef === undefined)
+            return 'deferred';
         if (this.lastGenerationToken !== gen.token) {
             this.lastGenerationToken = gen.token;
             this.lastActivity = null;
@@ -716,10 +786,13 @@ class Supervisor {
             this.lastActivity = { key, changedAt: Date.now() };
         }
         const activityFrozenMs = Date.now() - this.lastActivity.changedAt;
-        const decision = (0, generations_1.decideStall)({ heartbeatAgeMs, activityFrozenMs, safeToReplace: adapter.safeToReplace(gen.processRef) }, { heartbeatTimeoutMs: this.cfg.heartbeatTimeoutMs, activityWindowMs: this.cfg.activityWindowMs });
+        const safeToReplace = adapter.safeToReplace(gen.processRef);
+        // A dead process with proven identity is not healthy merely because
+        // its last heartbeat was recent. Resolve it before any new job starts.
+        const decision = snap === null && safeToReplace === 'safe' ? 'resolve-generation' : (0, generations_1.decideStall)({ heartbeatAgeMs, activityFrozenMs, safeToReplace }, { heartbeatTimeoutMs: this.cfg.heartbeatTimeoutMs, activityWindowMs: this.cfg.activityWindowMs });
         if (decision === 'healthy') {
             this.backoff.reset();
-            return false;
+            return 'ok';
         }
         if (decision === 'suspected-stall-observe') {
             if (gen.state !== 'controller-suspected-stall') {
@@ -727,39 +800,53 @@ class Supervisor {
                 (0, store_1.writeJournal)(this.repoRoot, this.branch, s);
                 (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'controller-suspected-stall', n: gen.n });
             }
-            return false;
+            return 'ok';
         }
         if (decision === 'custody-blocked') {
             (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'doble senial de stall sin safeToReplace positivo del adapter (R4.2b)');
-            return true;
+            return 'custody';
         }
         // resolve-generation
         const resolved = await (0, generations_1.resolveGeneration)(this.repoRoot, this.branch, adapter, { termGraceMs: this.cfg.termGraceMs, killGraceMs: this.cfg.killGraceMs });
         if (resolved === 'custody-blocked')
-            return true;
+            return 'custody';
         if (this.backoff.exhausted()) {
             (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'tope de relanzamientos por hora alcanzado (R4.3)');
-            return true;
+            return 'custody';
         }
         if (Date.now() < this.relaunchNotBefore)
-            return false; // esperando backoff, auditando
+            return 'deferred'; // esperando backoff, auditando
+        // This is a different controller generation, even though the tick
+        // began under the old one's admission. Do not reuse that admission
+        // after RED edits, runtime drift, or a currentness change.
+        let replacementAdmission;
+        try {
+            replacementAdmission = await this.dispatchAdmission({ freshSensorsRequired: true });
+        }
+        catch (error) {
+            (0, generations_1.enterCustody)(this.repoRoot, this.branch, `admisión de reemplazo no verificable: ${error.message}`);
+            return 'custody';
+        }
+        if (replacementAdmission.state !== 'admitted' || replacementAdmission.executionMode !== 'desatendido'
+            || replacementAdmission.currentness !== 'current' || replacementAdmission.sensors !== 'pass'
+            || 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';
+        }
         (0, generations_1.beginGeneration)(this.repoRoot, this.branch);
         const nextAction = (0, store_1.readJournal)(this.repoRoot, this.branch).state.cycle.nextAction;
         const action = { schema: 'controller-recovery/v1', kind: nextAction !== undefined ? 'resume-next-action' : 'resume-cycle' };
         const launched = this.ensureController(action);
         if (launched === 'custody')
-            return true;
+            return 'custody';
         if (launched === 'ok') {
             this.backoff.recordRelaunch();
             this.relaunchNotBefore = Date.now() + this.backoff.nextMs();
         }
-        return false;
+        return launched === 'deferred' ? 'deferred' : 'ok';
     }
 }
 exports.Supervisor = Supervisor;
-/** Foreground, visible, terminable (R2.4): sin daemons. SIGINT/SIGTERM libera
- *  el lock y sale; COMPLETE => auto-exit liberando lock y terminando la
- *  generacion propia (cero huerfanos). */
 async function runSupervisorLoop(repoRoot, branch, cfg, spawner = (0, runner_1.defaultWrapperSpawner)(), trackRuntime, dispatchAdmission) {
     const r = (0, store_1.readJournal)(repoRoot, branch);
     if (r.corrupt || r.state === null) {
@@ -772,11 +859,12 @@ async function runSupervisorLoop(repoRoot, branch, cfg, spawner = (0, runner_1.d
     }
     (0, lock_1.verifyBranchInvariant)(repoRoot, r.state.branch);
     if (r.state.cycle.status === 'COMPLETE')
-        return;
+        return 'complete';
     const handle = (0, lock_1.acquireLock)(repoRoot);
     let shutdownRequested = false;
     let wakeSleep = null;
     let safeToRelease = false;
+    let terminal = 'stopped';
     const onSignal = () => { shutdownRequested = true; wakeSleep?.(); };
     process.on('SIGINT', onSignal);
     process.on('SIGTERM', onSignal);
@@ -790,6 +878,7 @@ async function runSupervisorLoop(repoRoot, branch, cfg, spawner = (0, runner_1.d
             // drenar ownership y liberar el lock, el track ya cumplió su
             // freeze y no debe seguir despachando ni corriendo su loop.
             if (out === 'complete' || out === 'frozen') {
+                terminal = out;
                 const finalState = (0, store_1.readJournal)(repoRoot, branch);
                 if (!finalState.corrupt && finalState.state?.routingIncidents?.length)
                     process.stderr.write(`AWM final routing summary ${JSON.stringify((0, journal_1.routingReport)(finalState.state))}\n`);
@@ -831,6 +920,7 @@ async function runSupervisorLoop(repoRoot, branch, cfg, spawner = (0, runner_1.d
         if (shutdownRequested)
             (0, store_1.writeJournal)(repoRoot, branch, sEnd);
         safeToRelease = true;
+        return terminal;
     }
     finally {
         process.removeListener('SIGINT', onSignal);

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')