agentic-workflow-manager 9.12.0 → 9.12.1

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

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeGate = computeGate;
 exports.computeTrackGate = computeTrackGate;
+// Interlock mecanico (design R3.2): falla CERRADO. Solo `pass` con fingerprint
+// VIGENTE satisface (R1.4c, RF-2.8). Cada agujero del bloqueador 5 de la
+// review tiene su categoria propia — nada aprueba por vacuidad ni por
+// referencia falsa.
+const types_1 = require("../../core/journal/types");
 const store_1 = require("../../core/journal/store");
 const LIVE = ['received', 'spawn-intent', 'claimed', 'running', 'cancel-requested'];
 function sameSelection(left, right) {
@@ -12,7 +17,7 @@ function evaluateEvidence(state, fingerprintNow, scope) {
     if (state.cycle.status === 'BLOCKED') {
         reasons.push({ category: 'cycle-blocked', detail: `ciclo BLOCKED: ${state.cycle.blockedReason ?? 'sin razon registrada'}` });
     }
-    for (const problem of state.requestProblems) {
+    for (const problem of (0, types_1.activeRequestProblems)(state)) {
         reasons.push({ category: 'request-problem', detail: `request ${problem.kind} en ${problem.file}: ${problem.detail}` });
     }
     for (const j of Object.values(state.jobs)) {

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

@@ -116,13 +116,34 @@ function registerJobCommand(program) {
         }
         if (typeof payload !== 'object' || payload === null || Array.isArray(payload))
             throw new Error('--json requiere un objeto JSON');
+        if ('entity' in payload && payload.entity !== opts.entity) {
+            throw new Error('--json entity debe coincidir con --entity');
+        }
         const repo = process.cwd();
         const branch = branchOf(repo);
         assertAuthenticatedCwd(repo, branch);
+        if (opts.entity === 'task') {
+            const current = (0, store_1.readJournal)(repo, branch);
+            if (current.corrupt || current.state === null)
+                throw new Error('register --entity task requiere journal valido');
+            const taskId = payload.taskId;
+            const rawPlan = payload.verificationPlan;
+            const allowedKinds = ['test', 'lint', 'sensors', 'review', 'qa', 'interlock', 'track-integration'];
+            if (typeof taskId !== 'string' || taskId.length === 0)
+                throw new Error('register --entity task requiere taskId');
+            if (rawPlan !== undefined && (!Array.isArray(rawPlan) || !rawPlan.every(item => typeof item === 'object' && item !== null && typeof item.id === 'string' && item.id.length > 0
+                && allowedKinds.includes(item.kind) && (item.satisfiedBy === undefined || typeof item.satisfiedBy === 'string')))) {
+                throw new Error('register --entity task requiere verificationPlan valido');
+            }
+            const plan = (rawPlan ?? []);
+            const missing = current.state.requiredVerifiers.filter(kind => !plan.some(item => item.kind === kind));
+            if (missing.length > 0)
+                throw new Error(`register --entity task: verificationPlan no cubre los verificadores requeridos: ${missing.join(', ')}`);
+        }
         const r = (0, requests_1.emitRequest)(repo, branch, {
             kind: 'register-entity', generationToken: opts.generation,
             idempotencyKey: crypto_1.default.createHash('sha256').update(`${opts.entity}:${opts.json}`).digest('hex'),
-            payload: { entity: opts.entity, ...payload },
+            payload: { ...payload, entity: opts.entity },
         });
         process.stdout.write(JSON.stringify({ requestId: r.requestId }, null, 2) + '\n');
     });

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyCyclePlanAppend = applyCyclePlanAppend;
 exports.registerTrackIntegrationItems = registerTrackIntegrationItems;
+exports.applyRequestToState = applyRequestToState;
 exports.consumePendingRequests = consumePendingRequests;
 // Consumo transaccional de requests (bloqueador 4): mutar estado ->
 // writeJournal -> RECIEN AHI borrar archivos. El replay es seguro por
@@ -502,6 +503,8 @@ function applyRequestToState(s, env, digest, repoRoot, eventScope) {
             }
             if (s.cycle.status !== 'BLOCKED')
                 throw new Error('custody-decision solo aplica a un ciclo BLOCKED');
+            if ((0, types_1.activeRequestProblems)(s).length > 0)
+                throw new Error('custody-decision no resuelve requests rechazadas pendientes');
             s.custodyDecisions ??= [];
             s.custodyDecisions.push({ at: now(), decision: 'resume', reason: p.reason, generationToken: env.generationToken });
             for (const generation of s.generations) {
@@ -666,7 +669,10 @@ function consumePendingRequests(repoRoot, branch, activeToken, eventScope) {
                 rejectedInvalid++;
                 deferredRenames.push({ from: p.file, to: `${p.file}.rejected` });
                 if (!s.requestProblems.some((problem) => problem.file === p.file && problem.kind === 'rejected')) {
-                    s.requestProblems.push({ file: p.file, kind: 'rejected', detail: (0, redact_1.redactText)(e.message), at: now() });
+                    s.requestProblems.push({ file: p.file, kind: 'rejected', detail: (0, redact_1.redactText)(e.message), at: now(),
+                        requestId: env.requestId, generationToken: env.generationToken,
+                        ...(env.kind === 'register-entity' && env.payload.entity === 'task' && typeof env.payload.taskId === 'string'
+                            ? { taskId: env.payload.taskId } : {}) });
                 }
                 (0, store_1.appendEvent)(repoRoot, branch, { kind: 'request-rejected-invalid', requestId: env.requestId, detail: e.message });
                 dirChanged = true;

package/dist/src/commands/watch/archive-unused.js

@@ -50,8 +50,10 @@ function watchJournalStatus(repoRoot, branch) {
     }
     catch { /* recognized present journal, but never eligible by absence alone */ }
     const binding = current.state.planBinding;
+    const latest = current.state.generations.reduce((prev, generation) => prev === undefined || generation.n > prev.n ? generation : prev, undefined);
     return {
         state: 'present', cycleState: current.state.cycle.status, bootstrapUnused,
+        ...(latest ? { latestGeneration: { n: latest.n, token: latest.token, state: latest.state } } : {}),
         ...(binding ? { binding: { path: binding.path, digest: binding.digest, ...(binding.executionDigest ? { executionDigest: binding.executionDigest, executionIdentitySchema: binding.executionIdentitySchema } : {}), schema: binding.schema, executionMode: binding.executionMode, boundAt: binding.boundAt } } : {}),
     };
 }

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerWatchCommand = registerWatchCommand;
 const child_process_1 = require("child_process");
 const init_1 = require("./init");
+const request_recovery_1 = require("./request-recovery");
 const supervisor_1 = require("./supervisor");
 const capabilities_1 = require("../../core/model-policy/capabilities");
 const adapter_1 = require("../../core/journal/adapter");
@@ -144,6 +145,29 @@ function registerWatchCommand(program) {
         await (0, supervisor_1.runSupervisorLoop)(repo, branch, cfg);
         process.stdout.write('gate verde: ciclo COMPLETE — drenado, lock liberado, apagando\n');
     });
+    watch.command('recover-request')
+        .description('reconcilia una task rechazada con una request correctiva aplicada bajo lock exclusivo')
+        .requiredOption('--rejected <requestId>', 'request rechazada archivada')
+        .requiredOption('--replacement <requestId>', 'request correctiva pendiente')
+        .requiredOption('--generation <token>', 'generacion vigente')
+        .requiredOption('--reason <text>', 'motivo auditado de la recuperacion')
+        .option('--resume', 'reanuda explicitamente custodia si el unico bloqueo era la request')
+        .action((opts) => {
+        const repo = process.cwd();
+        const branch = currentBranch(repo);
+        try {
+            (0, context_1.resolveCommandContext)(repo, branch);
+            (0, request_recovery_1.recoverRejectedTask)(repo, branch, {
+                rejectedRequestId: opts.rejected, replacementRequestId: opts.replacement,
+                generationToken: opts.generation, reason: opts.reason, resume: opts.resume === true,
+            });
+            process.stdout.write(JSON.stringify({ recovered: true, rejectedRequestId: opts.rejected, replacementRequestId: opts.replacement, resumed: opts.resume === true }) + '\n');
+        }
+        catch (error) {
+            process.stderr.write(`${error.message}\n`);
+            process.exitCode = 1;
+        }
+    });
     watch
         .command('rebind')
         .description('reconcilia intencionalmente el binding desatendido tras un cambio válido del ciclo del plan')

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

@@ -13,6 +13,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const store_1 = require("../../core/journal/store");
 const paths_1 = require("../../core/journal/paths");
+const types_1 = require("../../core/journal/types");
 const lock_1 = require("./lock");
 const validate_1 = require("../../core/plan/validate");
 const identity_1 = require("../../core/plan/identity");
@@ -104,7 +105,7 @@ function rebindBlocker(state) {
     const nonterminal = Object.values(state.jobs).filter(job => !TERMINAL_JOB_STATES.has(job.executionState));
     if (nonterminal.length > 0)
         return `hay jobs no terminales: ${nonterminal.map(job => job.id).join(', ')}`;
-    if (state.requestProblems.length > 0)
+    if ((0, types_1.activeRequestProblems)(state).length > 0)
         return 'hay conflictos durables de requests';
     if (state.verdicts.some(verdict => verdict.result !== 'pass'))
         return 'hay evidencia adversa durable';

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

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverRejectedTask = recoverRejectedTask;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const json_1 = require("../../core/plan/json");
+const atomic_file_1 = require("../../core/atomic-file");
+const types_1 = require("../../core/journal/types");
+const requests_1 = require("../../core/journal/requests");
+const paths_1 = require("../../core/journal/paths");
+const store_1 = require("../../core/journal/store");
+const process_1 = require("../../core/journal/process");
+const apply_1 = require("./apply");
+const lock_1 = require("./lock");
+const REQUEST_ID = /^req-[0-9]+-[0-9]{10}-[a-f0-9]{8}$/;
+const MAX_REQUEST_BYTES = 256 * 1024;
+function validatedId(value, label) {
+    if (typeof value !== 'string' || !REQUEST_ID.test(value))
+        throw new Error(`${label} requiere un requestId valido`);
+    return value;
+}
+/** Reads only one canonical, bounded request file. The inode check closes a
+ * swap between lstat and open, including platforms without O_NOFOLLOW. */
+function requestEnvelope(file, requestId) {
+    const before = fs_1.default.lstatSync(file);
+    if (!before.isFile() || before.isSymbolicLink() || before.size < 1 || before.size > MAX_REQUEST_BYTES) {
+        throw new Error('request de recovery no es un archivo regular acotado');
+    }
+    const descriptor = fs_1.default.openSync(file, fs_1.default.constants.O_RDONLY | (fs_1.default.constants.O_NOFOLLOW ?? 0));
+    let body;
+    try {
+        const opened = fs_1.default.fstatSync(descriptor);
+        if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size) {
+            throw new Error('request de recovery cambio de identidad');
+        }
+        body = fs_1.default.readFileSync(descriptor, { encoding: 'utf8' });
+    }
+    finally {
+        fs_1.default.closeSync(descriptor);
+    }
+    const parsed = (0, json_1.parseJsonNoDuplicate)(body);
+    if (!(0, requests_1.isWellFormedEnvelope)(parsed) || parsed.requestId !== requestId)
+        throw new Error('request de recovery tiene envelope invalido');
+    return parsed;
+}
+function taskId(envelope) {
+    if (envelope.kind !== 'register-entity' || envelope.payload.entity !== 'task'
+        || typeof envelope.payload.taskId !== 'string' || envelope.payload.taskId.length === 0) {
+        throw new Error('recovery solo admite register-entity task con taskId');
+    }
+    return envelope.payload.taskId;
+}
+function mayResume(state) {
+    if (state.cycle.status !== 'BLOCKED' || state.cycle.blockedReason !== 'recovery no autorizado: hay conflictos durables de requests') {
+        throw new Error('resume requiere custodia BLOCKED por requests');
+    }
+    if ((0, types_1.activeRequestProblems)(state).length > 0)
+        throw new Error('resume requiere resolver todas las requests activas');
+}
+/** Offline recovery lane: no supervisor or controller may own this journal.
+ * The correction and its audit link are published in one state transaction. */
+function recoverRejectedTask(repoRoot, branch, input) {
+    if (typeof repoRoot !== 'string' || !path_1.default.isAbsolute(repoRoot) || typeof branch !== 'string' || branch.length === 0
+        || !input || typeof input !== 'object' || typeof input.generationToken !== 'string' || input.generationToken.length === 0
+        || typeof input.reason !== 'string' || input.reason.trim().length === 0 || input.reason.length > 1024 || typeof input.resume !== 'boolean') {
+        throw new Error('parametros de recovery invalidos');
+    }
+    const rejectedId = validatedId(input.rejectedRequestId, '--rejected');
+    const replacementId = validatedId(input.replacementRequestId, '--replacement');
+    if (rejectedId === replacementId)
+        throw new Error('la request correctiva debe ser distinta');
+    const lock = (0, lock_1.acquireLock)(repoRoot);
+    try {
+        const read = (0, store_1.readJournal)(repoRoot, branch);
+        if (read.corrupt || !read.state || read.state.schema !== 2 || !read.state.planBinding)
+            throw new Error('recovery requiere journal schema-2 vigente');
+        const state = read.state;
+        const latest = [...state.generations].sort((a, b) => b.n - a.n)[0];
+        if (!latest || latest.token !== input.generationToken)
+            throw new Error('generation de recovery no es la vigente');
+        for (const generation of state.generations) {
+            for (const ref of [generation.processRef, generation.wrapperRef]) {
+                if (ref && (0, process_1.refIsAlive)(ref))
+                    throw new Error('controller vivo: recovery requiere custodia exclusiva');
+            }
+        }
+        const dir = (0, paths_1.requestsDir)(repoRoot, branch);
+        const originalFile = path_1.default.join(dir, `${rejectedId}.json`);
+        const problem = state.requestProblems.find(item => item.kind === 'rejected' && item.file === originalFile);
+        if (!problem)
+            throw new Error('rechazo durable no encontrado');
+        if (problem.resolution) {
+            if (problem.resolution.replacementRequestId !== replacementId || problem.resolution.generationToken !== input.generationToken || problem.resolution.reason !== input.reason
+                || (0, types_1.activeRequestProblems)(state).includes(problem))
+                throw new Error('recovery previo incompatible');
+            if (input.resume && state.cycle.status === 'BLOCKED') {
+                const candidate = structuredClone(state);
+                mayResume(candidate);
+                candidate.custodyDecisions ??= [];
+                candidate.custodyDecisions.push({ at: new Date().toISOString(), decision: 'resume', reason: input.reason, generationToken: input.generationToken });
+                candidate.cycle.status = 'IN_PROGRESS';
+                candidate.cycle.blockedReason = undefined;
+                for (const generation of candidate.generations)
+                    if (generation.state === 'active' || generation.state === 'controller-suspected-stall')
+                        generation.state = 'superseded';
+                (0, store_1.writeJournal)(repoRoot, branch, candidate);
+            }
+            return;
+        }
+        const original = requestEnvelope(`${originalFile}.rejected`, rejectedId);
+        const replacementFile = path_1.default.join(dir, `${replacementId}.json`);
+        const replacement = requestEnvelope(replacementFile, replacementId);
+        if (original.generationToken !== input.generationToken || replacement.generationToken !== input.generationToken || taskId(original) !== taskId(replacement)) {
+            throw new Error('request correctiva no enlaza el mismo taskId o generation');
+        }
+        if (state.tasks.some(task => task.id === taskId(original)))
+            throw new Error('task ya existente: recovery requiere un registro rechazado sin aplicar');
+        if (state.appliedRequests[replacementId] !== undefined || Object.values(state.appliedRequests).some(item => item.idempotencyKey === replacement.idempotencyKey && item.payloadDigest !== (0, requests_1.digestOf)(replacement.payload))) {
+            throw new Error('request correctiva ya tiene outcome o idempotencyKey conflictiva');
+        }
+        const candidate = structuredClone(state);
+        (0, apply_1.applyRequestToState)(candidate, replacement, (0, requests_1.digestOf)(replacement.payload), repoRoot);
+        if (candidate.appliedRequests[replacementId]?.outcome !== 'applied' || !candidate.tasks.some(task => task.id === taskId(replacement))) {
+            throw new Error('request correctiva no fue aplicada');
+        }
+        const target = candidate.requestProblems.find(item => item.kind === 'rejected' && item.file === originalFile);
+        target.requestId = rejectedId;
+        target.taskId = taskId(original);
+        target.generationToken = original.generationToken;
+        target.resolution = { replacementRequestId: replacementId, replacementPayloadDigest: (0, requests_1.digestOf)(replacement.payload), reason: input.reason,
+            generationToken: input.generationToken, at: new Date().toISOString() };
+        if (input.resume) {
+            mayResume(candidate);
+            candidate.custodyDecisions ??= [];
+            candidate.custodyDecisions.push({ at: new Date().toISOString(), decision: 'resume', reason: input.reason, generationToken: input.generationToken });
+            candidate.cycle.status = 'IN_PROGRESS';
+            candidate.cycle.blockedReason = undefined;
+            for (const generation of candidate.generations)
+                if (generation.state === 'active' || generation.state === 'controller-suspected-stall')
+                    generation.state = 'superseded';
+        }
+        (0, store_1.writeJournal)(repoRoot, branch, candidate);
+        fs_1.default.rmSync(replacementFile);
+        (0, atomic_file_1.fsyncDirSync)(dir);
+        (0, store_1.appendEvent)(repoRoot, branch, { kind: 'request-recovered', rejectedRequestId: rejectedId, replacementRequestId: replacementId, generationToken: input.generationToken, resumed: input.resume });
+    }
+    finally {
+        (0, lock_1.releaseLock)(repoRoot, lock);
+    }
+}

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

@@ -4,6 +4,7 @@ exports.Supervisor = exports.MAX_SENSOR_DEFERRALS = exports.DEFAULT_SUPERVISOR_C
 exports.routingFacts = routingFacts;
 exports.defaultDispatchAdmission = defaultDispatchAdmission;
 exports.admissionForConfig = admissionForConfig;
+exports.recoveryWhitelistBlocker = recoveryWhitelistBlocker;
 exports.runSupervisorLoop = runSupervisorLoop;
 // Loop foreground (R4.4/R4.5): tick = apply -> collect/spawn -> stall -> gate.
 // COMPLETE exige gate verde (que exige cero vivos): drenaje ANTES de declarar.
@@ -27,6 +28,7 @@ const apply_1 = require("./apply");
 const runner_1 = require("./runner");
 const tracks_1 = require("./tracks");
 const generations_1 = require("./generations");
+const types_1 = require("../../core/journal/types");
 /** #166: compact v2 admission requires the runtime identity, and the supervisor
  *  never supplied it — so `awm watch` blocked on every tick with
  *  ADMISSION_ROUTING_FACTS_REQUIRED even with every other gate green.
@@ -201,9 +203,11 @@ function admissionForConfig(repoRoot, branch, cfg, deps = {}) {
 exports.MAX_SENSOR_DEFERRALS = 3;
 const LIVE = ['received', 'spawn-intent', 'claimed', 'running', 'cancel-requested'];
 function recoveryWhitelistBlocker(state) {
-    if (state.cycle.status === 'BLOCKED')
-        return 'el ciclo está bloqueado';
-    if (state.requestProblems.length > 0)
+    if (state.cycle.status === 'BLOCKED') {
+        return state.cycle.blockedReason === 'recovery no autorizado: hay conflictos durables de requests'
+            ? 'hay conflictos durables de requests' : 'el ciclo está bloqueado';
+    }
+    if ((0, types_1.activeRequestProblems)(state).length > 0)
         return 'hay conflictos durables de requests';
     // Pending work is the normal reason to launch (or retry launching) the
     // controller.  It is not recovery evidence and therefore cannot turn a

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.digestOf = digestOf;
 exports.emitRequest = emitRequest;
+exports.isWellFormedEnvelope = isWellFormedEnvelope;
 exports.listPendingRequests = listPendingRequests;
 exports.applyOutcome = applyOutcome;
 exports.ackFor = ackFor;

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

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GENERATION_STATES = exports.EXECUTION_STATES = void 0;
+exports.activeRequestProblems = activeRequestProblems;
 exports.isControllerRecoveryAction = isControllerRecoveryAction;
 exports.emptyState = emptyState;
 exports.isWellFormedState = isWellFormedState;
@@ -14,6 +15,7 @@ exports.isRoutingEnvelope = isRoutingEnvelope;
 exports.isWellFormedProcessRef = isWellFormedProcessRef;
 exports.isWellFormedJob = isWellFormedJob;
 const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
 const types_1 = require("../tracks/types");
 const paths_1 = require("./paths");
 exports.EXECUTION_STATES = [
@@ -35,6 +37,19 @@ const COHORT_PHASES = [
 ];
 const _cohortPhasesComplete = true;
 const VERIFICATION_KINDS = ['test', 'lint', 'sensors', 'review', 'qa', 'interlock', 'track-integration'];
+function activeRequestProblems(state) {
+    return state.requestProblems.filter(problem => {
+        const resolution = problem.resolution;
+        if (!resolution || !problem.requestId || !problem.taskId || !problem.generationToken
+            || path_1.default.basename(problem.file) !== `${problem.requestId}.json`
+            || resolution.generationToken !== problem.generationToken)
+            return true;
+        const applied = state.appliedRequests[resolution.replacementRequestId];
+        return applied?.outcome !== 'applied' || applied.resultRef !== problem.taskId
+            || applied.payloadDigest !== resolution.replacementPayloadDigest
+            || !state.tasks.some(task => task.id === problem.taskId);
+    });
+}
 function isControllerRecoveryAction(x) {
     return isObj(x) && Object.keys(x).length === 2
         && x.schema === 'controller-recovery/v1'
@@ -240,7 +255,20 @@ function isRoutingEnvelope(x) { if (!isObj(x) || !Object.keys(x).every(key => ['
 function isWellFormedImplementationLineage(x) { return isObj(x) && Object.keys(x).every(key => ['id', 'obligationId', 'sliceId', 'planDigest', 'executionDigest', 'initialProfile', 'initialEffort', 'attempts'].includes(key)) && typeof x.id === 'string' && x.id.length > 0 && typeof x.obligationId === 'string' && x.obligationId.length > 0 && typeof x.sliceId === 'string' && x.sliceId.length > 0 && isDigest(x.planDigest) && isDigest(x.executionDigest) && ['mechanical', 'integration', 'judgment'].includes(String(x.initialProfile)) && ['medium', 'high', 'runtime-default'].includes(String(x.initialEffort)) && Number.isSafeInteger(x.attempts) && x.attempts >= 0 && x.attempts <= 3; }
 function isWellFormedRequestProblem(x) {
     return isObj(x) && typeof x.file === 'string' && (x.kind === 'corrupt' || x.kind === 'rejected')
-        && typeof x.detail === 'string' && typeof x.at === 'string';
+        && typeof x.detail === 'string' && typeof x.at === 'string'
+        && (x.requestId === undefined || typeof x.requestId === 'string')
+        && (x.taskId === undefined || typeof x.taskId === 'string')
+        && (x.generationToken === undefined || typeof x.generationToken === 'string')
+        && (x.resolution === undefined || (x.kind === 'rejected' && isObj(x.resolution)
+            && Object.keys(x.resolution).every(key => ['replacementRequestId', 'replacementPayloadDigest', 'reason', 'generationToken', 'at'].includes(key))
+            && typeof x.requestId === 'string' && x.requestId.length > 0
+            && typeof x.taskId === 'string' && x.taskId.length > 0
+            && typeof x.generationToken === 'string' && x.generationToken.length > 0
+            && typeof x.resolution.replacementRequestId === 'string' && x.resolution.replacementRequestId.length > 0
+            && typeof x.resolution.replacementPayloadDigest === 'string' && /^[a-f0-9]{64}$/.test(x.resolution.replacementPayloadDigest)
+            && typeof x.resolution.reason === 'string' && x.resolution.reason.trim().length > 0
+            && typeof x.resolution.generationToken === 'string' && x.resolution.generationToken.length > 0
+            && typeof x.resolution.at === 'string' && Number.isFinite(Date.parse(x.resolution.at))));
 }
 function isWellFormedCustodyDecision(x) {
     return isObj(x) && typeof x.at === 'string' && x.decision === 'resume'

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

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const store_1 = require("../../../src/core/journal/store");
+const requests_1 = require("../../../src/core/journal/requests");
+const apply_1 = require("../../../src/commands/watch/apply");
+const gate_1 = require("../../../src/commands/job/gate");
+const paths_1 = require("../../../src/core/journal/paths");
+const lock_1 = require("../../../src/commands/watch/lock");
+const request_recovery_1 = require("../../../src/commands/watch/request-recovery");
+const supervisor_1 = require("../../../src/commands/watch/supervisor");
+const archive_unused_1 = require("../../../src/commands/watch/archive-unused");
+const generations_1 = require("../../../src/commands/watch/generations");
+describe('issue #194: recovery of a rejected task request', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-recover-request-'));
+        (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'rama'], { cwd: repo });
+        (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', 'commit', '--allow-empty', '-qm', 'seed'], { cwd: repo });
+        (0, store_1.initJournal)(repo, 'rama');
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.schema = 2;
+        state.planBinding = {
+            path: 'docs/plans/cycle.md', digest: 'a'.repeat(64), schema: 'compact-slices/v1',
+            executionMode: 'desatendido', boundAt: new Date().toISOString(),
+        };
+        state.requiredVerifiers = ['test', 'sensors'];
+        state.generations.push({ n: 1, token: 'g1', state: 'active', launchedAt: new Date().toISOString() });
+        state.cycle.status = 'BLOCKED';
+        state.cycle.blockedReason = 'recovery no autorizado: hay conflictos durables de requests';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+    });
+    afterEach(() => fs_1.default.rmSync(repo, { recursive: true, force: true }));
+    function rejectedTask() {
+        const rejected = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'bad-task',
+            payload: { entity: 'task', taskId: 'S1', title: 'slice', verificationPlan: [{ id: 'test-s1', kind: 'test' }], reviewObligations: [] },
+        });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${rejected.file}.rejected`)).toBe(true);
+        expect(fs_1.default.readFileSync((0, paths_1.eventsPath)(repo, 'rama'), 'utf8')).toMatch(/request-rejected-invalid/);
+        return rejected;
+    }
+    function correctedTask(taskId = 'S1', kinds = ['test', 'sensors']) {
+        return (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: `corrected-${taskId}-${kinds.join('-')}`,
+            payload: { entity: 'task', taskId, title: 'slice', verificationPlan: kinds.map(kind => ({ id: `${kind}-${taskId}`, kind })), reviewObligations: [] },
+        });
+    }
+    test('rejection → corrected request → audited recovery → next action remains gated by real work', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        expect((0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'rama').state, false, () => null).reasons.some(reason => reason.category === 'request-problem')).toBe(true);
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', {
+            rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido plan de verificación', resume: true,
+        });
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tasks.map(task => task.id)).toEqual(['S1']);
+        expect(state.appliedRequests[replacement.requestId]).toMatchObject({ outcome: 'applied', resultRef: 'S1' });
+        expect(state.requestProblems[0]).toMatchObject({ kind: 'rejected', resolution: { replacementRequestId: replacement.requestId, generationToken: 'g1', reason: 'corregido plan de verificación' } });
+        expect(state.cycle.status).toBe('IN_PROGRESS');
+        expect(state.custodyDecisions).toEqual([expect.objectContaining({ decision: 'resume', generationToken: 'g1' })]);
+        expect(fs_1.default.existsSync(`${rejected.file}.rejected`)).toBe(true);
+        expect(fs_1.default.existsSync(replacement.file)).toBe(false);
+        expect(fs_1.default.readFileSync((0, paths_1.eventsPath)(repo, 'rama'), 'utf8')).toMatch(/request-recovered/);
+        const gate = (0, gate_1.computeGate)(state, false, () => null);
+        expect(gate.reasons.some(reason => reason.category === 'request-problem')).toBe(false);
+        expect(gate.pass).toBe(false);
+        expect(gate.reasons.some(reason => reason.category === 'pending-task')).toBe(true);
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', {
+            rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido plan de verificación', resume: true,
+        });
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(1);
+        // Crash after state publication but before queue cleanup: supervisor
+        // replay consumes the same request ID without registering S1 twice.
+        fs_1.default.writeFileSync(replacement.file, JSON.stringify({ requestId: replacement.requestId,
+            kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'corrected-S1-test-sensors',
+            payload: { entity: 'task', taskId: 'S1', title: 'slice', verificationPlan: [
+                    { id: 'test-S1', kind: 'test' }, { id: 'sensors-S1', kind: 'sensors' }
+                ], reviewObligations: [] } }));
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(1);
+    });
+    test('wrong task and still-invalid correction leave rejection active without partial writes', () => {
+        const rejected = rejectedTask();
+        const wrong = correctedTask('S2');
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId, replacementRequestId: wrong.requestId, generationToken: 'g1', reason: 'wrong task', resume: true })).toThrow(/mismo taskId/);
+        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems[0].resolution).toBeUndefined();
+        fs_1.default.rmSync(wrong.file);
+        const invalid = correctedTask('S1', ['test']);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId, replacementRequestId: invalid.requestId, generationToken: 'g1', reason: 'still invalid', resume: true })).toThrow(/sensors/);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tasks).toHaveLength(0);
+        expect(state.requestProblems[0].resolution).toBeUndefined();
+        expect(state.cycle.status).toBe('BLOCKED');
+    });
+    test('stale generation, missing archive, and live supervisor lock cannot resolve a rejection', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const input = { rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido', resume: true };
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { ...input, generationToken: 'g0' })).toThrow(/generation/);
+        const lock = (0, lock_1.acquireLock)(repo);
+        try {
+            expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', input)).toThrow(/supervisor activo/);
+        }
+        finally {
+            (0, lock_1.releaseLock)(repo, lock);
+        }
+        fs_1.default.renameSync(`${rejected.file}.rejected`, `${rejected.file}.held`);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', input)).toThrow();
+        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems[0].resolution).toBeUndefined();
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(0);
+    });
+    test('an unrelated active problem prevents --resume and leaves the correction queued', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems.push({ file: path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'other.json'), kind: 'corrupt', detail: 'bad envelope', at: new Date().toISOString() });
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId,
+            replacementRequestId: replacement.requestId, generationToken: 'g1', reason: 'corregido', resume: true })).toThrow(/todas las requests/);
+        expect(fs_1.default.existsSync(replacement.file)).toBe(true);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(0);
+    });
+    test('a resolution-shaped state without an applied replacement is still an active gate problem', () => {
+        rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems[0].resolution = { replacementRequestId: 'req-1-0000000000-deadbeef', replacementPayloadDigest: 'a'.repeat(64), reason: 'forged', generationToken: 'g1', at: new Date().toISOString() };
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'rama').state, false, () => null).reasons.some(reason => reason.category === 'request-problem')).toBe(true);
+    });
+    test('an unrelated applied task cannot be cited as the replacement of S1', () => {
+        rejectedTask();
+        const unrelated = correctedTask('S2');
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems[0].resolution = { replacementRequestId: unrelated.requestId, replacementPayloadDigest: state.appliedRequests[unrelated.requestId].payloadDigest, reason: 'wrong link', generationToken: 'g1', at: new Date().toISOString() };
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, gate_1.computeGate)((0, store_1.readJournal)(repo, 'rama').state, false, () => null).reasons.some(reason => reason.category === 'request-problem')).toBe(true);
+    });
+    test('a corrupt request cannot be laundered through a task-shaped resolution', () => {
+        const replacement = correctedTask('S1');
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.requestProblems.push({ file: path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'req-1-0000000000-deadbeef.json'),
+            kind: 'corrupt', detail: 'bad JSON', at: new Date().toISOString(), requestId: 'req-1-0000000000-deadbeef',
+            taskId: 'S1', generationToken: 'g1', resolution: { replacementRequestId: replacement.requestId,
+                replacementPayloadDigest: state.appliedRequests[replacement.requestId].payloadDigest,
+                reason: 'forged', generationToken: 'g1', at: new Date().toISOString() } });
+        expect(() => (0, store_1.writeJournal)(repo, 'rama', state)).toThrow(/forma invalida/);
+    });
+    test('resume rejects a different custody cause even if its text mentions requests', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.cycle.blockedReason = 'other failure; also mentions conflictos durables de requests';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId,
+            replacementRequestId: replacement.requestId, generationToken: 'g1', reason: 'corrected', resume: true })).toThrow(/custodia BLOCKED por requests/);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tasks).toHaveLength(0);
+    });
+    test('a blocked request remains the specific custody cause across supervisor ticks', () => {
+        rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect((0, supervisor_1.recoveryWhitelistBlocker)(state)).toBe('hay conflictos durables de requests');
+    });
+    test('an independent custody cause is never overwritten by an active request problem', () => {
+        rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.cycle.blockedReason = 'veredicto de sensores no concluyente';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, supervisor_1.recoveryWhitelistBlocker)((0, store_1.readJournal)(repo, 'rama').state)).toBe('el ciclo está bloqueado');
+    });
+    test('public journal status exposes the latest generation token after supervisor shutdown', () => {
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.generations[0].state = 'terminated';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect((0, archive_unused_1.watchJournalStatus)(repo, 'rama')).toMatchObject({ latestGeneration: { n: 1, token: 'g1', state: 'terminated' } });
+    });
+    test('recovery without resume remains eligible for a later explicit resume', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const input = { rejectedRequestId: rejected.requestId, replacementRequestId: replacement.requestId,
+            generationToken: 'g1', reason: 'corregido', resume: false };
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', input);
+        const blocker = (0, supervisor_1.recoveryWhitelistBlocker)((0, store_1.readJournal)(repo, 'rama').state);
+        (0, generations_1.enterCustody)(repo, 'rama', `recovery no autorizado: ${blocker}`);
+        (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { ...input, resume: true });
+        expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('IN_PROGRESS');
+    });
+    test('a correction from a newer generation cannot silently resolve the archived rejection', () => {
+        const rejected = rejectedTask();
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.generations[0].state = 'superseded';
+        state.generations.push({ n: 2, token: 'g2', state: 'active', launchedAt: new Date().toISOString() });
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        const replacement = (0, requests_1.emitRequest)(repo, 'rama', { kind: 'register-entity', generationToken: 'g2', idempotencyKey: 'corrected-g2',
+            payload: { entity: 'task', taskId: 'S1', verificationPlan: [{ id: 't2', kind: 'test' }, { id: 's2', kind: 'sensors' }], reviewObligations: [] } });
+        expect(() => (0, request_recovery_1.recoverRejectedTask)(repo, 'rama', { rejectedRequestId: rejected.requestId,
+            replacementRequestId: replacement.requestId, generationToken: 'g2', reason: 'different generation', resume: true })).toThrow(/generation/);
+        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems[0].resolution).toBeUndefined();
+    });
+    test('public watch recover-request command applies the correction under custody', () => {
+        const rejected = rejectedTask();
+        const replacement = correctedTask();
+        const cli = path_1.default.resolve(__dirname, '../../../src/index.ts');
+        const tsNode = require.resolve('ts-node/dist/bin.js');
+        const output = (0, child_process_1.execFileSync)(process.execPath, [tsNode, '--compiler-options', '{"module":"CommonJS"}', cli, 'watch', 'recover-request',
+            '--rejected', rejected.requestId, '--replacement', replacement.requestId,
+            '--generation', 'g1', '--reason', 'operador verificó reemplazo', '--resume'], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        expect(JSON.parse(output)).toMatchObject({ recovered: true, replacementRequestId: replacement.requestId });
+        expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('IN_PROGRESS');
+    });
+    test('job register rejects missing sensors before writing a request file', () => {
+        const cli = path_1.default.resolve(__dirname, '../../../src/index.ts');
+        const tsNode = require.resolve('ts-node/dist/bin.js');
+        const payload = JSON.stringify({ taskId: 'S1', verificationPlan: [{ id: 't1', kind: 'test' }], reviewObligations: [] });
+        let diagnostic = '';
+        try {
+            (0, child_process_1.execFileSync)(process.execPath, [tsNode, '--compiler-options', '{"module":"CommonJS"}', cli,
+                'job', 'register', '--generation', 'g1', '--entity', 'task', '--json', payload], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (error) {
+            diagnostic = String(error.stderr ?? '');
+        }
+        expect(diagnostic).toMatch(/verificationPlan.*sensors/);
+        expect(fs_1.default.readdirSync((0, paths_1.requestsDir)(repo, 'rama')).filter(name => name.endsWith('.json'))).toHaveLength(0);
+    });
+    test('JSON cannot override --entity to bypass task prevalidation', () => {
+        const cli = path_1.default.resolve(__dirname, '../../../src/index.ts');
+        const tsNode = require.resolve('ts-node/dist/bin.js');
+        const payload = JSON.stringify({ entity: 'task', taskId: 'S1', verificationPlan: [{ id: 't1', kind: 'test' }], reviewObligations: [] });
+        let diagnostic = '';
+        try {
+            (0, child_process_1.execFileSync)(process.execPath, [tsNode, '--compiler-options', '{"module":"CommonJS"}', cli,
+                'job', 'register', '--generation', 'g1', '--entity', 'cycle-plan', '--json', payload], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (error) {
+            diagnostic = String(error.stderr ?? '');
+        }
+        expect(diagnostic).toMatch(/entity.*coincidir/);
+        expect(fs_1.default.readdirSync((0, paths_1.requestsDir)(repo, 'rama')).filter(name => name.endsWith('.json'))).toHaveLength(0);
+    });
+});

package/package.json

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