agentic-workflow-manager 9.7.1 → 9.9.0

package/dist/tests/commands/sensors/status.test.js

@@ -224,7 +224,7 @@ describe('computeSensorStatus', () => {
                         variants: [{
                                 id: 'eslint-10', priority: 10, certifiedRange: '>=10.0.0 <11.0.0',
                                 requirements: { tool: 'eslint', toolRange: '>=10.0.0 <11.0.0', runtime: 'node', runtimeRange: '>=0.0.0' },
-                                assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'package-script-present' },
+                                assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'package-script-present', script: 'lint' },
                                 command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.', '--config', 'eslint.config.awm.mjs'] },
                             }],
                     } },
@@ -291,7 +291,7 @@ describe('computeSensorStatus', () => {
             const variant = (id, range) => ({
                 id, priority: 10, certifiedRange: range,
                 requirements: { tool: 'eslint', toolRange: range, runtime: 'node', runtimeRange: '>=0.0.0' },
-                assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'package-script-present' },
+                assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'package-script-present', script: 'lint' },
                 command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
             });
             fs_1.default.writeFileSync(path_1.default.join(registry, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({
@@ -381,7 +381,7 @@ describe('computeSensorStatus', () => {
                 sensors: { lint: { applicability: { allFiles: ['package.json'] }, variants: [{
                                 id: 'eslint-10', priority: 1, certifiedRange: '>=10 <11',
                                 requirements: { tool: 'eslint', toolRange: '>=10 <11', runtime: 'node', runtimeRange: '>=0' },
-                                assets: [], formatter: 'generic', probe: { kind: 'package-script-present' },
+                                assets: [], formatter: 'generic', probe: { kind: 'package-script-present', script: 'lint' },
                                 command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
                             }] } },
             };

package/dist/tests/commands/watch/apply.test.js

@@ -194,6 +194,18 @@ describe('aplicacion transaccional de requests', () => {
         expect(Object.values(s.appliedRequests).some((a) => a.outcome === 'rejected-stale-generation')).toBe(true);
         expect(s.controllerHeartbeatAt).toBeUndefined();
     });
+    test('routing reserve/observe es supervisado, idempotente y una generacion vieja no muta intentos', () => {
+        const envelope = { schema: 'routing-envelope/v1', runtime: { target: 'codex', kind: 'native', version: '1', accountScopeDigest: '0'.repeat(64) }, role: 'implementer', sliceId: 'S1', requestedProfile: 'mechanical', effectiveProfile: 'mechanical', resolved: { selector: { kind: 'model', id: 'm' }, effort: { kind: 'explicit', value: 'medium' } }, outcome: 'native', unavailableEvidence: [], policyDigest: 'a'.repeat(64), capabilityDigest: 'b'.repeat(64), planDigest: 'c'.repeat(64), executionDigest: 'd'.repeat(64) };
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'routing-reserve', generationToken: 'g1', idempotencyKey: 'routing-1', payload: { obligationId: 'o1', lineageId: 'l1', envelope, fingerprint: 'e'.repeat(64) } });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        const attempt = (0, store_1.readJournal)(repo, 'rama').state.routingAttempts[0];
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'routing-observe', generationToken: 'g1', idempotencyKey: 'routing-2', payload: { attemptId: attempt.id, nativeAgentId: 'native-1' } });
+        (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect((0, store_1.readJournal)(repo, 'rama').state.routingAttempts[0]).toMatchObject({ state: 'active', nativeAgentId: 'native-1' });
+        (0, requests_1.emitRequest)(repo, 'rama', { kind: 'routing-reserve', generationToken: 'old', idempotencyKey: 'routing-old', payload: { obligationId: 'o1', lineageId: 'l2', envelope, fingerprint: 'f'.repeat(64) } });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').rejectedStale).toBe(1);
+        expect((0, store_1.readJournal)(repo, 'rama').state.routingAttempts).toHaveLength(1);
+    });
     test('request corrupta se aparta VISIBLE como .corrupt, jamas se descarta (R1.6)', () => {
         fs_1.default.writeFileSync(path_1.default.join((0, paths_1.requestsDir)(repo, 'rama'), 'req-roto.json'), '{no-json');
         const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');

package/dist/tests/commands/watch/e2e-crash.test.js

@@ -9,6 +9,8 @@ const os_1 = __importDefault(require("os"));
 const child_process_1 = require("child_process");
 const process_1 = require("../../../src/core/journal/process");
 const paths_1 = require("../../../src/core/paths");
+const run_1 = require("../../../src/commands/sensors/run");
+const live_1 = require("../../../src/commands/sensors/compatibility/live");
 /** win32 has no POSIX process groups / negative-pid kill convention -- mirrors
  *  killTreeWindows's taskkill pattern already established and tested in
  *  core/journal/process.ts, applied here to this test's own cleanup (not
@@ -27,6 +29,36 @@ function killGroup(pgid) {
     }
     catch { /* ya muerto */ }
 }
+function groupAlive(pgid) {
+    if ((0, paths_1.isWindowsNative)())
+        return false; // taskkill above is synchronous enough for this fixture.
+    try {
+        process.kill(-pgid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function terminateFixtureGroups(groups) {
+    for (const pgid of groups)
+        killGroup(pgid);
+    await until(() => [...groups].every(pgid => !groupAlive(pgid)), 5_000, 'terminacion de grupos del fixture');
+}
+async function removeFixture(pathname) {
+    let last;
+    for (let attempt = 0; attempt < 20; attempt++) {
+        try {
+            fs_1.default.rmSync(pathname, { recursive: true, force: true, maxRetries: 1, retryDelay: 25 });
+            return;
+        }
+        catch (error) {
+            last = error;
+            await new Promise(resolve => setTimeout(resolve, 25));
+        }
+    }
+    throw last;
+}
 jest.setTimeout(180000);
 // R1.8 promete "el wrapper sobrevive incluso si el supervisor muere" — en
 // POSIX esto se sostiene en `detached: true` (nueva sesion, sobrevive un
@@ -51,6 +83,37 @@ function readState(repo) {
         return null;
     }
 }
+/** A physical capability-only registry is intentional: sensor pack resolution
+ * rejects a linked registry root, because a link could later escape its
+ * configured authority.  Keep the v3 logical source name and the registry
+ * configuration aligned so this fixture exercises the real resolver. */
+function writeFixtureBaselineRegistry(awmHome) {
+    const packDir = path_1.default.join(awmHome, 'registries', 'baseline', 'sensor-packs', 'js-ts');
+    fs_1.default.mkdirSync(packDir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(packDir, 'pack.json'), JSON.stringify({
+        schemaVersion: 2,
+        name: 'js-ts',
+        description: 'E2E compact admission sensor fixture',
+        detects: ['package.json'],
+        sensors: {
+            test: {
+                applicability: { allFiles: ['package.json'] },
+                fast: false,
+                timeout: 30_000,
+                variants: [{
+                        id: 'npm-script', priority: 1,
+                        requirements: { tool: 'npm', toolRange: '>=1.0.0', runtime: 'node', runtimeRange: '>=20.0.0' },
+                        certifiedRange: '>=1.0.0',
+                        command: { executable: 'npm', resolution: 'path', args: ['test', '--', '--silent'], packageManager: 'npm' },
+                        assets: [], formatter: 'test', probe: { kind: 'package-script-present', script: 'test' },
+                    }],
+            },
+        },
+        coverage: { schemaVersion: 1, classes: {
+                tests: { description: 'Fixture test execution', detectors: [{ sensor: 'test' }], remedy: { summary: 'Run fixture tests', command: 'npm test' } },
+            } },
+    }, null, 2) + '\n');
+}
 async function until(fn, ms = 60000, label = 'condicion') {
     const t0 = Date.now();
     while (!fn()) {
@@ -62,19 +125,40 @@ async function until(fn, ms = 60000, label = 'condicion') {
 describe('E2E real: crash/restart del supervisor', () => {
     let repo;
     let stubBin;
+    let fixtureAwmHome;
     let env;
     const children = [];
     beforeAll(() => {
         if (!fs_1.default.existsSync(CLI))
             throw new Error('dist ausente: corre `cd cli && npm run build` antes de esta suite (Task 20 Step 1)');
     });
-    beforeEach(() => {
+    beforeEach(async () => {
         repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-e2e-'));
         git(repo, 'init', '-q', '-b', 'main');
-        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ name: 'fixture', scripts: { test: 'node -e "process.exit(0)"' } }));
+        const npmVersion = (0, child_process_1.execFileSync)('npm', ['--version'], { encoding: 'utf8' }).trim();
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ name: 'fixture', packageManager: `npm@${npmVersion}`, scripts: { test: 'node -e "process.exit(0)" --' } }));
+        // The package manager is deliberately selected in package metadata.
+        // Discovery must certify the same bounded PATH npm that the sensor runs,
+        // rather than accept a shadow package under this fixture's node_modules.
+        fs_1.default.mkdirSync(path_1.default.join(repo, 'plans'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'plans', 'fixture.md'), fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v1/valid.md'), 'utf8'));
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'source.md'), '## Canonical source\nfixture source\n');
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3, mode: 'project-sensors', pack: 'js-ts', source: { registry: 'baseline' },
+            sensors: { test: {
+                    enabled: true, variantId: 'npm-script',
+                    command: { executable: 'npm', resolution: 'path', args: ['test', '--', '--silent'], packageManager: 'npm' },
+                    initializedCompatibility: { state: 'certified', reason: 'fixture', variantId: 'npm-script', toolVersion: npmVersion, runtimeVersion: process.versions.node, certifiedRange: '>=8.0.0', evidence: [] },
+                } },
+        }));
         git(repo, 'add', '.');
         git(repo, 'commit', '-qm', 'c');
         stubBin = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-e2e-bin-'));
+        fixtureAwmHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-e2e-home-'));
+        writeFixtureBaselineRegistry(fixtureAwmHome);
+        fs_1.default.writeFileSync(path_1.default.join(fixtureAwmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'fixture://baseline' }]));
+        fs_1.default.writeFileSync(path_1.default.join(fixtureAwmHome, 'preferences.json'), JSON.stringify({ defaultAgent: 'codex', enabledAgents: ['codex', 'claude-code'], installMethod: 'symlink', defaultScope: 'local' }));
         // A bare extensionless #!/bin/sh script only runs via POSIX kernel shebang
         // interpretation -- Windows CreateProcess has none, so spawnStructured
         // (shell:false, matching production) would silently fail to launch this stub
@@ -82,13 +166,41 @@ describe('E2E real: crash/restart del supervisor', () => {
         // on both platforms (Node's spawn on win32 resolves via PATHEXT and transparently
         // re-invokes a found .cmd through cmd.exe) without touching production code.
         for (const name of ['codex', 'claude']) {
-            fs_1.default.writeFileSync(path_1.default.join(stubBin, name), '#!/bin/sh\nwhile true; do sleep 1; done\n', { mode: 0o755 });
+            fs_1.default.writeFileSync(path_1.default.join(stubBin, name), `#!/bin/sh
+# The supervisor invokes Codex as \`codex exec <prompt>\`; retain a distinct
+# path for that real adapter contract instead of accidentally treating it as
+# a bare binary invocation.  Both controller forms deliberately stay alive:
+# the test's requested \`node -e\` job is the process that must complete and
+# leave its sidecar while the supervisor is killed.
+if [ "$1" = "exec" ]; then shift; fi
+while true; do sleep 1; done
+`, { mode: 0o755 });
             fs_1.default.writeFileSync(path_1.default.join(stubBin, `${name}.cmd`), '@echo off\r\n:loop\r\ntimeout /t 1 /nobreak >nul\r\ngoto loop\r\n');
         }
-        env = { ...process.env, PATH: `${stubBin}${path_1.default.delimiter}${process.env.PATH}` };
-        (0, child_process_1.execFileSync)(process.execPath, [CLI, 'watch', '--init'], { cwd: repo, env });
+        env = { ...process.env, AWM_HOME: fixtureAwmHome, PATH: `${stubBin}${path_1.default.delimiter}${process.env.PATH}` };
+        (0, child_process_1.execFileSync)(process.execPath, [CLI, 'watch', '--init', '--plan', 'plans/fixture.md'], { cwd: repo, env });
+        const priorAwmHome = process.env.AWM_HOME;
+        process.env.AWM_HOME = fixtureAwmHome;
+        const sensorReport = await (0, run_1.runSensors)({ cwd: repo, all: true, readOnly: true });
+        if (priorAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = priorAwmHome;
+        if (sensorReport.overall !== 'pass') {
+            process.env.AWM_HOME = fixtureAwmHome;
+            const live = await (0, live_1.resolveLiveCompatibility)(repo, 'js-ts');
+            if (priorAwmHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = priorAwmHome;
+            throw new Error(`fixture runSensors failed: ${JSON.stringify({ sensorReport, live })}`);
+        }
+        expect(sensorReport).toMatchObject({ source: { kind: 'logical', registry: 'baseline' } });
+        const admission = (0, child_process_1.spawnSync)(process.execPath, [CLI, 'plan', 'admit', 'plans/fixture.md', '--provider', 'codex', '--cwd', '.', '--execution-mode', 'desatendido', '--require-current', '--verify-sensors', '--json'], { cwd: repo, env, encoding: 'utf8' });
+        if (admission.status !== 0)
+            throw new Error(`fixture admission failed: ${admission.stdout}${admission.stderr}`);
     });
-    afterEach(() => {
+    afterEach(async () => {
         // higiene: terminar TODO grupo que hayamos originado (supervisores,
         // stubs de controlador, wrappers) — cero huerfanos entre tests
         const s = readState(repo);
@@ -107,14 +219,17 @@ describe('E2E real: crash/restart del supervisor', () => {
                     groups.add(j.processRef.processGroup);
             }
         }
-        for (const pgid of groups)
-            killGroup(pgid);
+        await terminateFixtureGroups(groups);
         children.length = 0;
-        fs_1.default.rmSync(repo, { recursive: true, force: true });
-        fs_1.default.rmSync(stubBin, { recursive: true, force: true });
+        await removeFixture(repo);
+        await removeFixture(stubBin);
+        await removeFixture(fixtureAwmHome);
     });
     function startSupervisor(provider) {
-        const out = fs_1.default.openSync(path_1.default.join(repo, `sup-${children.length}.log`), 'a');
+        // Supervisor stdout is test harness output, not project evidence.  An
+        // in-repo log would make the real currentness/admission gate reject
+        // the next tick before it can collect an exited job sidecar.
+        const out = fs_1.default.openSync(path_1.default.join(stubBin, `sup-${children.length}.log`), 'a');
         const child = (0, child_process_1.spawn)(process.execPath, [CLI, 'watch', '--provider', provider], {
             cwd: repo, env, detached: true, stdio: ['ignore', out, out],
         });

package/dist/tests/commands/watch/generations.test.js

@@ -12,6 +12,7 @@ const process_1 = require("../../../src/core/journal/process");
 const store_1 = require("../../../src/core/journal/store");
 const paths_1 = require("../../../src/core/journal/paths");
 const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+const recovery = { schema: 'controller-recovery/v1', kind: 'resume-cycle' };
 describe('generaciones', () => {
     let repo;
     beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-gen-')); (0, store_1.initJournal)(repo, 'rama'); });
@@ -56,7 +57,7 @@ describe('generaciones', () => {
         const begun = (0, generations_1.beginGeneration)(repo, 'rama');
         let captured;
         const wrapperRef = { pid: 42, startTime: 't', spawnNonce: 'wrapper-nonce', argvDigest: 'a', processGroup: 42, psArgsDigest: 'p' };
-        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', 'continua el ciclo', (job, nonce) => {
+        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', recovery, (job, nonce) => {
             const duringSpawn = (0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'rama').state);
             expect(duringSpawn.controllerJobId).toBe(job.id); // persistido ANTES del spawn
             expect(duringSpawn.spawnNonce).toBe(nonce);
@@ -67,9 +68,42 @@ describe('generaciones', () => {
         expect(captured.argv.join(' ')).toContain(`--generation ${begun.token}`);
         expect((0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'rama').state).wrapperRef).toEqual(wrapperRef);
     });
+    test('an arbitrary prompt is rejected before durable launch intent or dispatch', () => {
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        let dispatched = false;
+        expect(() => (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', 'private source body and password=sentinel', () => { dispatched = true; })).toThrow(/recovery|intent|acción/i);
+        expect(dispatched).toBe(false);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+        expect(() => (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', { ...recovery, prompt: 'private body' }, () => { })).toThrow(/recovery/);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+    });
+    test('legacy prompt custody remains readable but cannot launch or replay', () => {
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.generations[0].resumePrompt = 'historical legacy body';
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        expect(() => (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', recovery, () => { })).toThrow(/legacy/);
+        expect(() => (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', recovery, () => { }, 10000)).toThrow(/legacy/);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+    });
+    test('closed recovery intent launches deterministically and persists no prompt body', () => {
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        const action = { schema: 'controller-recovery/v1', kind: 'resume-cycle' };
+        const attempts = [];
+        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', action, job => { attempts.push(job.argv); });
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.generations[0]).toMatchObject({ resumeAction: action });
+        expect(state.generations[0].resumePrompt).toBeUndefined();
+        expect(JSON.stringify(state)).not.toContain('Sos el orquestador');
+        (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', { schema: 'controller-recovery/v1', kind: 'reconcile-active-jobs' }, job => { attempts.push(job.argv); }, 10000);
+        expect(attempts).toHaveLength(2);
+        expect(attempts[1]).toEqual(attempts[0]);
+    });
     test('claim sin identidad/resultado conserva ownership ambiguo; usa la edad del claim, no la de begin', () => {
         (0, generations_1.beginGeneration)(repo, 'rama');
-        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', 'continua', () => { });
+        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', recovery, () => { });
         let s = (0, store_1.readJournal)(repo, 'rama').state;
         const gen = (0, generations_1.activeGeneration)(s);
         gen.launchedAt = new Date(Date.now() - 3600000).toISOString();
@@ -77,15 +111,90 @@ describe('generaciones', () => {
         fs_1.default.mkdirSync((0, paths_1.logsDir)(repo, 'rama'), { recursive: true });
         fs_1.default.writeFileSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'rama'), gen.controllerJobId, gen.spawnNonce), '{}');
         expect((0, generations_1.controllerGenerationHasUnresolvedClaim)(repo, 'rama', gen)).toBe(true);
-        (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', 'continua', () => { }, 10000);
+        (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', recovery, () => { }, 10000);
         expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('IN_PROGRESS'); // claim recien creado: aun dentro de gracia
         const old = new Date(Date.now() - 20000);
         fs_1.default.utimesSync((0, exec_wrapper_1.claimPath)((0, paths_1.logsDir)(repo, 'rama'), gen.controllerJobId, gen.spawnNonce), old, old);
-        (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', 'continua', () => { }, 10000);
+        (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', recovery, () => { }, 10000);
         expect((0, store_1.readJournal)(repo, 'rama').state.cycle.status).toBe('BLOCKED');
         fs_1.default.writeFileSync((0, exec_wrapper_1.resultPath)((0, paths_1.logsDir)(repo, 'rama'), gen.controllerJobId, gen.spawnNonce), JSON.stringify({ exitCode: 1 }));
         expect((0, generations_1.controllerGenerationHasUnresolvedClaim)(repo, 'rama', gen)).toBe(false);
     });
+    test('replay preserves exact argv commitment and rejects environment command drift without mutation', () => {
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', recovery, () => { });
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        const previous = process.env.AWM_CONTROLLER_ARGV;
+        process.env.AWM_CONTROLLER_ARGV = JSON.stringify(['different-controller']);
+        try {
+            expect(() => (0, generations_1.ensureControllerGeneration)(repo, 'rama', 'codex', recovery, () => { }, 10000)).toThrow(/argv cambio/);
+            expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.AWM_CONTROLLER_ARGV;
+            else
+                process.env.AWM_CONTROLLER_ARGV = previous;
+        }
+    });
+    test('a real launched controller generation retains metadata but no prompt or source output', async () => {
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        const body = 'SOURCE_BODY_SENTINEL_private_controller_text';
+        const previous = process.env.AWM_CONTROLLER_ARGV;
+        process.env.AWM_CONTROLLER_ARGV = JSON.stringify([process.execPath, '-e', `process.stdout.write('${body}')`]);
+        let execution;
+        try {
+            (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', recovery, (job, nonce, logsRoot, repoRoot) => {
+                execution = (0, exec_wrapper_1.runExecWrapper)({ logsRoot, jobId: job.id, nonce, argv: job.argv, cwd: job.cwd, repoRoot });
+            });
+            await execution;
+            const state = (0, store_1.readJournal)(repo, 'rama').state;
+            expect(state.generations[0].launchArgvDigest).toMatch(/^[a-f0-9]{16}$/);
+            const artifacts = fs_1.default.readdirSync((0, paths_1.logsDir)(repo, 'rama')).map(name => fs_1.default.readFileSync(path_1.default.join((0, paths_1.logsDir)(repo, 'rama'), name), 'utf8')).join('\n');
+            expect(artifacts).toContain('argvDigest');
+            expect(artifacts).toContain('exitCode');
+            expect(artifacts + JSON.stringify(state)).not.toContain(body);
+            expect(artifacts + JSON.stringify(state)).not.toContain('Retoma el plan');
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.AWM_CONTROLLER_ARGV;
+            else
+                process.env.AWM_CONTROLLER_ARGV = previous;
+        }
+    });
+    test('a user verifier named like a controller keeps ordinary bounded output without generation proof', async () => {
+        const logsRoot = (0, paths_1.logsDir)(repo, 'rama');
+        const argv = [process.execPath, '-e', "process.stdout.write('ordinary-verifier-output')"];
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.jobs['controller-gen-1'] = { id: 'controller-gen-1', argv, spawnNonce: 'normal-verifier', fingerprint: 'fixture', commandDigest: 'fixture',
+            cwd: '.', paths: [], expandedPaths: [], executionState: 'spawn-intent', observationState: 'progressing', phaseTimestamps: {} };
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        await (0, exec_wrapper_1.runExecWrapper)({ logsRoot, repoRoot: repo, jobId: 'controller-gen-1', nonce: 'normal-verifier', cwd: '.',
+            argv });
+        const artifacts = fs_1.default.readdirSync(logsRoot).map(name => fs_1.default.readFileSync(path_1.default.join(logsRoot, name), 'utf8')).join('\n');
+        expect(artifacts).toContain('ordinary-verifier-output');
+    });
+    test.each(['missing', 'corrupt', 'symlink', 'oversized', 'nonce-drift', 'argv-drift'])('controller %s custody fails closed before claim or launch artifacts', async (fault) => {
+        (0, generations_1.beginGeneration)(repo, 'rama');
+        let launched;
+        (0, generations_1.launchControllerGeneration)(repo, 'rama', 'codex', recovery, (job, nonce) => { launched = { id: job.id, nonce, argv: job.argv }; });
+        const stateFile = path_1.default.resolve((0, paths_1.logsDir)(repo, 'rama'), '..', 'state.json');
+        if (fault === 'missing')
+            fs_1.default.unlinkSync(stateFile);
+        if (fault === 'corrupt')
+            fs_1.default.writeFileSync(stateFile, '{bad json');
+        if (fault === 'oversized')
+            fs_1.default.writeFileSync(stateFile, ' '.repeat(1024 * 1024 + 1));
+        if (fault === 'symlink') {
+            fs_1.default.renameSync(stateFile, `${stateFile}.original`);
+            fs_1.default.symlinkSync(`${stateFile}.original`, stateFile, 'file');
+        }
+        const argv = fault === 'argv-drift' ? [process.execPath, '-e', "process.stdout.write('source body')"] : launched.argv;
+        const nonce = fault === 'nonce-drift' ? 'wrong-nonce' : launched.nonce;
+        await expect((0, exec_wrapper_1.runExecWrapper)({ logsRoot: (0, paths_1.logsDir)(repo, 'rama'), repoRoot: repo, jobId: launched.id, nonce, argv, cwd: '.' })).rejects.toThrow(/controller|custody|custodia|bounded|regular/i);
+        expect(fs_1.default.readdirSync((0, paths_1.logsDir)(repo, 'rama'))).toEqual([]);
+    });
     test('resolveGeneration: muerte probada => proven-dead; vivo+indeterminate => custodia con estado BLOCKED (R4.2b)', async () => {
         const adapter = (0, adapter_1.adapterFor)('codex');
         (0, generations_1.beginGeneration)(repo, 'rama');