agentic-workflow-manager 3.4.0 → 3.5.0

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');
+    });
+});