agentic-workflow-manager 9.12.1 → 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/admission-recovery.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverAdmissionCustody = recoverAdmissionCustody;
+const path_1 = __importDefault(require("path"));
+const validate_1 = require("../../core/plan/validate");
+const capabilities_1 = require("../../core/model-policy/capabilities");
+const event_store_1 = require("../../core/model-policy/event-store");
+const local_event_scope_1 = require("../../core/model-policy/local-event-scope");
+const store_1 = require("../../core/journal/store");
+const types_1 = require("../../core/journal/types");
+const process_1 = require("../../core/journal/process");
+const adapter_1 = require("../../core/journal/adapter");
+const generations_1 = require("./generations");
+const lock_1 = require("./lock");
+const supervisor_1 = require("./supervisor");
+function contextFor(input) {
+    if (!(0, adapter_1.isWatchProvider)(input.provider))
+        throw new Error('provider de recovery invalido');
+    if (!(0, adapter_1.isControllerAutonomy)(input.controllerAutonomy))
+        throw new Error('postura del controller invalida');
+    if (!input.routingIdentity)
+        throw new Error('runtime de recovery requerido');
+    const runtime = (0, capabilities_1.validateRuntimeKey)({ target: input.provider, ...input.routingIdentity });
+    return { provider: input.provider, runtime: { kind: runtime.kind, version: runtime.version, accountScopeDigest: runtime.accountScopeDigest }, controllerAutonomy: input.controllerAutonomy };
+}
+function sameContext(a, b) {
+    return a.provider === b.provider && a.controllerAutonomy === b.controllerAutonomy
+        && a.runtime?.kind === b.runtime?.kind && a.runtime?.version === b.runtime?.version
+        && a.runtime?.accountScopeDigest === b.runtime?.accountScopeDigest;
+}
+function admissionCustodyCause(reason) {
+    if (!reason || (reason.match(/ADMISSION_[A-Z_]+/g) ?? []).length !== 1)
+        return undefined;
+    const old = reason.startsWith('admisión compacta desatendida bloqueada antes de dispatch: ');
+    if ((old || reason.startsWith('admisión currentness no verificable tras 3 reintentos: '))
+        && reason.includes('ADMISSION_CURRENTNESS_BLOCKED:'))
+        return 'currentness';
+    if ((old || reason.startsWith('admisión sensors no verificable tras 3 reintentos: '))
+        && reason.includes('ADMISSION_SENSORS_BLOCKED:'))
+        return 'sensors';
+    return undefined;
+}
+function assertNoAmbiguousWork(repoRoot, branch, state) {
+    if ((0, types_1.activeRequestProblems)(state).length > 0)
+        throw new Error('recovery bloqueado: request rechazada o corrupta activa');
+    for (const generation of state.generations) {
+        if ((0, generations_1.controllerGenerationHasUnresolvedClaim)(repoRoot, branch, generation))
+            throw new Error('recovery bloqueado: claim de controller sin identidad demostrable');
+        for (const ref of [generation.processRef, generation.wrapperRef]) {
+            if (ref && ((0, process_1.refIsAlive)(ref) || !(0, process_1.groupIsGone)(ref.processGroup)))
+                throw new Error('recovery bloqueado: controller vivo o ambiguo');
+        }
+    }
+    for (const job of Object.values(state.jobs)) {
+        if (!['exited', 'cancelled'].includes(job.executionState))
+            throw new Error(`recovery bloqueado: job ${job.id} activo o ambiguo`);
+        for (const ref of [job.processRef, job.wrapperRef]) {
+            if (ref && ((0, process_1.refIsAlive)(ref) || !(0, process_1.groupIsGone)(ref.processGroup)))
+                throw new Error(`recovery bloqueado: job ${job.id} vivo o ambiguo`);
+        }
+    }
+}
+/** Explicit offline transition. The journal record is the authoritative audit;
+ * the event is supplementary, so retry after a crash cannot duplicate the
+ * state transition or silently discard the original custody reason. */
+async function recoverAdmissionCustody(repoRoot, branch, input, dispatchAdmission) {
+    if (typeof repoRoot !== 'string' || !path_1.default.isAbsolute(repoRoot) || typeof branch !== 'string' || branch.length === 0
+        || !input || typeof input !== 'object' || typeof input.reason !== 'string'
+        || input.reason.trim().length === 0 || input.reason.length > 1024
+        || (input.generationToken !== undefined && (typeof input.generationToken !== 'string' || input.generationToken.length === 0))) {
+        throw new Error('parametros de recovery invalidos');
+    }
+    const context = contextFor(input);
+    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;
+        (0, lock_1.verifyBranchInvariant)(repoRoot, state.branch);
+        const previous = state.admissionRecoveries?.at(-1);
+        if (state.cycle.status === 'IN_PROGRESS' && previous
+            && previous.reason === input.reason && previous.generationToken === input.generationToken
+            && sameContext(previous.context, context))
+            return 'already-recovered';
+        if (state.cycle.status !== 'BLOCKED' || !admissionCustodyCause(state.cycle.blockedReason)) {
+            throw new Error('recovery solo admite custodia causada por admisión currentness o sensores');
+        }
+        const latest = state.generations.at(-1);
+        if (latest?.token !== input.generationToken || (latest === undefined && input.generationToken !== undefined)) {
+            throw new Error('generation de recovery no es la vigente');
+        }
+        if (latest?.provider && latest.provider !== context.provider)
+            throw new Error('provider de generation no coincide con identidad de recovery');
+        if (state.admissionContext && !sameContext(state.admissionContext, context))
+            throw new Error('identidad de runtime o postura no coincide con la admisión original');
+        assertNoAmbiguousWork(repoRoot, branch, state);
+        const prospective = structuredClone(state);
+        prospective.cycle.status = 'IN_PROGRESS';
+        prospective.cycle.blockedReason = undefined;
+        const independentBlocker = (0, supervisor_1.recoveryWhitelistBlocker)(prospective);
+        if (independentBlocker)
+            throw new Error(`recovery bloqueado por causa independiente: ${independentBlocker}`);
+        const binding = state.planBinding;
+        if (!binding)
+            throw new Error('binding del plan ausente');
+        const plan = (0, validate_1.validatePlanFile)(binding.path, repoRoot);
+        if (plan.state !== 'valid' || plan.planDigest !== binding.digest || plan.schema !== binding.schema
+            || (binding.executionDigest !== undefined && plan.executionDigest !== binding.executionDigest)) {
+            throw new Error('binding del plan alterado: recovery denegado');
+        }
+        // A v1 plan does not ask the admission engine to evaluate routing.
+        // Recovery still promises a current native receipt for the asserted
+        // provider/runtime, so check its machine seal and live local scope
+        // explicitly; an operator assertion alone is not evidence.
+        const runtime = (0, capabilities_1.validateRuntimeKey)({ target: context.provider, ...context.runtime });
+        const stored = (0, event_store_1.readStoredEventReceipt)(runtime);
+        if (stored.state !== 'present')
+            throw new Error(`recibo nativo ausente o invalido para ${context.provider}: ejecuta awm model-policy setup --provider ${context.provider}`);
+        const local = await (0, local_event_scope_1.queryLocalEventScope)(repoRoot, context.provider, runtime.kind);
+        if (local.state !== 'current' || local.scope.runtime.target !== runtime.target
+            || local.scope.runtime.kind !== runtime.kind || local.scope.runtime.version !== runtime.version
+            || local.scope.runtime.accountScopeDigest !== runtime.accountScopeDigest
+            || stored.receipt.runtime.target !== runtime.target || stored.receipt.runtime.kind !== runtime.kind
+            || stored.receipt.runtime.version !== runtime.version || stored.receipt.runtime.accountScopeDigest !== runtime.accountScopeDigest
+            || stored.receipt.binaryDigest !== local.scope.binaryDigest || stored.receipt.configDigest !== local.scope.configDigest
+            || Date.parse(stored.receipt.recordedAt) > Date.now()) {
+            throw new Error(`recibo nativo no coincide con runtime/cuenta local de ${context.provider}`);
+        }
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: context.provider,
+            routingIdentity: context.runtime, controllerAutonomy: context.controllerAutonomy };
+        const report = await (dispatchAdmission ?? (0, supervisor_1.admissionForConfig)(repoRoot, branch, cfg))();
+        if (report.state !== 'admitted' || report.planState !== 'valid' || report.executionMode !== 'desatendido'
+            || report.journal !== 'current' || report.currentness !== 'current' || report.sensors !== 'pass'
+            || (report.planDigest !== undefined && report.planDigest !== binding.digest)) {
+            throw new Error(`admisión estricta todavía bloqueada: ${report.diagnostics.map(item => `${item.code}: ${item.message}`).join('; ')}`);
+        }
+        const candidate = structuredClone(state);
+        candidate.admissionRecoveries ??= [];
+        candidate.admissionRecoveries.push({ at: new Date().toISOString(), reason: input.reason,
+            blockedReason: state.cycle.blockedReason, generationToken: input.generationToken,
+            context, planDigest: binding.digest,
+            assertion: state.admissionContext ? 'recorded' : 'legacy-operator-asserted' });
+        candidate.admissionContext = context;
+        candidate.admissionRetry = undefined;
+        candidate.cycle.status = 'IN_PROGRESS';
+        candidate.cycle.blockedReason = undefined;
+        // Existing generations and nextAction remain untouched. The next watch
+        // tick performs strict admission again before reconciling either.
+        (0, store_1.writeJournal)(repoRoot, branch, candidate);
+        (0, store_1.appendEvent)(repoRoot, branch, { kind: 'admission-recovered', generationToken: input.generationToken,
+            reason: input.reason, blockedReason: state.cycle.blockedReason, planDigest: binding.digest });
+        return 'recovered';
+    }
+    finally {
+        (0, lock_1.releaseLock)(repoRoot, lock);
+    }
+}

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

