agentic-workflow-manager 9.7.0 → 9.8.0

package/dist/tests/commands/watch/plan-lifecycle.test.js

@@ -0,0 +1,263 @@
+"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 child_process_1 = require("child_process");
+const init_1 = require("../../../src/commands/watch/init");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const validate_1 = require("../../../src/core/plan/validate");
+const git_fixture_1 = require("../../helpers/git-fixture");
+const generations_1 = require("../../../src/commands/watch/generations");
+const requests_1 = require("../../../src/core/journal/requests");
+const request_1 = require("../../../src/commands/job/request");
+const fingerprint_1 = require("../../../src/core/journal/fingerprint");
+const supervisor_1 = require("../../../src/commands/watch/supervisor");
+const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
+const lock_1 = require("../../../src/commands/watch/lock");
+const archive_unused_1 = require("../../../src/commands/watch/archive-unused");
+jest.setTimeout(30000);
+function valid(repo) {
+    const report = (0, validate_1.validatePlanFile)('docs/plan.md', repo);
+    if (report.state !== 'valid')
+        throw new Error(JSON.stringify(report));
+    return report;
+}
+function cli(repo, ...args) {
+    return (0, child_process_1.spawnSync)(process.execPath, [path_1.default.resolve(__dirname, '../../../dist/src/index.js'), ...args], {
+        cwd: repo, encoding: 'utf8', env: { ...process.env, HOME: repo, AWM_HOME: path_1.default.join(repo, 'awm-home'), AWM_NO_UPDATE_CHECK: '1' },
+    });
+}
+describe('compact lifecycle proof and unused bootstrap archival', () => {
+    let repo;
+    beforeEach(() => {
+        repo = (0, git_fixture_1.initRepo)();
+        (0, git_fixture_1.commitFile)(repo, 'source.md', '## Canonical source\nfixture source\n');
+        fs_1.default.mkdirSync(path_1.default.join(repo, 'docs'));
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.awm/sensors.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'node -e "process.exit(0)"' } }));
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'docs/plan.md'), `${fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v1/valid.md'), 'utf8')}\n- [ ] Reviewed task.\n`);
+        (0, init_1.initWatch)(repo, 'main', { path: 'docs/plan.md', report: valid(repo) });
+    });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('durable journal retains hash commitments only, never the validated plan source body', () => {
+        const contents = (directory) => fs_1.default.readdirSync(directory, { withFileTypes: true }).map(entry => entry.isDirectory() ? contents(path_1.default.join(directory, entry.name)) : fs_1.default.readFileSync(path_1.default.join(directory, entry.name), 'utf8')).join('\n');
+        expect(contents((0, paths_1.journalDir)(repo, 'main'))).not.toContain('Reviewed task.');
+        expect((0, store_1.readJournal)(repo, 'main').state.planBinding).toMatchObject({ executionIdentitySchema: 'awm-plan-execution/v1', executionDigest: expect.stringMatching(/^[a-f0-9]{64}$/) });
+    });
+    test.each(['malformed', 'oversized', 'deep'])('CLI init rejects %s verifier inputs before mutating gitignore or journal', (kind) => {
+        const fresh = (0, git_fixture_1.initRepo)();
+        try {
+            (0, git_fixture_1.commitFile)(fresh, 'source.md', '## Canonical source\nfixture source\n');
+            fs_1.default.mkdirSync(path_1.default.join(fresh, 'docs'));
+            fs_1.default.copyFileSync(path_1.default.join(repo, 'docs/plan.md'), path_1.default.join(fresh, 'docs/plan.md'));
+            fs_1.default.writeFileSync(path_1.default.join(fresh, '.gitignore'), 'user-owned-ignore\n');
+            if (kind === 'malformed')
+                fs_1.default.writeFileSync(path_1.default.join(fresh, 'package.json'), '{invalid package');
+            if (kind === 'oversized')
+                fs_1.default.writeFileSync(path_1.default.join(fresh, 'package.json'), JSON.stringify({ padding: 'x'.repeat(256 * 1024) }));
+            if (kind === 'deep') {
+                let cursor = fresh;
+                for (let i = 0; i < 65; i++) {
+                    cursor = path_1.default.join(cursor, 'p');
+                    fs_1.default.mkdirSync(cursor);
+                }
+            }
+            const before = fs_1.default.readFileSync(path_1.default.join(fresh, '.gitignore'), 'utf8');
+            const rejected = cli(fresh, 'watch', '--init', '--plan', 'docs/plan.md');
+            expect(rejected.status).not.toBe(0);
+            expect(rejected.stderr).toMatch(/verifier scan/);
+            expect(fs_1.default.readFileSync(path_1.default.join(fresh, '.gitignore'), 'utf8')).toBe(before);
+            expect(fs_1.default.existsSync((0, paths_1.statePath)(fresh, 'main'))).toBe(false);
+            expect(JSON.parse(cli(fresh, 'watch', 'journal-status', '--json').stdout).state).toBe('missing');
+        }
+        finally {
+            fs_1.default.rmSync(fresh, { recursive: true, force: true });
+        }
+    });
+    test('CLI init rejects an existing linked journal segment before mutating gitignore', () => {
+        const fresh = (0, git_fixture_1.initRepo)();
+        try {
+            (0, git_fixture_1.commitFile)(fresh, 'source.md', '## Canonical source\nfixture source\n');
+            fs_1.default.mkdirSync(path_1.default.join(fresh, 'docs'));
+            fs_1.default.copyFileSync(path_1.default.join(repo, 'docs/plan.md'), path_1.default.join(fresh, 'docs/plan.md'));
+            fs_1.default.writeFileSync(path_1.default.join(fresh, '.gitignore'), 'user-owned-ignore\n');
+            fs_1.default.mkdirSync((0, paths_1.journalDir)(fresh, 'main'), { recursive: true });
+            fs_1.default.symlinkSync(path_1.default.join(fresh, 'docs'), (0, paths_1.requestsDir)(fresh, 'main'), 'junction');
+            const before = fs_1.default.readFileSync(path_1.default.join(fresh, '.gitignore'), 'utf8');
+            const rejected = cli(fresh, 'watch', '--init', '--plan', 'docs/plan.md');
+            expect(rejected.status).not.toBe(0);
+            expect(rejected.stderr).toMatch(/symlink/);
+            expect(fs_1.default.readFileSync(path_1.default.join(fresh, '.gitignore'), 'utf8')).toBe(before);
+            expect(fs_1.default.existsSync((0, paths_1.statePath)(fresh, 'main'))).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(fresh, { recursive: true, force: true });
+        }
+    });
+    test('CLI reconciles proved progress while IN_PROGRESS without fabricating completion', () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'docs/plan.md'), fs_1.default.readFileSync(path_1.default.join(repo, 'docs/plan.md'), 'utf8')
+            .replace('- [ ] Reviewed task.', '- [x] Reviewed task.')
+            .replace('#### Evidence', '<!-- awm-qa-complete: 2026-09-16 -->\n#### Evidence'));
+        const result = cli(repo, 'watch', 'rebind', '--plan', 'docs/plan.md');
+        expect(result.stderr).toBe('');
+        expect(result.status).toBe(0);
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        expect(state.cycle.status).toBe('IN_PROGRESS');
+        expect(state.cycle.completedAt).toBeUndefined();
+        expect(state.planBinding.digest).toBe(valid(repo).planDigest);
+        expect(state.planBindingHistory).toHaveLength(1);
+        expect(state.tasks).toEqual([]);
+        expect(state.verdicts).toEqual([]);
+    });
+    test.each([
+        ['source-scoped evidence', ['source.md'], 'complete'],
+        ['plan-inclusive evidence', [], 'custody'],
+    ])('real execution after CLI rebind: %s (%s) reaches %s without a COMPLETE fixture', async (_label, paths, expectedOutcome) => {
+        const generation = (0, generations_1.beginGeneration)(repo, 'main');
+        const supervisor = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10 }, (job, nonce, logsRoot, repoRoot) => {
+            // The external controller is the test itself; actual verification
+            // jobs still execute through the real wrapper and durable results.
+            if (job.argv[0] === 'codex')
+                return;
+            void (0, exec_wrapper_1.runExecWrapper)({ logsRoot, jobId: job.id, nonce, argv: job.argv, cwd: job.cwd, repoRoot });
+        }, undefined, async () => ({ state: 'admitted', planState: 'valid', executionMode: 'desatendido', journal: 'current', currentness: 'current', sensors: 'pass', diagnostics: [] }));
+        const emit = (id, payload) => (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: generation.token, idempotencyKey: id, payload });
+        emit('task', { entity: 'task', taskId: 'T1', title: 'Actual verification', verificationPlan: [{ id: 'tests', kind: 'test' }, { id: 'sensors', kind: 'sensors' }], reviewObligations: [{ id: 'spec', kind: 'spec' }, { id: 'quality', kind: 'quality' }] });
+        emit('cycle', { entity: 'cycle-plan', items: [{ id: 'qa', kind: 'qa' }, { id: 'interlock', kind: 'interlock' }] });
+        for (const id of ['tests', 'sensors'])
+            (0, request_1.requestJob)(repo, 'main', generation.token, [process.execPath, '-e', 'process.exit(0)'], paths, '.', { satisfies: id });
+        for (const obligationId of ['spec', 'quality']) {
+            const argv = ['awm-review', obligationId];
+            (0, requests_1.emitRequest)(repo, 'main', { kind: 'verdict', generationToken: generation.token, idempotencyKey: obligationId, payload: {
+                    verdictId: obligationId, obligationId, result: 'pass', detail: 'Real controller observation',
+                    fingerprint: (0, fingerprint_1.computeFingerprint)(repo, argv, ['source.md'], '.').fingerprint, argv, paths: ['source.md'], cwd: '.',
+                } });
+        }
+        for (let i = 0; i < 100; i++) {
+            expect(await supervisor.tick()).toBe('continue');
+            if (Object.values((0, store_1.readJournal)(repo, 'main').state.jobs).some(job => job.verdict === 'pass'))
+                break;
+            await new Promise(resolve => setTimeout(resolve, 20));
+        }
+        expect(Object.values((0, store_1.readJournal)(repo, 'main').state.jobs).every(job => job.executionState === 'exited' && job.verdict === 'pass')).toBe(true);
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'docs/plan.md'), fs_1.default.readFileSync(path_1.default.join(repo, 'docs/plan.md'), 'utf8')
+            .replace('- [ ] Reviewed task.', '- [x] Reviewed task.')
+            .replace('#### Evidence', '<!-- awm-qa-complete: 2026-09-16 -->\n<!-- awm-docs-complete: 2026-09-16 -->\n<!-- awm-retro-complete: 2026-09-16 -->\n#### Evidence'));
+        const rebound = cli(repo, 'watch', 'rebind', '--plan', 'docs/plan.md');
+        expect(rebound.stderr).toBe('');
+        expect(rebound.status).toBe(0);
+        if (expectedOutcome === 'custody')
+            expect(rebound.stdout).toMatch(/stale-fingerprint.*job request/);
+        for (const id of ['qa', 'interlock'])
+            (0, request_1.requestJob)(repo, 'main', generation.token, [process.execPath, '-e', 'process.exit(0)'], ['source.md'], '.', { satisfies: id });
+        emit('done', { entity: 'task-status', taskId: 'T1', status: 'done' });
+        let outcome = 'continue';
+        for (let i = 0; i < 100 && outcome === 'continue'; i++) {
+            outcome = await supervisor.tick();
+            await new Promise(resolve => setTimeout(resolve, 20));
+        }
+        expect(outcome).toBe(expectedOutcome);
+        const final = (0, store_1.readJournal)(repo, 'main').state;
+        expect(final.cycle.status).toBe(expectedOutcome === 'complete' ? 'COMPLETE' : 'BLOCKED');
+        if (expectedOutcome === 'complete')
+            expect(final.cycle.completedAt).toEqual(expect.any(String));
+        else {
+            expect(final.cycle.completedAt).toBeUndefined();
+            expect(final.cycle.blockedReason).toMatch(/stale-fingerprint.*job request/);
+        }
+        expect(final.tasks[0].status).toBe('done');
+        expect(final.verdicts).toHaveLength(2);
+        expect(Object.values(final.jobs).every(job => job.executionState === 'exited' && job.verdict === 'pass')).toBe(true);
+    });
+    test('public current-branch status distinguishes missing, corrupt and unused without exporting bodies', () => {
+        const present = cli(repo, 'watch', 'journal-status', '--json');
+        expect(present.status).toBe(0);
+        expect(JSON.parse(present.stdout)).toMatchObject({ state: 'present', cycleState: 'IN_PROGRESS', bootstrapUnused: true });
+        expect(present.stdout).not.toContain('Reviewed task.');
+        const state = (0, paths_1.statePath)(repo, 'main');
+        const before = fs_1.default.readFileSync(state, 'utf8');
+        fs_1.default.writeFileSync(state, '{corrupt');
+        expect(JSON.parse(cli(repo, 'watch', 'journal-status', '--json').stdout)).toEqual({ state: 'corrupt', bootstrapUnused: false });
+        fs_1.default.writeFileSync(state, before);
+        expect(cli(repo, 'watch', 'archive-unused', '--plan', 'docs/plan.md').status).toBe(0);
+        expect(JSON.parse(cli(repo, 'watch', 'journal-status', '--json').stdout)).toEqual({ state: 'missing', bootstrapUnused: false });
+    });
+    test.each([
+        ['requirements', (text) => text.replace(/RF-1\.3/g, 'RF-1.4')],
+        ['argv', (text) => text.replace('"test"', '"build"')],
+        ['source fact', (text) => text.replace('intentionally small and stable', 'changed fact')],
+        ['prose', (text) => text.replace('only surfaces', 'changed surfaces')],
+        ['mode', (text) => text.replace('desatendido', 'interactivo')],
+    ])('rejects %s change and preserves the entire prior journal', (_label, edit) => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'docs/plan.md'), edit(fs_1.default.readFileSync(path_1.default.join(repo, 'docs/plan.md'), 'utf8')));
+        const before = (0, store_1.readJournal)(repo, 'main').raw;
+        expect(() => (0, init_1.rebindWatchPlan)(repo, 'main', { path: 'docs/plan.md', report: valid(repo) })).toThrow();
+        expect((0, store_1.readJournal)(repo, 'main').raw).toBe(before);
+    });
+    test('archives unused bootstrap recoverably via CLI without COMPLETE or cycle evidence', () => {
+        const before = (0, store_1.readJournal)(repo, 'main').raw;
+        const result = cli(repo, 'watch', 'archive-unused', '--plan', 'docs/plan.md');
+        expect(result.stderr).toBe('');
+        expect(result.status).toBe(0);
+        const archived = JSON.parse(result.stdout).archived;
+        expect(fs_1.default.readFileSync(path_1.default.join(repo, archived, 'state.json'), 'utf8')).toBe(before);
+        expect(JSON.parse(before).cycle.status).toBe('IN_PROGRESS');
+        expect(fs_1.default.existsSync((0, paths_1.statePath)(repo, 'main'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(repo, '.awm/evidence'))).toBe(false);
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(false);
+    });
+    test('archive refuses one durable task and leaves source journal intact', () => {
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        state.tasks.push({ id: 'T1', title: 'Actual work', status: 'pending', attempts: 0, verificationPlan: [], reviewObligations: [] });
+        (0, store_1.writeJournal)(repo, 'main', state);
+        const before = (0, store_1.readJournal)(repo, 'main').raw;
+        const result = cli(repo, 'watch', 'archive-unused', '--plan', 'docs/plan.md');
+        expect(result.status).not.toBe(0);
+        expect(result.stderr).toMatch(/unused|bootstrap|utilizado/i);
+        expect((0, store_1.readJournal)(repo, 'main').raw).toBe(before);
+    });
+    test('archive refuses a pending request or a symlink artifact', () => {
+        fs_1.default.writeFileSync(path_1.default.join((0, paths_1.requestsDir)(repo, 'main'), 'pending.json'), '{}');
+        const before = (0, store_1.readJournal)(repo, 'main').raw;
+        const result = cli(repo, 'watch', 'archive-unused', '--plan', 'docs/plan.md');
+        expect(result.status).not.toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').raw).toBe(before);
+        fs_1.default.rmSync(path_1.default.join((0, paths_1.requestsDir)(repo, 'main'), 'pending.json'));
+        fs_1.default.symlinkSync(path_1.default.join(repo, 'source.md'), path_1.default.join((0, paths_1.journalDir)(repo, 'main'), 'outside'));
+        const linked = cli(repo, 'watch', 'archive-unused', '--plan', 'docs/plan.md');
+        expect(linked.status).not.toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').raw).toBe(before);
+    });
+    test('archive obeys the real supervisor lock and rejects unknown optional runtime state', () => {
+        const before = (0, store_1.readJournal)(repo, 'main').raw;
+        const lock = (0, lock_1.acquireLock)(repo);
+        try {
+            expect(() => (0, archive_unused_1.archiveUnusedWatch)(repo, 'main', 'docs/plan.md')).toThrow(/supervisor activo/i);
+        }
+        finally {
+            (0, lock_1.releaseLock)(repo, lock);
+        }
+        expect((0, store_1.readJournal)(repo, 'main').raw).toBe(before);
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        state.controllerHeartbeatAt = new Date().toISOString();
+        (0, store_1.writeJournal)(repo, 'main', state);
+        expect(() => (0, archive_unused_1.archiveUnusedWatch)(repo, 'main', 'docs/plan.md')).toThrow(/no reconocido|unused/i);
+    });
+    test('a rename failure preserves active journal and releases its lock', () => {
+        const before = (0, store_1.readJournal)(repo, 'main').raw;
+        const rename = jest.spyOn(fs_1.default, 'renameSync').mockImplementation(() => { throw new Error('injected rename failure'); });
+        try {
+            expect(() => (0, archive_unused_1.archiveUnusedWatch)(repo, 'main', 'docs/plan.md')).toThrow('injected rename failure');
+        }
+        finally {
+            rename.mockRestore();
+        }
+        expect((0, store_1.readJournal)(repo, 'main').raw).toBe(before);
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(false);
+    });
+});