agentic-workflow-manager 3.3.1 → 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/core/ledger/cluster.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEXICAL_AFFINITY_MIN = void 0;
+exports.normalizeTokens = normalizeTokens;
+exports.affinity = affinity;
+exports.normalizeRef = normalizeRef;
+exports.clusterEntries = clusterEntries;
+/** Palabras sin valor discriminante de identidad de defecto: se descartan antes
+ * de medir afinidad para que no inflen el score de dos hallazgos distintos. */
+const STOPWORDS = new Set([
+    'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'not', 'but',
+    'its', 'has', 'have', 'was', 'are', 'were', 'when', 'then', 'than', 'only',
+    'all', 'any', 'via', 'per', 'out', 'off', 'over', 'under',
+]);
+function normalizeTokens(...texts) {
+    const out = new Set();
+    for (const text of texts) {
+        for (const token of text.toLowerCase().split(/[^a-z0-9]+/)) {
+            if (token.length < 2)
+                continue;
+            if (STOPWORDS.has(token))
+                continue;
+            out.add(token);
+        }
+    }
+    return out;
+}
+/** Coeficiente de solapamiento — |A∩B| / min(|A|,|B|). Elegido sobre Jaccard
+ * porque el caso normal acá es un slug corto contra una descripción larga, y
+ * Jaccard castiga esa diferencia de longitud incluso cuando el set corto está
+ * completamente contenido en el largo. */
+function affinity(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let shared = 0;
+    for (const token of a)
+        if (b.has(token))
+            shared++;
+    return shared / Math.min(a.size, b.size);
+}
+/** El locus de archivo de un `ref`, o null cuando el ref no apunta a un archivo.
+ * `PR #16` devuelve null a propósito: un PR entero no es un locus de defecto, y
+ * agrupar por él fundiría todo lo hallado en una misma review. */
+function normalizeRef(ref) {
+    if (!ref)
+        return null;
+    const locus = ref.split(':')[0].trim();
+    if (!locus)
+        return null;
+    if (!locus.includes('/') && !/\.[a-z0-9]+$/i.test(locus))
+        return null;
+    return locus;
+}
+/** Umbral sin `ref` compartido: alto, porque la afinidad léxica es la única
+ * evidencia disponible y un falso positivo acá funde hallazgos de archivos
+ * distintos.
+ *
+ * Con `ref` compartido no hay umbral de ratio: alcanza **un token en común**
+ * (`score > 0`). Es deliberado y no es lo mismo que "un umbral muy bajo":
+ * compartir archivo ya es evidencia fuerte y barata de mismo locus, así que lo
+ * único que falta descartar es el par sin ninguna palabra en común — dos
+ * defectos genuinamente distintos que caen en el mismo archivo. Un ratio bajo
+ * (probamos 0.2) hacía que el caso real del issue —tres lentes, siete a nueve
+ * tokens cada una, un solo token compartido por par— cayera exactamente sobre
+ * el borde: agrupaba por casualidad aritmética, y cualquier palabra más en una
+ * descripción lo habría vuelto a romper. */
+exports.LEXICAL_AFFINITY_MIN = 0.6;
+/** Devuelve, por índice de entrada, el índice raíz de su cluster. */
+function unify(entries) {
+    const parent = entries.map((_, i) => i);
+    const find = (i) => {
+        let node = i;
+        while (parent[node] !== node) {
+            parent[node] = parent[parent[node]];
+            node = parent[node];
+        }
+        return node;
+    };
+    const union = (a, b) => {
+        const rootA = find(a);
+        const rootB = find(b);
+        // La raíz más baja gana: hace el resultado independiente del orden de
+        // comparación, y por lo tanto determinístico.
+        if (rootA !== rootB)
+            parent[Math.max(rootA, rootB)] = Math.min(rootA, rootB);
+    };
+    const tokens = entries.map((e) => normalizeTokens(e.signature, e.desc));
+    const refs = entries.map((e) => normalizeRef(e.ref));
+    for (let i = 0; i < entries.length; i++) {
+        for (let j = i + 1; j < entries.length; j++) {
+            if (entries[i].signature === entries[j].signature) {
+                union(i, j); // R1.1 — piso preservado, sin más condiciones
+                continue;
+            }
+            if (entries[i].polarity !== entries[j].polarity)
+                continue; // R1.4
+            const score = affinity(tokens[i], tokens[j]);
+            const sameFile = refs[i] !== null && refs[i] === refs[j];
+            // Mismo archivo: cualquier palabra en común alcanza (R1.2).
+            // Archivos distintos: la afinidad tiene que sostener sola (R1.3).
+            const unionable = sameFile ? score > 0 : score >= exports.LEXICAL_AFFINITY_MIN;
+            if (unionable)
+                union(i, j);
+        }
+    }
+    return entries.map((_, i) => find(i));
+}
+function clusterEntries(entries, min) {
+    const roots = unify(entries);
+    const byRoot = new Map();
+    for (let i = 0; i < entries.length; i++) {
+        const group = byRoot.get(roots[i]) ?? [];
+        group.push(entries[i]);
+        byRoot.set(roots[i], group);
+    }
+    const clusters = [];
+    for (const group of byRoot.values()) {
+        const freq = new Map();
+        for (const e of group)
+            freq.set(e.signature, (freq.get(e.signature) ?? 0) + 1);
+        const signatures = [...freq.keys()].sort();
+        // signatures viene ascendente y la comparación es estricta, así que un
+        // empate de frecuencia deja parada la primera lexicográfica (R1.8).
+        const representative = signatures.reduce((best, s) => (freq.get(s) > freq.get(best) ? s : best), signatures[0]);
+        clusters.push({
+            signature: representative,
+            count: group.length,
+            kind: signatures.length > 1 ? 'convergent' : 'exact',
+            signatures,
+            entries: group,
+        });
+    }
+    return clusters
+        .filter((c) => c.count >= min)
+        .sort((a, b) => b.count - a.count
+        || (a.kind === b.kind ? 0 : a.kind === 'convergent' ? -1 : 1)
+        || a.signature.localeCompare(b.signature));
+}

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

