agentic-workflow-manager 3.4.0 → 3.6.0

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

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digestOf = digestOf;
+exports.emitRequest = emitRequest;
+exports.listPendingRequests = listPendingRequests;
+exports.applyOutcome = applyOutcome;
+exports.ackFor = ackFor;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const paths_1 = require("./paths");
+const redact_1 = require("./redact");
+const atomic_file_1 = require("../atomic-file");
+function digestOf(payload) {
+    return crypto_1.default.createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+}
+function countPendingRequests(dir) {
+    try {
+        return fs_1.default.readdirSync(dir).filter((f) => f.endsWith('.json')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Publicacion atomica Y durable (R1.3, bloqueador 4): tmp + fsync + close +
+ *  rename + fsync del DIRECTORIO. Redaccion EN EL EMISOR; secreto literal en
+ *  flag sensible => rechazo sin persistir (R2.3). El segmento `seq` es un
+ *  conteo del directorio de requests AL MOMENTO DE EMITIR (no un contador
+ *  en memoria del proceso): las emisiones causalmente dependientes son, por
+ *  definicion, secuenciales desde la perspectiva del emisor (el agente
+ *  orquestador espera a que el proceso A termine — incluyendo su
+ *  fsyncDirSync — antes de lanzar el proceso B), asi que el archivo de A ya
+ *  esta durablemente presente cuando B escanea el directorio. Esto preserva
+ *  el orden causal AUN ENTRE PROCESOS SEPARADOS, a diferencia de un
+ *  contador en memoria por proceso (que reinicia en 0 en cada invocacion
+ *  nueva de la CLI). Emisores genuinamente independientes/concurrentes
+ *  pueden empatar en el conteo y caer al sufijo hex aleatorio — aceptable,
+ *  porque requests independientes no requieren orden relativo. */
+function emitRequest(repoRoot, branch, env) {
+    const payload = { ...env.payload };
+    if (Array.isArray(payload.argv)) {
+        const secretFlag = (0, redact_1.findLiteralSecretFlag)(payload.argv);
+        if (secretFlag !== null)
+            throw new Error(`secreto literal en ${secretFlag}: pasalo por referencia (-env), no por valor`);
+        payload.argv = (0, redact_1.redactArgv)(payload.argv);
+    }
+    const dir = (0, paths_1.requestsDir)(repoRoot, branch);
+    const seq = countPendingRequests(dir).toString().padStart(10, '0');
+    const requestId = `req-${Date.now()}-${seq}-${crypto_1.default.randomBytes(4).toString('hex')}`;
+    const body = JSON.stringify({ requestId, ...env, payload }, null, 2) + '\n';
+    const tmp = path_1.default.join(dir, `.${requestId}.tmp`);
+    const final = path_1.default.join(dir, `${requestId}.json`);
+    const fd = fs_1.default.openSync(tmp, 'wx', 0o600);
+    try {
+        fs_1.default.writeFileSync(fd, body);
+        fs_1.default.fsyncSync(fd);
+    }
+    finally {
+        fs_1.default.closeSync(fd);
+    }
+    fs_1.default.renameSync(tmp, final);
+    (0, atomic_file_1.fsyncDirSync)(dir); // la ENTRADA renombrada tambien debe sobrevivir un crash (R1.3)
+    return { requestId, idempotencyKey: env.idempotencyKey, payloadDigest: digestOf(payload), file: final };
+}
+const KNOWN_KINDS = ['job-request', 'register-entity', 'controller-heartbeat', 'verdict'];
+function isRecord(x) {
+    return typeof x === 'object' && x !== null && !Array.isArray(x);
+}
+function isWellFormedEnvelope(x) {
+    if (!isRecord(x))
+        return false;
+    return typeof x.requestId === 'string' && x.requestId.length > 0
+        && KNOWN_KINDS.includes(x.kind)
+        && typeof x.generationToken === 'string' && x.generationToken.length > 0
+        && typeof x.idempotencyKey === 'string' && x.idempotencyKey.length > 0
+        && isRecord(x.payload);
+}
+function listPendingRequests(repoRoot, branch) {
+    const dir = (0, paths_1.requestsDir)(repoRoot, branch);
+    return fs_1.default.readdirSync(dir).filter((f) => f.endsWith('.json')).sort().map((f) => {
+        const file = path_1.default.join(dir, f);
+        try {
+            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
+            // tambien son corrupcion visible, no una excepcion del supervisor.
+            if (!isWellFormedEnvelope(parsed)) {
+                return { requestId: f, envelope: null, file, corrupt: true };
+            }
+            if (f !== `${parsed.requestId}.json`) {
+                return { requestId: f, envelope: null, file, corrupt: true };
+            }
+            return { requestId: parsed.requestId, envelope: parsed, file, corrupt: false };
+        }
+        catch {
+            return { requestId: f, envelope: null, file, corrupt: true };
+        }
+    });
+}
+/** Registro del resultado en el state (el ack es derivable — R1.3).
+ *  - mismo requestId ya registrado => no-op (replay seguro);
+ *  - misma idempotencyKey con digest DISTINTO => error explicito;
+ *  - misma idempotencyKey con mismo digest => ALIAS: el requestId nuevo
+ *    registra SU PROPIA entrada con el mismo outcome/resultRef, para poder
+ *    regenerar su ack (bloqueador 4 de la review).
+ *  Devuelve el state mutado (el caller es el supervisor, que luego hace
+ *  writeJournal — orden estado -> journal -> borrado de archivos). */
+function applyOutcome(state, applied) {
+    if (state.appliedRequests[applied.requestId] !== undefined)
+        return state;
+    const prior = Object.values(state.appliedRequests).find((a) => a.idempotencyKey === applied.idempotencyKey);
+    if (prior !== undefined && prior.payloadDigest !== applied.payloadDigest) {
+        if (applied.outcome === 'applied') {
+            throw new Error(`idempotencyKey ${applied.idempotencyKey} reutilizada con payload digest distinto`);
+        }
+        // outcome de rechazo: ninguna mutacion ocurrio, seguro registrar aun con digest distinto
+        state.appliedRequests[applied.requestId] = applied;
+        return state;
+    }
+    if (prior !== undefined) {
+        state.appliedRequests[applied.requestId] = { ...applied, outcome: prior.outcome, resultRef: prior.resultRef };
+        return state;
+    }
+    state.appliedRequests[applied.requestId] = applied;
+    return state;
+}
+function ackFor(state, requestId) {
+    return state.appliedRequests[requestId] ?? null;
+}

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

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initJournal = initJournal;
+exports.readJournal = readJournal;
+exports.writeJournal = writeJournal;
+exports.appendEvent = appendEvent;
+const fs_1 = __importDefault(require("fs"));
+const atomic_file_1 = require("../atomic-file");
+const types_1 = require("./types");
+const paths_1 = require("./paths");
+/** Schema 1 evoluciono de forma aditiva durante R1. Normalizamos solamente
+ * campos que antes no existian; evidencia legacy queda deliberadamente con
+ * fingerprint vacio para que el gate la considere stale, nunca certificada. */
+function normalizeSchemaOne(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return value;
+    const parsed = structuredClone(value);
+    if (parsed.schema !== 1)
+        return parsed;
+    if (parsed.requestProblems === undefined)
+        parsed.requestProblems = [];
+    if (parsed.custodyDecisions === undefined)
+        parsed.custodyDecisions = [];
+    if (typeof parsed.cycle === 'object' && parsed.cycle !== null && !Array.isArray(parsed.cycle)) {
+        const cycle = parsed.cycle;
+        if (cycle.status === 'IN_PROGRESS' && cycle.nextAction === undefined) {
+            cycle.nextAction = { actionId: 'bootstrap-cycle', type: 'plan-cycle', target: 'cycle', preconditions: [], attempt: 0, state: 'pending' };
+        }
+    }
+    if (Array.isArray(parsed.verdicts)) {
+        for (const item of parsed.verdicts) {
+            if (typeof item !== 'object' || item === null || Array.isArray(item))
+                continue;
+            const verdict = item;
+            if (verdict.fingerprint === undefined)
+                verdict.fingerprint = '';
+            if (verdict.argv === undefined)
+                verdict.argv = [];
+            if (verdict.paths === undefined)
+                verdict.paths = [];
+            if (verdict.cwd === undefined)
+                verdict.cwd = '.';
+        }
+    }
+    return parsed;
+}
+function initJournal(repoRoot, branch) {
+    for (const d of [(0, paths_1.journalDir)(repoRoot, branch), (0, paths_1.requestsDir)(repoRoot, branch), (0, paths_1.acksDir)(repoRoot, branch), (0, paths_1.logsDir)(repoRoot, branch), (0, paths_1.exportDir)(repoRoot, branch)]) {
+        fs_1.default.mkdirSync(d, { recursive: true, mode: 0o700 });
+        fs_1.default.chmodSync(d, 0o700); // mkdirSync mode es umask-dependiente: fijar explicito (R1.2)
+    }
+    const sp = (0, paths_1.statePath)(repoRoot, branch);
+    if (!fs_1.default.existsSync(sp)) {
+        (0, atomic_file_1.writeFileAtomicDurable)(sp, JSON.stringify((0, types_1.emptyState)(branch), null, 2) + '\n', 0o600);
+    }
+}
+/** Lectura corrupt-aware (R1.6): sintaxis invalida O shape invalido => corrupt:true.
+ *  Los CONSUMIDORES deciden: consultas muestran 'corrupt'; gate/reconcile bloquean. */
+function readJournal(repoRoot, branch) {
+    const sp = (0, paths_1.statePath)(repoRoot, branch);
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(sp, 'utf8');
+    }
+    catch {
+        return { state: null, corrupt: true };
+    }
+    let parsed;
+    try {
+        parsed = normalizeSchemaOne(JSON.parse(raw));
+    }
+    catch {
+        return { state: null, corrupt: true, raw };
+    }
+    if (!(0, types_1.isWellFormedState)(parsed))
+        return { state: null, corrupt: true, raw };
+    return { state: parsed, corrupt: false, raw };
+}
+/** Escritura canonica: SOLO el supervisor la invoca (single-writer). CAS por
+ *  revision monotonica: el snapshot que traes debe ser el vigente. */
+function writeJournal(repoRoot, branch, state) {
+    if (state.branch !== branch)
+        throw new Error(`writeJournal: branch del estado (${state.branch}) no coincide con branch destino (${branch})`);
+    const current = readJournal(repoRoot, branch);
+    if (current.corrupt)
+        throw new Error('journal corrupto: no se escribe sobre corrupcion (R1.6)');
+    if (current.state !== null && current.state.revision !== state.revision) {
+        throw new Error(`revision desactualizada: disco=${current.state.revision} propuesta=${state.revision}`);
+    }
+    const next = { ...state, revision: state.revision + 1 };
+    if (!(0, types_1.isWellFormedState)(next))
+        throw new Error('writeJournal: estado propuesto con forma invalida, no se persiste (R1.6)');
+    (0, atomic_file_1.writeFileAtomicDurable)((0, paths_1.statePath)(repoRoot, branch), JSON.stringify(next, null, 2) + '\n', 0o600);
+}
+/** Auditoria derivada best-effort (R4.6): la escribe SOLO el supervisor, un
+ *  fallo aqui jamas invalida el estado — state.json es la unica autoridad. */
+function appendEvent(repoRoot, branch, event) {
+    try {
+        fs_1.default.appendFileSync((0, paths_1.eventsPath)(repoRoot, branch), JSON.stringify({ at: new Date().toISOString(), ...event }) + '\n', { mode: 0o600 });
+    }
+    catch {
+        // best-effort: un evento perdido no se reconstruye ni bloquea (R4.6)
+    }
+}

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

@@ -0,0 +1,165 @@
+"use strict";
+// Única fuente de tipos del journal. CONSTITUTION: estados separados, nunca
+// sobrecargados; shape validation antes de usar campos deserializados.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATION_STATES = exports.EXECUTION_STATES = void 0;
+exports.emptyState = emptyState;
+exports.isWellFormedState = isWellFormedState;
+exports.isWellFormedProcessRef = isWellFormedProcessRef;
+exports.isWellFormedJob = isWellFormedJob;
+exports.EXECUTION_STATES = [
+    'received', 'spawn-intent', 'claimed', 'running',
+    'exited', 'cancel-requested', 'cancelled', 'orphaned',
+];
+exports.GENERATION_STATES = [
+    'active', 'controller-suspected-stall', 'terminated', 'superseded',
+];
+function emptyState(branch) {
+    return {
+        schema: 1, revision: 0, branch,
+        cycle: {
+            status: 'IN_PROGRESS', startedAt: new Date().toISOString(),
+            nextAction: { actionId: 'bootstrap-cycle', type: 'plan-cycle', target: 'cycle', preconditions: [], attempt: 0, state: 'pending' },
+        },
+        cycleVerificationPlan: [], requiredVerifiers: [], generations: [], tasks: [],
+        dispatches: [], jobs: {}, verdicts: [], fixes: [], appliedRequests: {}, requestProblems: [], custodyDecisions: [],
+    };
+}
+function isObj(x) {
+    return typeof x === 'object' && x !== null && !Array.isArray(x);
+}
+function isWellFormedState(x) {
+    if (!isObj(x))
+        return false;
+    if (x.schema !== 1)
+        return false;
+    if (typeof x.revision !== 'number')
+        return false;
+    if (typeof x.branch !== 'string')
+        return false;
+    if (!isObj(x.cycle) || !['IN_PROGRESS', 'COMPLETE', 'BLOCKED'].includes(String(x.cycle.status))
+        || typeof x.cycle.startedAt !== 'string'
+        || (x.cycle.completedAt !== undefined && typeof x.cycle.completedAt !== 'string')
+        || (x.cycle.blockedReason !== undefined && typeof x.cycle.blockedReason !== 'string')
+        || (x.cycle.nextAction !== undefined && !isWellFormedNextAction(x.cycle.nextAction))
+        || (x.cycle.status === 'IN_PROGRESS' && x.cycle.nextAction === undefined))
+        return false;
+    if (!Array.isArray(x.generations) || !Array.isArray(x.tasks))
+        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) => ['test', 'lint', 'sensors', 'review', 'qa', 'interlock'].includes(String(kind)))
+        || !Array.isArray(x.dispatches) || !x.dispatches.every(isWellFormedDispatch))
+        return false;
+    if (!isObj(x.jobs) || !Object.values(x.jobs).every(isWellFormedJob))
+        return false;
+    if (!isObj(x.appliedRequests) || !Object.values(x.appliedRequests).every(isWellFormedAppliedRequest))
+        return false;
+    if (!Array.isArray(x.requestProblems) || !x.requestProblems.every(isWellFormedRequestProblem))
+        return false;
+    if (x.custodyDecisions !== undefined && (!Array.isArray(x.custodyDecisions) || !x.custodyDecisions.every(isWellFormedCustodyDecision)))
+        return false;
+    if (!x.generations.every(isWellFormedGeneration) || !x.tasks.every(isWellFormedTask))
+        return false;
+    if (!x.cycleVerificationPlan.every(isWellFormedVerificationItem))
+        return false;
+    if (!x.verdicts.every(isWellFormedVerdict) || !x.fixes.every(isWellFormedFix))
+        return false;
+    return true;
+}
+function isWellFormedNextAction(x) {
+    return isObj(x) && typeof x.actionId === 'string' && typeof x.type === 'string' && typeof x.target === 'string'
+        && strings(x.preconditions) && typeof x.attempt === 'number'
+        && (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';
+}
+function strings(x) {
+    return Array.isArray(x) && x.every((item) => typeof item === 'string');
+}
+function isWellFormedVerificationItem(x) {
+    return isObj(x) && typeof x.id === 'string'
+        && ['test', 'lint', 'sensors', 'review', 'qa', 'interlock'].includes(String(x.kind))
+        && (x.satisfiedBy === undefined || typeof x.satisfiedBy === 'string');
+}
+function isWellFormedReviewObligation(x) {
+    return isObj(x) && typeof x.id === 'string' && typeof x.taskId === 'string'
+        && (x.kind === 'spec' || x.kind === 'quality')
+        && (x.verdictId === undefined || typeof x.verdictId === 'string');
+}
+function isWellFormedTask(x) {
+    return isObj(x) && typeof x.id === 'string' && typeof x.title === 'string'
+        && ['pending', 'in-progress', 'done'].includes(String(x.status))
+        && typeof x.attempts === 'number'
+        && Array.isArray(x.verificationPlan) && x.verificationPlan.every(isWellFormedVerificationItem)
+        && Array.isArray(x.reviewObligations) && x.reviewObligations.every(isWellFormedReviewObligation);
+}
+function isWellFormedGeneration(x) {
+    return isObj(x) && typeof x.n === 'number' && typeof x.token === 'string'
+        && exports.GENERATION_STATES.includes(String(x.state))
+        && typeof x.launchedAt === 'string'
+        && (x.controllerJobId === undefined || typeof x.controllerJobId === 'string')
+        && (x.spawnNonce === undefined || typeof x.spawnNonce === 'string')
+        && (x.provider === undefined || typeof x.provider === 'string')
+        && (x.resumePrompt === undefined || typeof x.resumePrompt === 'string')
+        && (x.processRef === undefined || isWellFormedProcessRef(x.processRef))
+        && (x.wrapperRef === undefined || isWellFormedProcessRef(x.wrapperRef));
+}
+function isWellFormedVerdict(x) {
+    return isObj(x) && typeof x.id === 'string' && typeof x.obligationId === 'string'
+        && ['pass', 'fail', 'inconclusive'].includes(String(x.result))
+        && typeof x.detail === 'string' && typeof x.receivedAt === 'string'
+        && typeof x.fingerprint === 'string' && strings(x.argv) && strings(x.paths) && typeof x.cwd === 'string';
+}
+function isWellFormedFix(x) {
+    return isObj(x) && typeof x.id === 'string' && typeof x.verdictId === 'string' && typeof x.closed === 'boolean';
+}
+function isWellFormedAppliedRequest(x) {
+    return isObj(x) && typeof x.requestId === 'string' && typeof x.idempotencyKey === 'string'
+        && typeof x.payloadDigest === 'string'
+        && ['applied', 'rejected-stale-generation', 'rejected-digest-mismatch', 'rejected-secret'].includes(String(x.outcome))
+        && (x.resultRef === undefined || typeof x.resultRef === 'string');
+}
+function isWellFormedRequestProblem(x) {
+    return isObj(x) && typeof x.file === 'string' && (x.kind === 'corrupt' || x.kind === 'rejected')
+        && typeof x.detail === 'string' && typeof x.at === 'string';
+}
+function isWellFormedCustodyDecision(x) {
+    return isObj(x) && typeof x.at === 'string' && x.decision === 'resume'
+        && typeof x.reason === 'string' && typeof x.generationToken === 'string';
+}
+function isWellFormedProcessRef(x) {
+    if (!isObj(x))
+        return false;
+    return typeof x.pid === 'number' && Number.isInteger(x.pid) && x.pid > 0
+        && typeof x.startTime === 'string'
+        && typeof x.spawnNonce === 'string'
+        && typeof x.argvDigest === 'string'
+        && typeof x.processGroup === 'number' && Number.isInteger(x.processGroup) && x.processGroup > 0
+        && typeof x.psArgsDigest === 'string';
+}
+function isWellFormedJob(x) {
+    if (!isObj(x))
+        return false;
+    return typeof x.id === 'string'
+        && typeof x.fingerprint === 'string'
+        && typeof x.commandDigest === 'string'
+        && strings(x.argv)
+        && typeof x.cwd === 'string'
+        && strings(x.paths)
+        && strings(x.expandedPaths)
+        && (x.observationState === 'progressing' || x.observationState === 'suspected-stall')
+        && isObj(x.phaseTimestamps) && Object.entries(x.phaseTimestamps).every(([state, at]) => exports.EXECUTION_STATES.includes(state) && typeof at === 'string')
+        && (x.verdict === undefined || ['pass', 'fail', 'inconclusive'].includes(String(x.verdict)))
+        && (x.spawnNonce === undefined || typeof x.spawnNonce === 'string')
+        && (x.processRef === undefined || isWellFormedProcessRef(x.processRef))
+        && (x.wrapperRef === undefined || isWellFormedProcessRef(x.wrapperRef))
+        && (x.lastProgressAt === undefined || typeof x.lastProgressAt === 'string')
+        && (x.logPath === undefined || typeof x.logPath === 'string')
+        && (x.result === undefined || (isObj(x.result) && typeof x.result.exitCode === 'number'
+            && typeof x.result.endedAt === 'string' && typeof x.result.resultPath === 'string'))
+        && (x.satisfies === undefined || typeof x.satisfies === 'string')
+        && (x.attemptOf === undefined || typeof x.attemptOf === 'string')
+        && exports.EXECUTION_STATES.includes(x.executionState);
+}

package/dist/src/index.js

@@ -33,6 +33,8 @@ const registry_1 = require("./commands/registry");
 const pin_1 = require("./commands/pin");
 const export_1 = require("./commands/export");
 const agent_1 = require("./commands/agent");
+const job_1 = require("./commands/job");
+const watch_1 = require("./commands/watch");
 const add_1 = require("./commands/add");
 const sync_1 = require("./commands/sync");
 const update_1 = require("./commands/update");
@@ -611,4 +613,6 @@ miroCmd.command('sync <storyMapPath>')
 (0, pin_1.registerPinCommands)(program);
 (0, export_1.registerExportCommand)(program);
 (0, agent_1.registerAgentCommand)(program);
+(0, job_1.registerJobCommand)(program);
+(0, watch_1.registerWatchCommand)(program);
 program.parse();

package/dist/tests/commands/job/exec-wrapper.test.js

@@ -0,0 +1,85 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+const process_1 = require("../../../src/core/journal/process");
+describe('exec-wrapper', () => {
+    let dir;
+    beforeEach(() => { dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-wrap-')); });
+    afterEach(() => { fs_1.default.rmSync(dir, { recursive: true, force: true }); });
+    test('claim + identity sidecar + resultado terminal atomico (R1.8)', async () => {
+        const out = await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job1', nonce: 'nonceA', argv: ['node', '-e', 'setTimeout(()=>process.exit(0), 300)'], cwd: '.' });
+        expect(out.exitCode).toBe(0);
+        expect(fs_1.default.existsSync((0, exec_wrapper_1.claimPath)(dir, 'job1', 'nonceA'))).toBe(true);
+        const identity = JSON.parse(fs_1.default.readFileSync((0, exec_wrapper_1.identityPath)(dir, 'job1', 'nonceA'), 'utf8'));
+        expect(identity.wrapper.pid).toBe(process.pid); // ProcessRef REAL del wrapper
+        expect(identity.command.pid).toBeGreaterThan(0); // ProcessRef REAL del comando
+        expect(identity.command.psArgsDigest).toMatch(/^[0-9a-f]{16}$/);
+        expect(identity.command.processGroup).not.toBe(identity.wrapper.processGroup); // el wrapper puede limpiar el grupo sin matarse
+        const result = JSON.parse(fs_1.default.readFileSync((0, exec_wrapper_1.resultPath)(dir, 'job1', 'nonceA'), 'utf8'));
+        expect(result.exitCode).toBe(0);
+    });
+    test('segundo claim con el mismo nonce falla: exactly-once (R1.8)', async () => {
+        await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job2', nonce: 'nonceB', argv: ['node', '-e', 'process.exit(0)'], cwd: '.' });
+        await expect((0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job2', nonce: 'nonceB', argv: ['node', '-e', 'process.exit(0)'], cwd: '.' }))
+            .rejects.toThrow(/claim/);
+    });
+    test('comando inexistente produce resultado 127, no crash (R1.8)', async () => {
+        const out = await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job3', nonce: 'nonceC', argv: ['binario-inexistente-xyz'], cwd: '.' });
+        expect(out.exitCode).toBe(127);
+        expect((0, exec_wrapper_1.replayVerdict)(dir, 'job3', 'nonceC')).toBe('completed');
+    });
+    test('matriz de replay: sin claim / claim+resultado / claim sin resultado (R1.8)', async () => {
+        expect((0, exec_wrapper_1.replayVerdict)(dir, 'jobX', 'n1')).toBe('never-started'); // sin claim => re-spawn seguro
+        await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'jobY', nonce: 'n2', argv: ['node', '-e', 'process.exit(3)'], cwd: '.' });
+        expect((0, exec_wrapper_1.replayVerdict)(dir, 'jobY', 'n2')).toBe('completed'); // adoptar resultado
+        fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)(dir, 'jobZ', 'n3'), '{"claimed":true}'); // claim sin resultado
+        expect((0, exec_wrapper_1.replayVerdict)(dir, 'jobZ', 'n3')).toBe('unprovable'); // orphaned, jamas relanzar solo
+    });
+    test('el log captura la salida completa incluso si exit llega antes que el flush de stdio (R2.5)', async () => {
+        await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job4', nonce: 'nonceD', argv: ['node', '-e', "process.stdout.write('linea-final-no-se-debe-perder'); process.exit(0)"], cwd: '.' });
+        const log = fs_1.default.readFileSync((0, exec_wrapper_1.logPath)(dir, 'job4', 'nonceD'), 'utf8');
+        expect(log).toContain('linea-final-no-se-debe-perder');
+    });
+    test('redacta secretos aunque la asignacion llegue dividida entre chunks de stdout (R2.3)', async () => {
+        const script = "process.stdout.write('API_'); setTimeout(()=>{process.stdout.write('KEY=hunter2\\n'); process.exit(0)}, 80)";
+        await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job-split', nonce: 'nonce-split', argv: ['node', '-e', script], cwd: '.' });
+        const log = fs_1.default.readFileSync((0, exec_wrapper_1.logPath)(dir, 'job-split', 'nonce-split'), 'utf8');
+        expect(log).toContain('API_KEY=[REDACTED]');
+        expect(log).not.toContain('hunter2');
+    });
+    test('el log se acota aprox. en MAX_LOG_BYTES cuando la salida supera el limite, no crece sin cota (R2.5)', async () => {
+        const MAX_LOG_BYTES = 1024 * 1024;
+        const bytesToWrite = 2 * MAX_LOG_BYTES; // 2MB, muy por encima del cap de 1MB
+        const out = await (0, exec_wrapper_1.runExecWrapper)({
+            logsRoot: dir, jobId: 'job6', nonce: 'nonceF',
+            argv: ['node', '-e', `process.stdout.write('x'.repeat(${bytesToWrite}))`],
+            cwd: '.',
+        });
+        expect(out.exitCode).toBe(0);
+        const size = fs_1.default.statSync((0, exec_wrapper_1.logPath)(dir, 'job6', 'nonceF')).size;
+        // el append corta apenas se cruza el cap (chequeo ANTES de cada chunk),
+        // asi que el tamano final ronda MAX_LOG_BYTES +/- un ultimo chunk de
+        // pipe, jamas los 2MB reales escritos por el comando (R2.5).
+        expect(size).toBeGreaterThanOrEqual(MAX_LOG_BYTES);
+        expect(size).toBeLessThan(MAX_LOG_BYTES * 1.5);
+        expect(size).toBeLessThan(bytesToWrite);
+    }, 10000);
+    test('no se cuelga si un descendiente hereda stdio y no lo cierra (R1.8)', async () => {
+        const script = "const {spawn}=require('child_process'); const gc=spawn('sleep',['3'],{stdio:'inherit',detached:true}); gc.unref(); process.exit(0);";
+        const out = await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job5', nonce: 'nonceE', argv: ['node', '-e', script], cwd: '.' });
+        expect(out.exitCode).toBe(0);
+    }, 10000);
+    test('no publica pass hasta drenar descendientes que quedan en el process group del comando', async () => {
+        const script = "require('child_process').spawn('sleep',['30'],{stdio:'ignore'}); process.exit(0);";
+        const out = await (0, exec_wrapper_1.runExecWrapper)({ logsRoot: dir, jobId: 'job7', nonce: 'nonceG', argv: ['node', '-e', script], cwd: '.' });
+        const identity = JSON.parse(fs_1.default.readFileSync((0, exec_wrapper_1.identityPath)(dir, 'job7', 'nonceG'), 'utf8'));
+        expect(out.exitCode).toBe(0);
+        expect((0, process_1.groupIsGone)(identity.command.processGroup)).toBe(true);
+    }, 10000);
+});

package/dist/tests/commands/job/export.test.js

@@ -0,0 +1,76 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+const export_1 = require("../../../src/commands/job/export");
+const types_1 = require("../../../src/core/journal/types");
+function job(partial) {
+    return {
+        id: 'j1', fingerprint: 'fp', commandDigest: 'cd', argv: ['npm', 'test'], cwd: '.',
+        paths: [], expandedPaths: [], executionState: 'exited', observationState: 'progressing',
+        phaseTimestamps: {}, ...partial,
+    };
+}
+describe('export', () => {
+    let logs;
+    beforeEach(() => { logs = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-exp-')); });
+    afterEach(() => { fs_1.default.rmSync(logs, { recursive: true, force: true }); });
+    test('schema, timestamps por fase, wall time por task y ciclo (R3.7 / RNF-T.4)', () => {
+        const s = (0, types_1.emptyState)('r');
+        s.cycle.startedAt = '2026-08-01T10:00:00.000Z';
+        s.cycle.completedAt = '2026-08-01T10:30:00.000Z';
+        s.tasks.push({ id: 'T1', title: 't', status: 'done', attempts: 2, verificationPlan: [], reviewObligations: [], createdAt: '2026-08-01T10:00:00.000Z', completedAt: '2026-08-01T10:10:00.000Z' });
+        s.tasks.push({ id: 'T2', title: 'sin-timestamps', status: 'done', attempts: 1, verificationPlan: [], reviewObligations: [] });
+        s.jobs['j1'] = job({ phaseTimestamps: { received: 'a', running: 'b', exited: 'c' } });
+        const e = (0, export_1.buildExport)(s, 'codex', { logsRoot: null, baseline: null });
+        expect(e.schema).toBe(2);
+        expect(e.cycle.wallTimeMs).toBe(30 * 60000);
+        expect(e.tasks[0].wallTimeMs).toBe(10 * 60000);
+        expect(e.tasks[1].wallTimeMs).toBe('unobservable'); // sin timestamps => declarado, no cero
+        expect(e.jobs[0].phaseTimestamps.running).toBe('b');
+    });
+    test('despachos REALES, dedup real, evidencia con hash + comando reproducible (RNF-T.8/T.9)', () => {
+        const s = (0, types_1.emptyState)('r');
+        s.dispatches.push({ id: 'd1', taskId: 'T1', at: 'x' }, { id: 'd2', taskId: 'T1', at: 'y' });
+        s.jobs['j1'] = job({ id: 'j1', spawnNonce: 'n1' });
+        s.jobs['j2'] = job({ id: 'j2', spawnNonce: 'n2' }); // mismo fingerprint+cmd => dedup
+        const resultBody = JSON.stringify({ exitCode: 0, endedAt: 'x', resultPath: 'p' });
+        fs_1.default.writeFileSync(path_1.default.join(logs, 'j1.n1.result.json'), resultBody);
+        const e = (0, export_1.buildExport)(s, 'codex', { logsRoot: logs, baseline: null });
+        expect(e.metrics.dispatches).toBe(2); // reales, no attempts-proxy
+        expect(e.metrics.mechanicalRunsReal).toBe(2);
+        expect(e.metrics.mechanicalRunsDeduplicated).toBe(1);
+        expect(e.jobs.find((j) => j.id === 'j2').deduplicated).toBe(true);
+        const ev1 = e.evidence.find((x) => x.jobId === 'j1');
+        expect(ev1.resultHash).toBe(crypto_1.default.createHash('sha256').update(resultBody).digest('hex'));
+        expect(ev1.reproduce).toContain('npm test');
+        expect(e.evidence.find((x) => x.jobId === 'j2').resultHash).toBe('unobservable'); // sin result file
+    });
+    test('baselineComparison: con baseline compara, sin baseline declara unobservable (R3.7)', () => {
+        const s = (0, types_1.emptyState)('r');
+        s.cycle.startedAt = '2026-08-01T10:00:00.000Z';
+        s.cycle.completedAt = '2026-08-01T10:20:00.000Z';
+        s.dispatches.push({ id: 'd1', taskId: 'T1', at: 'x' });
+        const withBase = (0, export_1.buildExport)(s, 'codex', { logsRoot: null, baseline: { source: 'docs/baseline-2026-07-29.json', wallTimeMs: 40 * 60000, dispatches: 3 } });
+        expect(withBase.baselineComparison.baselineDate).toBe('2026-07-29');
+        expect(withBase.baselineComparison.wallTimeMs).toEqual({ current: 20 * 60000, baseline: 40 * 60000, delta: -20 * 60000 });
+        expect(withBase.baselineComparison.dispatches).toEqual({ current: 1, baseline: 3, delta: -2 });
+        expect(withBase.baselineComparison.tokensPerRole).toBe('unobservable'); // ningun provider lo reporta (R0)
+        const noBase = (0, export_1.buildExport)(s, 'codex', { logsRoot: null, baseline: null });
+        expect(noBase.baselineComparison.wallTimeMs.baseline).toBe('unobservable');
+        expect(noBase.baselineComparison.wallTimeMs.delta).toBe('unobservable');
+        expect(noBase.metrics.tokensPerRole).toBe('unobservable');
+    });
+    test('wallMs declara unobservable ante timestamps invertidos, nunca un numero negativo (R3.7)', () => {
+        const s = (0, types_1.emptyState)('r');
+        s.cycle.startedAt = '2026-08-01T10:30:00.000Z';
+        s.cycle.completedAt = '2026-08-01T10:00:00.000Z'; // invertido: dato corrupto/anomalo
+        const e = (0, export_1.buildExport)(s, 'codex', { logsRoot: null, baseline: null });
+        expect(e.cycle.wallTimeMs).toBe('unobservable');
+    });
+});