agentic-workflow-manager 9.12.2 → 9.12.3

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/apply.js

@@ -155,6 +155,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 +174,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 +471,40 @@ 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 existing = s.dispatches.find(d => d.id === dispatchId);
+            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

@@ -341,12 +341,61 @@ 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 (error) {
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, `runtime local no verificable: ${error.message}`);
+                    return 'custody';
+                }
+                if (local.state !== 'current' || 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 +408,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 +613,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 +629,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 +750,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 +779,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 +793,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();
+        }
+        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') {
+            (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 +852,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 +871,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 +913,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/journal/requests.js

@@ -85,9 +85,15 @@ function isWellFormedEnvelope(x) {
 }
 function listPendingRequests(repoRoot, branch) {
     const dir = (0, paths_1.requestsDir)(repoRoot, branch);
+    const directory = fs_1.default.lstatSync(dir);
+    if (directory.isSymbolicLink() || !directory.isDirectory())
+        throw new Error('request directory is not a controlled directory');
     return fs_1.default.readdirSync(dir).filter((f) => f.endsWith('.json')).sort().map((f) => {
         const file = path_1.default.join(dir, f);
         try {
+            const stat = fs_1.default.lstatSync(file);
+            if (stat.isSymbolicLink() || !stat.isFile())
+                return { requestId: f, envelope: null, file, corrupt: true };
             const parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
             // Shape completa antes de cualquier uso downstream. JSON valido no
             // implica envelope valido: payload/generation/idempotency ausentes

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

@@ -99,6 +99,8 @@ function isWellFormedState(x) {
         return false;
     if (!Array.isArray(x.generations) || !Array.isArray(x.tasks))
         return false;
+    if (!x.tasks.every(isWellFormedTask))
+        return false;
     if (!Array.isArray(x.cycleVerificationPlan) || !Array.isArray(x.verdicts) || !Array.isArray(x.fixes))
         return false;
     if (!Array.isArray(x.requiredVerifiers) || !x.requiredVerifiers.every((kind) => VERIFICATION_KINDS.includes(kind))
@@ -108,8 +110,40 @@ function isWellFormedState(x) {
         return false;
     if (!isObj(x.appliedRequests) || !Object.values(x.appliedRequests).every(isWellFormedAppliedRequest))
         return false;
+    if (!Object.entries(x.appliedRequests).every(([requestId, ack]) => requestId === ack.requestId))
+        return false;
     if (x.routingAttempts !== undefined && (!Array.isArray(x.routingAttempts) || x.routingAttempts.length > 4096 || !x.routingAttempts.every(isWellFormedRoutingAttempt)))
         return false;
+    // A linked v2 dispatch is evidence of a native handoff. Reject a broken
+    // link or a second dispatch for one reservation on journal read as well as
+    // at request-application time. Historical unlinked records remain readable
+    // but cannot masquerade as this new acknowledged handoff.
+    if (x.planBinding?.schema === 'compact-slices/v2') {
+        const binding = x.planBinding;
+        const attempts = (x.routingAttempts ?? []);
+        const dispatches = x.dispatches;
+        const linked = new Set();
+        for (const dispatch of dispatches) {
+            if (!dispatch.routingAttemptId)
+                continue;
+            if (linked.has(dispatch.routingAttemptId))
+                return false;
+            linked.add(dispatch.routingAttemptId);
+            const attempt = attempts.find(candidate => candidate.id === dispatch.routingAttemptId);
+            if (!attempt || !(x.tasks.some(task => task.id === dispatch.taskId))
+                || attempt.envelope.role !== 'implementer' || attempt.envelope.sliceId !== dispatch.taskId
+                || attempt.envelope.planDigest !== binding.digest || attempt.envelope.executionDigest !== binding.executionDigest
+                || !attempt.reservationRequestId || !dispatch.dispatchRequestId)
+                return false;
+            const acknowledgements = x.appliedRequests;
+            const reservationAck = acknowledgements[attempt.reservationRequestId];
+            const dispatchAck = acknowledgements[dispatch.dispatchRequestId];
+            if (reservationAck?.outcome !== 'applied' || reservationAck.requestId !== attempt.reservationRequestId
+                || reservationAck.resultRef !== attempt.id || dispatchAck?.outcome !== 'applied'
+                || dispatchAck.requestId !== dispatch.dispatchRequestId || dispatchAck.resultRef !== dispatch.id)
+                return false;
+        }
+    }
     if (x.routingIncidents !== undefined && (!Array.isArray(x.routingIncidents) || x.routingIncidents.length > 4096 || !x.routingIncidents.every(isWellFormedRoutingIncident)))
         return false;
     if (x.implementationLineages !== undefined && (!Array.isArray(x.implementationLineages) || x.implementationLineages.length > 4096 || !x.implementationLineages.every(isWellFormedImplementationLineage)))
@@ -183,7 +217,10 @@ function isWellFormedNextAction(x) {
         && (x.state === 'pending' || x.state === 'in-progress');
 }
 function isWellFormedDispatch(x) {
-    return isObj(x) && typeof x.id === 'string' && typeof x.taskId === 'string' && typeof x.at === 'string';
+    return isObj(x) && Object.keys(x).every(key => ['id', 'taskId', 'at', 'routingAttemptId', 'dispatchRequestId'].includes(key))
+        && typeof x.id === 'string' && x.id.length > 0 && typeof x.taskId === 'string' && x.taskId.length > 0
+        && typeof x.at === 'string' && (x.routingAttemptId === undefined || (typeof x.routingAttemptId === 'string' && x.routingAttemptId.length > 0))
+        && (x.dispatchRequestId === undefined || (typeof x.dispatchRequestId === 'string' && x.dispatchRequestId.length > 0));
 }
 function strings(x) {
     return Array.isArray(x) && x.every((item) => typeof item === 'string');
@@ -235,11 +272,11 @@ function isWellFormedAppliedRequest(x) {
         && (x.resultRef === undefined || typeof x.resultRef === 'string');
 }
 function isWellFormedRoutingAttempt(x) {
-    return isObj(x) && Object.keys(x).every(key => ['schema', 'id', 'obligationId', 'lineageId', 'attempt', 'envelope', 'envelopeDigest', 'fingerprint', 'state', 'reservedAt', 'nativeEvidenceRequired', 'nativeEventDigest', 'nativeAgentId', 'observed', 'observedBackendModel', 'verdict', 'reasonCode', 'administrativeRepair'].includes(key))
+    return isObj(x) && Object.keys(x).every(key => ['schema', 'id', 'obligationId', 'lineageId', 'attempt', 'envelope', 'envelopeDigest', 'fingerprint', 'state', 'reservedAt', 'reservationRequestId', 'nativeEvidenceRequired', 'nativeEventDigest', 'nativeAgentId', 'observed', 'observedBackendModel', 'verdict', 'reasonCode', 'administrativeRepair'].includes(key))
         && x.schema === 'routing-attempt/v1'
         && typeof x.id === 'string' && typeof x.obligationId === 'string' && typeof x.lineageId === 'string' && Number.isSafeInteger(x.attempt) && x.attempt > 0
         && typeof x.envelopeDigest === 'string' && /^[a-f0-9]{64}$/.test(x.envelopeDigest) && typeof x.fingerprint === 'string' && /^[a-f0-9]{64}$/.test(x.fingerprint)
-        && ['reserved', 'active', 'complete', 'blocked', 'unknown'].includes(String(x.state)) && (x.reservedAt === undefined || (typeof x.reservedAt === 'string' && Number.isFinite(Date.parse(x.reservedAt)))) && (x.nativeEvidenceRequired === undefined || x.nativeEvidenceRequired === true) && (x.nativeEventDigest === undefined || isDigest(x.nativeEventDigest)) && (x.nativeAgentId === undefined || typeof x.nativeAgentId === 'string') && (x.observed === undefined || isRoutingSelection(x.observed)) && (x.observedBackendModel === undefined || (typeof x.observedBackendModel === 'string' && x.observedBackendModel.length > 0 && x.observedBackendModel.length <= 128)) && (x.verdict === undefined || ['pass', 'fail', 'inconclusive'].includes(String(x.verdict))) && (x.reasonCode === undefined || typeof x.reasonCode === 'string') && (x.administrativeRepair === undefined || x.administrativeRepair === true) && isRoutingEnvelope(x.envelope);
+        && ['reserved', 'active', 'complete', 'blocked', 'unknown'].includes(String(x.state)) && (x.reservedAt === undefined || (typeof x.reservedAt === 'string' && Number.isFinite(Date.parse(x.reservedAt)))) && (x.reservationRequestId === undefined || (typeof x.reservationRequestId === 'string' && x.reservationRequestId.length > 0 && x.reservationRequestId.length <= 128)) && (x.nativeEvidenceRequired === undefined || x.nativeEvidenceRequired === true) && (x.nativeEventDigest === undefined || isDigest(x.nativeEventDigest)) && (x.nativeAgentId === undefined || typeof x.nativeAgentId === 'string') && (x.observed === undefined || isRoutingSelection(x.observed)) && (x.observedBackendModel === undefined || (typeof x.observedBackendModel === 'string' && x.observedBackendModel.length > 0 && x.observedBackendModel.length <= 128)) && (x.verdict === undefined || ['pass', 'fail', 'inconclusive'].includes(String(x.verdict))) && (x.reasonCode === undefined || typeof x.reasonCode === 'string') && (x.administrativeRepair === undefined || x.administrativeRepair === true) && isRoutingEnvelope(x.envelope);
 }
 function isWellFormedRoutingIncident(x) {
     if (!isObj(x) || Object.keys(x).length !== 12 || !Object.keys(x).every(key => ['schema', 'id', 'runStartedAt', 'target', 'selection', 'reasonCode', 'firstAt', 'lastAt', 'affectedObligations', 'fallbackCount', 'blockedCount', 'alertState'].includes(key)))

package/dist/tests/commands/watch/plan-lifecycle.test.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -19,6 +52,7 @@ const supervisor_1 = require("../../../src/commands/watch/supervisor");
 const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
 const lock_1 = require("../../../src/commands/watch/lock");
 const archive_unused_1 = require("../../../src/commands/watch/archive-unused");
+const adapterModule = __importStar(require("../../../src/core/journal/adapter"));
 jest.setTimeout(30000);
 function valid(repo) {
     const report = (0, validate_1.validatePlanFile)('docs/plan.md', repo);
@@ -43,7 +77,7 @@ describe('compact lifecycle proof and unused bootstrap archival', () => {
         fs_1.default.writeFileSync(path_1.default.join(repo, 'docs/plan.md'), `${fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v1/valid.md'), 'utf8')}\n- [ ] Reviewed task.\n`);
         (0, init_1.initWatch)(repo, 'main', { path: 'docs/plan.md', report: valid(repo) });
     });
-    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    afterEach(() => { jest.restoreAllMocks(); fs_1.default.rmSync(repo, { recursive: true, force: true }); });
     test('durable journal retains hash commitments only, never the validated plan source body', () => {
         const contents = (directory) => fs_1.default.readdirSync(directory, { withFileTypes: true }).map(entry => entry.isDirectory() ? contents(path_1.default.join(directory, entry.name)) : fs_1.default.readFileSync(path_1.default.join(directory, entry.name), 'utf8')).join('\n');
         expect(contents((0, paths_1.journalDir)(repo, 'main'))).not.toContain('Reviewed task.');
@@ -138,6 +172,18 @@ describe('compact lifecycle proof and unused bootstrap archival', () => {
                     fingerprint: (0, fingerprint_1.computeFingerprint)(repo, argv, ['source.md'], '.').fingerprint, argv, paths: ['source.md'], cwd: '.',
                 } });
         }
+        // This fixture acts as the external controller. Give it an adopted
+        // identity before expecting the supervisor to dispatch verification
+        // jobs; launch intent alone is deliberately insufficient.
+        expect(await supervisor.tick()).toBe('continue');
+        const launched = (0, store_1.readJournal)(repo, 'main').state;
+        const gen = launched.generations.find(entry => entry.token === generation.token);
+        gen.processRef = { pid: process.pid, processGroup: process.pid, startTime: 'fixture',
+            spawnNonce: gen.spawnNonce, argvDigest: gen.launchArgvDigest, psArgsDigest: 'b'.repeat(64) };
+        (0, store_1.writeJournal)(repo, 'main', launched);
+        const adapter = adapterModule.adapterFor('codex');
+        jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter,
+            activity: () => ({ cpuTime: '0', groupSize: 1 }), safeToReplace: () => 'indeterminate' });
         for (let i = 0; i < 100; i++) {
             expect(await supervisor.tick()).toBe('continue');
             if (Object.values((0, store_1.readJournal)(repo, 'main').state.jobs).some(job => job.verdict === 'pass'))