@@ -12,6 +12,7 @@ exports.archiveLedger = archiveLedger;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
+const cluster_1 = require("./cluster");
 const LEDGER_DIR = path_1.default.join('.awm', 'ledger');
 function detectBranch(cwd) {
     try {
@@ -33,6 +34,21 @@ function addEntry(cwd, entry) {
     fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
     fs_1.default.appendFileSync(p, JSON.stringify(entry) + '\n', 'utf-8');
 }
+/** Required LedgerEntry fields that `cluster.ts` reads unconditionally
+ * (`signature`, `desc`, `ref` when present). A JSONL line can be syntactically
+ * valid JSON while still being shape-invalid (e.g. missing `desc`) — that's
+ * not a parse error, so it needs its own check, extending the same "skip
+ * malformed line" policy this function already applies to JSON syntax errors. */
+function isWellFormedEntry(x) {
+    if (!x || typeof x !== 'object')
+        return false;
+    const e = x;
+    return typeof e.signature === 'string'
+        && typeof e.desc === 'string'
+        && typeof e.branch === 'string'
+        && typeof e.polarity === 'string'
+        && (e.ref === undefined || typeof e.ref === 'string');
+}
 function listEntries(cwd, branch) {
     const p = ledgerPath(cwd, branch);
     if (!fs_1.default.existsSync(p))
@@ -43,23 +59,16 @@ function listEntries(cwd, branch) {
         if (!trimmed)
             continue;
         try {
-            out.push(JSON.parse(trimmed));
+            const parsed = JSON.parse(trimmed);
+            if (isWellFormedEntry(parsed))
+                out.push(parsed);
         }
         catch { /* skip malformed line */ }
     }
     return out;
 }
 function recurring(cwd, branch, min) {
-    const bySig = new Map();
-    for (const e of listEntries(cwd, branch)) {
-        const arr = bySig.get(e.signature) ?? [];
-        arr.push(e);
-        bySig.set(e.signature, arr);
-    }
-    return [...bySig.entries()]
-        .map(([signature, entries]) => ({ signature, count: entries.length, entries }))
-        .filter(c => c.count >= min)
-        .sort((a, b) => b.count - a.count);
+    return (0, cluster_1.clusterEntries)(listEntries(cwd, branch), min);
 }
 function archiveLedger(cwd, branch, label) {
     const src = ledgerPath(cwd, branch);

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