@@ -7,6 +7,7 @@ exports.registerWatchCommand = registerWatchCommand;
 const child_process_1 = require("child_process");
 const init_1 = require("./init");
 const request_recovery_1 = require("./request-recovery");
+const admission_recovery_1 = require("./admission-recovery");
 const supervisor_1 = require("./supervisor");
 const capabilities_1 = require("../../core/model-policy/capabilities");
 const adapter_1 = require("../../core/journal/adapter");
@@ -142,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')
@@ -168,6 +179,36 @@ function registerWatchCommand(program) {
             process.exitCode = 1;
         }
     });
+    watch.command('recover-admission')
+        .description('reanuda offline una custodia por admisión tras una nueva comprobación estricta')
+        .option('--generation <token>', 'token de la ultima generacion; omitir solo si no existe')
+        .requiredOption('--reason <text>', 'motivo explícito de la decisión del operador')
+        .action(async (opts, command) => {
+        const repo = process.cwd();
+        try {
+            const branch = currentBranch(repo);
+            (0, context_1.resolveCommandContext)(repo, branch);
+            const parent = command.parent?.opts() ?? {};
+            if (command.parent?.getOptionValueSource('provider') !== 'cli')
+                throw new Error('recover-admission requiere --provider explícito');
+            if (!(0, adapter_1.isControllerAutonomy)(parent.controllerAutonomy))
+                throw new Error('recover-admission requiere --controller-autonomy valido');
+            if (parent.runtimeKind === undefined || parent.runtimeVersion === undefined || parent.accountScopeDigest === undefined) {
+                throw new Error('recover-admission requiere --runtime-kind, --runtime-version y --account-scope-digest');
+            }
+            const outcome = await (0, admission_recovery_1.recoverAdmissionCustody)(repo, branch, {
+                provider: parent.provider,
+                routingIdentity: { kind: parent.runtimeKind, version: parent.runtimeVersion, accountScopeDigest: parent.accountScopeDigest },
+                controllerAutonomy: parent.controllerAutonomy,
+                generationToken: opts.generation, reason: opts.reason,
+            });
+            process.stdout.write(JSON.stringify({ recovered: true, outcome, generationToken: opts.generation ?? null }) + '\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')