agentic-workflow-manager 9.12.1 → 9.12.3

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Supervisor = exports.MAX_SENSOR_DEFERRALS = exports.DEFAULT_SUPERVISOR_CONFIG = void 0;
+exports.Supervisor = exports.ADMISSION_RETRY_DELAY_MS = exports.MAX_SENSOR_DEFERRALS = exports.DEFAULT_SUPERVISOR_CONFIG = void 0;
 exports.routingFacts = routingFacts;
 exports.defaultDispatchAdmission = defaultDispatchAdmission;
 exports.admissionForConfig = admissionForConfig;
@@ -192,6 +192,21 @@ exports.DEFAULT_SUPERVISOR_CONFIG = {
 function admissionForConfig(repoRoot, branch, cfg, deps = {}) {
     return defaultDispatchAdmission(repoRoot, branch, cfg.provider, cfg.routingIdentity, deps, cfg.controllerAutonomy);
 }
+function admissionContextForConfig(cfg) {
+    if (!(0, adapter_1.isWatchProvider)(cfg.provider))
+        throw new Error('provider de supervisor invalido');
+    if (cfg.controllerAutonomy !== undefined && !(0, adapter_1.isControllerAutonomy)(cfg.controllerAutonomy))
+        throw new Error('postura del controller invalida');
+    const runtime = cfg.routingIdentity === undefined ? undefined : (0, capabilities_1.validateRuntimeKey)({ target: cfg.provider, ...cfg.routingIdentity });
+    return { provider: cfg.provider,
+        ...(runtime ? { runtime: { kind: runtime.kind, version: runtime.version, accountScopeDigest: runtime.accountScopeDigest } } : {}),
+        ...(cfg.controllerAutonomy ? { controllerAutonomy: cfg.controllerAutonomy } : {}) };
+}
+function sameAdmissionContext(left, right) {
+    return left.provider === right.provider && left.controllerAutonomy === right.controllerAutonomy
+        && left.runtime?.kind === right.runtime?.kind && left.runtime?.version === right.runtime?.version
+        && left.runtime?.accountScopeDigest === right.runtime?.accountScopeDigest;
+}
 // 'frozen' (R5.2/R6.3, Task 10): SOLO puede ocurrir en el journal de un
 // TRACK individual (nunca en el del plan) — el track terminó, con las 6
 // observaciones demostrables (cero jobs vivos, gate local verde, worktree
@@ -200,7 +215,24 @@ function admissionForConfig(repoRoot, branch, cfg, deps = {}) {
 /** How many consecutive ticks an inconclusive sensor verdict may defer dispatch
  *  before the supervisor says so out loud. Small: the deferral covers a verdict
  *  still settling, not one that never will. */
-exports.MAX_SENSOR_DEFERRALS = 3;
+exports.MAX_SENSOR_DEFERRALS = types_1.MAX_ADMISSION_DEFERRALS;
+exports.ADMISSION_RETRY_DELAY_MS = 5000;
+function transientAdmission(report) {
+    // Currentness and sensors are evaluated before journalStatus, so their
+    // blocked reports legitimately carry journal=not-required. The caller
+    // verifies the bound journal identity independently before deferring.
+    if (report.state !== 'blocked' || report.executionMode !== 'desatendido'
+        || report.planState !== 'valid' || !['not-required', 'current'].includes(report.journal)
+        || report.diagnostics.length !== 1)
+        return undefined;
+    if (report.currentness === 'unverifiable' && report.sensors === 'not-required'
+        && report.diagnostics[0].code === 'ADMISSION_CURRENTNESS_BLOCKED')
+        return 'currentness';
+    if (report.currentness === 'current' && report.sensors === 'not-certified'
+        && report.diagnostics[0].code === 'ADMISSION_SENSORS_BLOCKED')
+        return 'sensors';
+    return undefined;
+}
 const LIVE = ['received', 'spawn-intent', 'claimed', 'running', 'cancel-requested'];
 function recoveryWhitelistBlocker(state) {
     if (state.cycle.status === 'BLOCKED') {
@@ -230,21 +262,19 @@ class Supervisor {
     cfg;
     spawner;
     dispatchAdmission;
+    autoBeginGeneration;
     backoff = new generations_1.Backoff();
     relaunchNotBefore = 0;
-    /** Consecutive ticks deferred on an inconclusive sensor verdict. Bounded:
-     *  the deferral exists for a verdict that is still settling, and a verdict
-     *  that never settles must become visible rather than loop forever. */
-    sensorDeferrals = 0;
     lastActivity = null;
     lastGenerationToken = null;
     trackRuntime;
-    constructor(repoRoot, branch, cfg, spawner, trackRuntime, dispatchAdmission = admissionForConfig(repoRoot, branch, cfg)) {
+    constructor(repoRoot, branch, cfg, spawner, trackRuntime, dispatchAdmission = admissionForConfig(repoRoot, branch, cfg), autoBeginGeneration = false) {
         this.repoRoot = repoRoot;
         this.branch = branch;
         this.cfg = cfg;
         this.spawner = spawner;
         this.dispatchAdmission = dispatchAdmission;
+        this.autoBeginGeneration = autoBeginGeneration;
         this.trackRuntime = trackRuntime ?? (0, tracks_1.defaultTrackRuntime)(repoRoot, branch, { termGraceMs: cfg.termGraceMs, killGraceMs: cfg.killGraceMs });
     }
     fingerprintNow = (argv, paths, cwd) => {
@@ -281,7 +311,7 @@ class Supervisor {
         }
     }
     async tick() {
-        const before0 = (0, store_1.readJournal)(this.repoRoot, this.branch);
+        let before0 = (0, store_1.readJournal)(this.repoRoot, this.branch);
         if (before0.corrupt || before0.state === null)
             throw new Error('journal corrupto: el supervisor no opera sobre corrupcion (R1.6)');
         // Historical/schema-1 journals are intentionally readable by migration
@@ -295,10 +325,77 @@ class Supervisor {
         // longer reconstructible.
         if (before0.state.cycle.status === 'COMPLETE')
             return 'complete';
+        // A historical custody cannot be silently converted into another
+        // cause on a later tick. Only the locked offline recovery may resume.
+        if (before0.state.cycle.status === 'BLOCKED')
+            return 'custody';
+        const assertedContext = admissionContextForConfig(this.cfg);
+        if (before0.state.admissionContext && !sameAdmissionContext(before0.state.admissionContext, assertedContext)) {
+            (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'identidad de admisión cambió al reiniciar: provider/runtime/postura');
+            return 'custody';
+        }
+        if (!before0.state.admissionContext && assertedContext.runtime && assertedContext.controllerAutonomy) {
+            before0.state.admissionContext = assertedContext;
+            (0, store_1.writeJournal)(this.repoRoot, this.branch, before0.state);
+            before0 = (0, store_1.readJournal)(this.repoRoot, this.branch);
+            if (before0.corrupt || !before0.state)
+                throw new Error('journal no verificable tras vincular identidad de admisión');
+        }
+        // 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();
@@ -309,40 +406,48 @@ class Supervisor {
             }
             if (admission.state !== 'admitted' || admission.executionMode !== 'desatendido'
                 || admission.currentness !== 'current' || admission.sensors !== 'pass' || admission.journal !== 'current') {
-                // A first empirical sensor observation can be inconclusive while
-                // the already-started controller is still settling. It never
-                // authorizes dispatch; retry the read-only admission next tick
-                // instead of permanently custodying a healthy cycle.
-                //
-                // Bounded, because the verdict is not always transient: a
-                // registry whose sensors are all disabled reports
-                // `not-certified` forever. Unbounded, this returned before
-                // `consumePendingRequests` below, so the supervisor ticked
-                // indefinitely applying nothing and writing nothing — no event,
-                // no state change, no exit. Refusing to progress is correct
-                // here; refusing invisibly is not. Consuming requests cannot be
-                // hoisted above this gate to compensate: applying a job-request
-                // creates a Job that runnerTick can start, which is the dispatch
-                // this admission exists to authorize.
-                if (admission.planState === 'valid' && admission.currentness === 'current'
-                    && admission.sensors === 'not-certified' && admission.journal === 'not-required') {
-                    this.sensorDeferrals += 1;
-                    if (this.sensorDeferrals <= exports.MAX_SENSOR_DEFERRALS)
+                const kind = transientAdmission(admission);
+                if (kind) {
+                    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)
+                        || (admission.planDigest !== undefined && admission.planDigest !== binding.digest)) {
+                        (0, generations_1.enterCustody)(this.repoRoot, this.branch, 'binding del plan alterado durante admisión transitoria');
+                        return 'custody';
+                    }
+                    const prior = before0.state.admissionRetry;
+                    const attempts = (prior?.attempts ?? 0) + 1;
+                    if (attempts <= types_1.MAX_ADMISSION_DEFERRALS) {
+                        const now = Date.now();
+                        before0.state.admissionRetry = { kind, attempts, firstAt: prior?.firstAt ?? new Date(now).toISOString(), nextRetryAt: new Date(now + exports.ADMISSION_RETRY_DELAY_MS).toISOString() };
+                        (0, store_1.writeJournal)(this.repoRoot, this.branch, before0.state);
+                        (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'admission-retry', cause: kind, attempts, retryAfterMs: exports.ADMISSION_RETRY_DELAY_MS });
                         return 'continue';
-                    // The reason must not carry the running counter. enterCustody is
-                    // idempotent on (status, reason), so a message that changes every
-                    // tick defeats that guard and rewrites the journal plus appends a
-                    // custody-blocked event every tickMs, without bound. Naming the
-                    // bound instead of the count keeps the reason stable, so custody
-                    // is entered once and stays entered.
-                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, `veredicto de sensores no concluyente tras ${exports.MAX_SENSOR_DEFERRALS} ticks: ${admission.diagnostics.map(diagnostic => `${diagnostic.code}: ${diagnostic.message}`).join('; ')}`);
+                    }
+                    (0, generations_1.enterCustody)(this.repoRoot, this.branch, `admisión ${kind} no verificable tras ${types_1.MAX_ADMISSION_DEFERRALS} reintentos: ${admission.diagnostics.map(diagnostic => `${diagnostic.code}: ${diagnostic.message}`).join('; ')}`);
                     return 'custody';
                 }
                 (0, generations_1.enterCustody)(this.repoRoot, this.branch, `admisión compacta desatendida bloqueada antes de dispatch: ${admission.diagnostics.map(diagnostic => `${diagnostic.code}: ${diagnostic.message}`).join('; ')}`);
                 return 'custody';
             }
-            // The verdict settled, which is exactly what the deferral waited for.
-            this.sensorDeferrals = 0;
+            // An incomplete assertion can be repaired while the cycle is
+            // still waiting. Bind it only after an admitted observation, never
+            // on an early currentness/sensor response that has not reached the
+            // provider, runtime and autonomy gates yet.
+            if (!before0.state.admissionContext) {
+                before0.state.admissionContext = assertedContext;
+                (0, store_1.writeJournal)(this.repoRoot, this.branch, before0.state);
+                before0 = (0, store_1.readJournal)(this.repoRoot, this.branch);
+                if (before0.corrupt || !before0.state)
+                    throw new Error('journal no verificable tras vincular admisión completa');
+            }
+            if (before0.state.admissionRetry) {
+                before0.state.admissionRetry = undefined;
+                (0, store_1.writeJournal)(this.repoRoot, this.branch, before0.state);
+                before0 = (0, store_1.readJournal)(this.repoRoot, this.branch);
+                if (before0.corrupt || !before0.state)
+                    throw new Error('journal no verificable tras resolver reintento de admisión');
+            }
         }
         let recoveryResumeAction;
         // Schema-2 custody is reconciled before any controller launch.  This is
@@ -396,14 +501,14 @@ class Supervisor {
             // verdicts, and an adverse verdict without a closed fix all stop
             // recovery before a controller can create more work.
             const verdictById = new Map(before0.state.verdicts.map(verdict => [verdict.id, verdict]));
-            const openReviewOrFix = before0.state.tasks.some(task => {
+            const openReviewOrFix = (terminalTaskClaims && before0.state.tasks.some(task => {
                 const obligations = task.reviewObligations;
                 return !['spec', 'quality'].every(kind => obligations.some(obligation => obligation.kind === kind))
                     || obligations.some(obligation => {
                         const verdict = obligation.verdictId === undefined ? undefined : verdictById.get(obligation.verdictId);
                         return verdict === undefined || verdict.result !== 'pass';
                     });
-            }) || before0.state.verdicts.some(verdict => verdict.result !== 'pass'
+            })) || before0.state.verdicts.some(verdict => verdict.result !== 'pass'
                 && !before0.state.fixes.some(fix => fix.verdictId === verdict.id && fix.closed));
             const recovery = (0, fingerprint_1.reconcileUnattendedRecovery)({
                 journal: before0.state, journalCorrupt: false, plan: before0.state.planBinding,
@@ -442,6 +547,8 @@ class Supervisor {
         // mismo resultado terminal.
         if (before.frozen !== undefined)
             return 'frozen';
+        if (this.autoBeginGeneration && (0, generations_1.activeGeneration)(before) === undefined)
+            (0, generations_1.beginGeneration)(this.repoRoot, this.branch);
         const pending = before.cycle.nextAction;
         const resumeAction = recoveryResumeAction ?? { schema: 'controller-recovery/v1', kind: pending !== undefined ? 'resume-next-action' : 'resume-cycle' };
         if (this.ensureController(resumeAction) === 'custody')
@@ -506,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';
@@ -518,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);
@@ -636,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;
@@ -657,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') {
@@ -668,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) {
@@ -713,20 +852,17 @@ 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);
-    const sup = new Supervisor(repoRoot, branch, cfg, spawner, trackRuntime, dispatchAdmission);
+    const sup = new Supervisor(repoRoot, branch, cfg, spawner, trackRuntime, dispatchAdmission, true);
     try {
-        const s0 = (0, store_1.readJournal)(repoRoot, branch).state;
-        if ((0, generations_1.activeGeneration)(s0) === undefined) {
-            (0, generations_1.beginGeneration)(repoRoot, branch);
-        }
         for (;;) {
             if (shutdownRequested)
                 break;
@@ -735,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`);
@@ -776,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

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GENERATION_STATES = exports.EXECUTION_STATES = void 0;
+exports.MAX_ADMISSION_DEFERRALS = exports.GENERATION_STATES = exports.EXECUTION_STATES = void 0;
 exports.activeRequestProblems = activeRequestProblems;
 exports.isControllerRecoveryAction = isControllerRecoveryAction;
 exports.emptyState = emptyState;
@@ -50,6 +50,7 @@ function activeRequestProblems(state) {
             || !state.tasks.some(task => task.id === problem.taskId);
     });
 }
+exports.MAX_ADMISSION_DEFERRALS = 3;
 function isControllerRecoveryAction(x) {
     return isObj(x) && Object.keys(x).length === 2
         && x.schema === 'controller-recovery/v1'
@@ -98,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))
@@ -107,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)))
@@ -117,6 +152,12 @@ function isWellFormedState(x) {
         return false;
     if (x.custodyDecisions !== undefined && (!Array.isArray(x.custodyDecisions) || !x.custodyDecisions.every(isWellFormedCustodyDecision)))
         return false;
+    if (x.admissionRetry !== undefined && !isWellFormedAdmissionRetry(x.admissionRetry))
+        return false;
+    if (x.admissionContext !== undefined && !isWellFormedAdmissionContext(x.admissionContext))
+        return false;
+    if (x.admissionRecoveries !== undefined && (!Array.isArray(x.admissionRecoveries) || !x.admissionRecoveries.every(isWellFormedAdmissionRecovery)))
+        return false;
     if (!x.generations.every(isWellFormedGeneration) || !x.tasks.every(isWellFormedTask))
         return false;
     if (!x.cycleVerificationPlan.every(isWellFormedVerificationItem))
@@ -176,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');
@@ -228,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)))
@@ -274,6 +318,36 @@ function isWellFormedCustodyDecision(x) {
     return isObj(x) && typeof x.at === 'string' && x.decision === 'resume'
         && typeof x.reason === 'string' && typeof x.generationToken === 'string';
 }
+function isWellFormedAdmissionRetry(x) {
+    return isObj(x) && Object.keys(x).length === 4
+        && (x.kind === 'currentness' || x.kind === 'sensors')
+        && Number.isInteger(x.attempts) && Number(x.attempts) >= 1 && Number(x.attempts) <= exports.MAX_ADMISSION_DEFERRALS
+        && typeof x.firstAt === 'string' && Number.isFinite(Date.parse(x.firstAt))
+        && typeof x.nextRetryAt === 'string' && Number.isFinite(Date.parse(x.nextRetryAt))
+        && Date.parse(x.nextRetryAt) >= Date.parse(x.firstAt);
+}
+function isWellFormedAdmissionContext(x) {
+    if (!isObj(x) || !Object.keys(x).every(key => ['provider', 'runtime', 'controllerAutonomy'].includes(key))
+        || (x.provider !== 'codex' && x.provider !== 'claude-code')
+        || (x.controllerAutonomy !== undefined && x.controllerAutonomy !== 'approval-free'))
+        return false;
+    if (x.runtime === undefined)
+        return true;
+    return isObj(x.runtime) && Object.keys(x.runtime).length === 3
+        && typeof x.runtime.kind === 'string' && x.runtime.kind.length > 0
+        && typeof x.runtime.version === 'string' && x.runtime.version.length > 0
+        && typeof x.runtime.accountScopeDigest === 'string' && /^[a-f0-9]{64}$/.test(x.runtime.accountScopeDigest);
+}
+function isWellFormedAdmissionRecovery(x) {
+    return isObj(x) && Object.keys(x).every(key => ['at', 'reason', 'blockedReason', 'generationToken', 'context', 'planDigest', 'assertion'].includes(key))
+        && typeof x.at === 'string' && Number.isFinite(Date.parse(x.at))
+        && typeof x.reason === 'string' && x.reason.trim().length > 0 && x.reason.length <= 1024
+        && typeof x.blockedReason === 'string' && x.blockedReason.length > 0
+        && (x.generationToken === undefined || (typeof x.generationToken === 'string' && x.generationToken.length > 0))
+        && isWellFormedAdmissionContext(x.context)
+        && typeof x.planDigest === 'string' && /^[a-f0-9]{64}$/.test(x.planDigest)
+        && (x.assertion === 'recorded' || x.assertion === 'legacy-operator-asserted');
+}
 function isWellFormedProcessRef(x) {
     if (!isObj(x))
         return false;