agentic-workflow-manager 9.19.0 → 9.20.1

package/dist/tests/core/changes/worktree.test.js

@@ -0,0 +1,259 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = __importStar(require("child_process"));
+const helpers_1 = require("./helpers");
+const worktree_1 = require("../../../src/core/changes/worktree");
+const ENV_KEYS = ['HOME', 'AWM_HOME', 'GIT_CONFIG_GLOBAL', 'GIT_CONFIG_NOSYSTEM'];
+const ORIGINAL = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+let saved = {};
+let root;
+let home;
+// Jest's sandboxed `process.env` is a copy that children do not see, so the child's environment is passed explicitly.
+const gitEnv = () => ({ ...process.env, HOME: home, GIT_CONFIG_GLOBAL: path_1.default.join(home, 'gitconfig'), GIT_AUTHOR_NAME: 't', GIT_AUTHOR_EMAIL: 't@t', GIT_COMMITTER_NAME: 't', GIT_COMMITTER_EMAIL: 't@t', GIT_CONFIG_NOSYSTEM: '1' });
+const g = (...args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd: root, encoding: 'utf8', env: gitEnv() }).trim();
+const real = child_process_1.default.execFileSync;
+let spy;
+beforeEach(() => {
+    saved = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-home-'));
+    Object.assign(process.env, { HOME: home, AWM_HOME: path_1.default.join(home, '.awm'), GIT_CONFIG_GLOBAL: (0, helpers_1.emptyGitConfig)(home), GIT_CONFIG_NOSYSTEM: '1' });
+    root = fs_1.default.realpathSync.native(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-wt-')));
+    g('init', '-q', '-b', 'main');
+    fs_1.default.writeFileSync(path_1.default.join(root, 'a.txt'), 'a');
+    g('add', '.');
+    g('commit', '-q', '-m', 'feat: a');
+});
+afterEach(() => {
+    spy?.mockRestore();
+    spy = undefined;
+    for (const [k, v] of Object.entries(saved)) {
+        if (v === undefined)
+            delete process.env[k];
+        else
+            process.env[k] = v;
+    }
+    fs_1.default.rmSync(root, { recursive: true, force: true });
+    fs_1.default.rmSync(home, { recursive: true, force: true });
+});
+afterAll(() => {
+    // The environment the suite started with is back, so nothing leaks into the next test file.
+    for (const k of ENV_KEYS)
+        expect(process.env[k]).toBe(ORIGINAL[k]);
+});
+/** Intercepts git invocations whose first argument is `first`; every other call reaches the real git. */
+const intercept = (first, handler) => {
+    spy = jest.spyOn(child_process_1.default, 'execFileSync').mockImplementation(((cmd, args, opts) => {
+        if (cmd === 'git' && args[0] === first)
+            return handler(opts, args);
+        return real(cmd, args, opts);
+    }));
+};
+const fail = (code) => () => { throw Object.assign(new Error(`spawnSync git ${code}`), { code }); };
+describe('worktree state', () => {
+    test('R2.x isolation: HOME and AWM_HOME point at a throwaway directory, never the real ones', () => {
+        expect(process.env.HOME).toBe(home);
+        expect(process.env.HOME).not.toBe(ORIGINAL.HOME);
+        expect(process.env.AWM_HOME).toBe(path_1.default.join(home, '.awm'));
+        expect(process.env.AWM_HOME).not.toBe(ORIGINAL.AWM_HOME);
+        expect(process.env.GIT_CONFIG_GLOBAL).toBe(path_1.default.join(home, 'gitconfig'));
+        expect(fs_1.default.readFileSync(path_1.default.join(home, 'gitconfig'), 'utf8')).toBe('');
+        expect(process.env.GIT_CONFIG_NOSYSTEM).toBe('1');
+    });
+    test('the runtime-state exclusion list is exactly the local state paths', () => {
+        expect([...worktree_1.RUNTIME_STATE_EXCLUDES]).toEqual(['.awm/sensors/runs', '.awm/journal', '.awm/ledger', '.awm/evidence', '.awm/track.json']);
+    });
+    test('a clean repository reports its root, HEAD and a clean tree', () => {
+        const state = (0, worktree_1.gitState)(root, true);
+        expect(state.kind).toBe('ok');
+        if (state.kind === 'ok') {
+            expect(fs_1.default.realpathSync.native(state.root)).toBe(fs_1.default.realpathSync.native(root));
+            expect(state.commit).toBe(g('rev-parse', 'HEAD'));
+            expect(state.dirty).toBe(false);
+        }
+    });
+    test('the root is normalized with native separators', () => {
+        intercept('rev-parse', (opts, args) => (args[1] === '--show-toplevel' ? `${root}${path_1.default.sep}.${path_1.default.sep}\n` : real('git', args, opts)));
+        const state = (0, worktree_1.gitState)(root, true);
+        expect(state.kind === 'ok' && state.root).toBe(path_1.default.resolve(root));
+    });
+    test('an untracked file is dirty for the pre-run measure and clean for the post-run recheck', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'new.ts'), 'x');
+        const pre = (0, worktree_1.gitState)(root, true);
+        const post = (0, worktree_1.gitState)(root, false);
+        expect(pre.kind === 'ok' && pre.dirty).toBe(true);
+        expect(post.kind === 'ok' && post.dirty).toBe(false);
+    });
+    test('the pre-run measure sees untracked files even when status.showUntrackedFiles is no', () => {
+        g('config', 'status.showUntrackedFiles', 'no');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'new.ts'), 'x');
+        const pre = (0, worktree_1.gitState)(root, true);
+        expect(pre.kind === 'ok' && pre.dirty).toBe(true);
+    });
+    test('a tracked change is dirty for both measures', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'a.txt'), 'changed');
+        const pre = (0, worktree_1.gitState)(root, true);
+        const post = (0, worktree_1.gitState)(root, false);
+        expect(pre.kind === 'ok' && pre.dirty).toBe(true);
+        expect(post.kind === 'ok' && post.dirty).toBe(true);
+    });
+    test.each(worktree_1.RUNTIME_STATE_EXCLUDES.map((p) => [p]))('an untracked file at %s is not a change', (rel) => {
+        fs_1.default.mkdirSync(path_1.default.dirname(path_1.default.join(root, rel)), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, rel), 'x');
+        const pre = (0, worktree_1.gitState)(root, true);
+        expect(pre.kind === 'ok' && pre.dirty).toBe(false);
+    });
+    test('extra exclusions hide changes under them, on top of the runtime-state ones', () => {
+        fs_1.default.mkdirSync(path_1.default.join(root, 'docs/changes'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'docs/changes/r.md'), 'r');
+        const without = (0, worktree_1.gitState)(root, true);
+        const withExtra = (0, worktree_1.gitState)(root, true, ['docs/changes']);
+        expect(without.kind === 'ok' && without.dirty).toBe(true);
+        expect(withExtra.kind === 'ok' && withExtra.dirty).toBe(false);
+        fs_1.default.writeFileSync(path_1.default.join(root, 'other.ts'), 'x');
+        const stillDirty = (0, worktree_1.gitState)(root, true, ['docs/changes']);
+        expect(stillDirty.kind === 'ok' && stillDirty.dirty).toBe(true);
+    });
+    test('extra exclusions keep the runtime-state exclusions', () => {
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm/journal'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm/journal/j.json'), 'x');
+        const state = (0, worktree_1.gitState)(root, true, ['docs/changes']);
+        expect(state.kind === 'ok' && state.dirty).toBe(false);
+    });
+    test.each([['docs/changes'], [[7]], [['../out']], [['a\nb']], [['/abs']], [[' pad']], [Array.from({ length: 65 }, (_, i) => `d${i}`)]])('unsafe extra exclusions %j are a failure, never a throw', (extra) => {
+        expect((0, worktree_1.gitState)(root, true, extra)).toEqual({ kind: 'failed' });
+    });
+    test('GIT_*_PATHSPECS variables in the environment do not change the exclusions', () => {
+        fs_1.default.mkdirSync(path_1.default.join(root, 'docs/changes'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'docs/changes/r.md'), 'r');
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm/journal'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm/journal/j.json'), 'x');
+        const saved = process.env.GIT_LITERAL_PATHSPECS;
+        process.env.GIT_LITERAL_PATHSPECS = '1';
+        try {
+            const state = (0, worktree_1.gitState)(root, true, ['docs/changes']);
+            expect(state.kind === 'ok' && state.dirty).toBe(false);
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.GIT_LITERAL_PATHSPECS;
+            else
+                process.env.GIT_LITERAL_PATHSPECS = saved;
+        }
+    });
+    describe('a submodule change is a change whatever the configuration says', () => {
+        // Offline: vendor/sm is a nested repository registered as a gitlink, hidden by .gitmodules `ignore = all` and diff.ignoreSubmodules=all.
+        let sm = '';
+        let commitInSm = () => '';
+        const registerHiddenSubmodule = () => {
+            const hidden = (0, helpers_1.makeHiddenSubmodule)(root, (cwd, ...args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd, encoding: 'utf8', env: gitEnv() }).trim());
+            sm = hidden.dir;
+            commitInSm = hidden.commitInSm;
+        };
+        test('a clean tree holding a submodule is clean', () => {
+            registerHiddenSubmodule();
+            const state = (0, worktree_1.gitState)(root, true);
+            expect(state.kind === 'ok' && state.dirty).toBe(false);
+        });
+        test('an untracked file inside a clean submodule: the post-run recheck ignores it, the pre-run measure counts it', () => {
+            registerHiddenSubmodule();
+            fs_1.default.writeFileSync(path_1.default.join(sm, 'coverage.out'), 'x'); // what a sensor leaves behind
+            const post = (0, worktree_1.gitState)(root, false);
+            const pre = (0, worktree_1.gitState)(root, true);
+            expect(post.kind === 'ok' && post.dirty).toBe(false);
+            // git reports the submodule itself as modified (untracked content) in the normal-untracked mode, so the pre-run measure is dirty.
+            expect(pre.kind === 'ok' && pre.dirty).toBe(true);
+        });
+        test.each([[true], [false]])('modified tracked content inside a submodule makes the tree dirty (untracked=%p)', (untracked) => {
+            registerHiddenSubmodule();
+            fs_1.default.writeFileSync(path_1.default.join(sm, 'one'), 'changed');
+            const state = (0, worktree_1.gitState)(root, untracked);
+            expect(state.kind === 'ok' && state.dirty).toBe(true);
+        });
+        test.each([[true], [false]])('a submodule checked out at another commit than the gitlink makes the tree dirty (untracked=%p)', (untracked) => {
+            registerHiddenSubmodule();
+            commitInSm('two');
+            const state = (0, worktree_1.gitState)(root, untracked);
+            expect(state.kind === 'ok' && state.dirty).toBe(true);
+        });
+    });
+    test('a non-string or empty cwd is a failure, never a throw', () => {
+        expect((0, worktree_1.gitState)(undefined, true)).toEqual({ kind: 'failed' });
+        expect((0, worktree_1.gitState)('', true)).toEqual({ kind: 'failed' });
+    });
+    test('a directory outside git is not-repo', () => {
+        const plain = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-plain-'));
+        try {
+            expect((0, worktree_1.gitState)(plain, true)).toEqual({ kind: 'not-repo' });
+        }
+        finally {
+            fs_1.default.rmSync(plain, { recursive: true, force: true });
+        }
+    });
+    test('a repository without a commit is not-repo', () => {
+        const empty = fs_1.default.realpathSync.native(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-')));
+        try {
+            (0, child_process_1.execFileSync)('git', ['init', '-q', '-b', 'main'], { cwd: empty, env: gitEnv() });
+            expect((0, worktree_1.gitState)(empty, true)).toEqual({ kind: 'not-repo' });
+        }
+        finally {
+            fs_1.default.rmSync(empty, { recursive: true, force: true });
+        }
+    });
+    test.each([['ENOBUFS'], ['ETIMEDOUT']])('a %s from git status is a failure, not a missing repository', (code) => {
+        intercept('status', fail(code));
+        expect((0, worktree_1.gitState)(root, true)).toEqual({ kind: 'failed' });
+    });
+    test('git missing from PATH is a failure', () => {
+        intercept('rev-parse', fail('ENOENT'));
+        expect((0, worktree_1.gitState)(root, true)).toEqual({ kind: 'failed' });
+    });
+    test('git status gets a 64 MiB buffer', () => {
+        let seen;
+        intercept('status', (opts) => { seen = opts.maxBuffer; throw Object.assign(new Error('stop'), { code: 'ENOBUFS' }); });
+        (0, worktree_1.gitState)(root, true);
+        expect(seen).toBeGreaterThanOrEqual(64 * 1024 * 1024);
+    });
+    test('the reasons are the stable user-facing strings', () => {
+        expect(worktree_1.REASON_NOT_REPO).toBe('not inside a git repository with a commit');
+        expect(worktree_1.REASON_GIT_FAILED).toBe('git command failed or timed out');
+    });
+});

package/dist/tests/core/dashboard/write-html.test.js

@@ -7,6 +7,7 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const write_html_1 = require("../../../src/core/dashboard/write-html");
+const platform_1 = require("../../helpers/platform");
 describe('writeHtmlAtomically', () => {
     let root;
     beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-html-')); });
@@ -85,9 +86,7 @@ describe('writeHtmlAtomically', () => {
             open.mockRestore();
         }
     });
-    it('uses mode 0600 for a POSIX adjacent temporary file', () => {
-        if (process.platform === 'win32')
-            return;
+    (0, platform_1.posixOnly)('uses mode 0600 for a POSIX adjacent temporary file', () => {
         const target = path_1.default.join(root, 'posix.html');
         const open = jest.spyOn(fs_1.default, 'openSync');
         try {

package/dist/tests/core/evidence/store.test.js

@@ -8,6 +8,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const evidence_fixtures_1 = require("../../helpers/evidence-fixtures");
 const store_1 = require("../../../src/core/evidence/store");
+const platform_1 = require("../../helpers/platform");
 describe('cycle evidence store', () => {
     let root;
     beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-')); });
@@ -20,9 +21,7 @@ describe('cycle evidence store', () => {
         expect(fs_1.default.readdirSync(dir)).toEqual([`${evidence.cycleId}.json`]);
         expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, `${evidence.cycleId}.json`), 'utf8')).qa.fixes).toBe(0);
     });
-    test('rejects symlinked evidence ancestors without writing outside root', () => {
-        if (process.platform === 'win32')
-            return;
+    (0, platform_1.posixOnly)('rejects symlinked evidence ancestors without writing outside root', () => {
         const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-outside-'));
         fs_1.default.symlinkSync(outside, path_1.default.join(root, '.awm'));
         expect(() => (0, store_1.writeCycleEvidence)(root, (0, evidence_fixtures_1.cycleEvidenceFixture)())).toThrow(/symlink/);

package/dist/tests/core/ledger/store.test.js

@@ -8,6 +8,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const store_1 = require("../../../src/core/ledger/store");
 const types_1 = require("../../../src/core/ledger/types");
+const platform_1 = require("../../helpers/platform");
 function mkTmp() {
     return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ledger-'));
 }
@@ -191,18 +192,11 @@ describe('ledger store — archive', () => {
         expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([expect.objectContaining({ signature: 'active-evidence' })]);
         expect(fs_1.default.readFileSync(archivePath, 'utf-8')).toContain('archived-evidence');
     });
-    test('refuses a dangling symlink archive destination and preserves the active ledger', () => {
+    (0, platform_1.symlinkTest)('refuses a dangling symlink archive destination and preserves the active ledger', () => {
         (0, store_1.addEntry)(cwd, entry({ signature: 'active-evidence' }));
         const archivePath = path_1.default.join(cwd, '.awm', 'ledger', 'archive', 'feat-x-20260606T000000.jsonl');
         fs_1.default.mkdirSync(path_1.default.dirname(archivePath), { recursive: true });
-        try {
-            fs_1.default.symlinkSync(path_1.default.join(cwd, 'missing-target.jsonl'), archivePath);
-        }
-        catch (error) {
-            if (process.platform === 'win32')
-                return;
-            throw error;
-        }
+        fs_1.default.symlinkSync(path_1.default.join(cwd, 'missing-target.jsonl'), archivePath);
         expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000')).toThrow(/archive.*already exists/i);
         expect(fs_1.default.lstatSync(archivePath).isSymbolicLink()).toBe(true);
         expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([expect.objectContaining({ signature: 'active-evidence' })]);

package/dist/tests/core/process/discover.test.js

@@ -66,6 +66,27 @@ describe('discoverProcessModels', () => {
         expect(r.models.map((m) => m.name)).toEqual(['mi-proceso']);
         expect(r.diagnostics).toEqual([]);
     });
+    it('description sobrevive parse → discover, tal cual la lee YAML', () => {
+        const saved = { HOME: process.env.HOME, AWM_HOME: process.env.AWM_HOME };
+        process.env.HOME = path_1.default.join(tmp, 'home');
+        process.env.AWM_HOME = path_1.default.join(tmp, 'home', '.awm');
+        try {
+            const root = registry(path_1.default.join(tmp, 'rd'), {
+                'con-desc': FIXTURE.replace('NAME', 'con-desc').replace('created:', 'description: "Use when: tracing\\u00A0"\ncreated:'),
+            });
+            const r = (0, discover_1.discoverProcessModels)([root]);
+            expect(r.diagnostics).toEqual([]);
+            expect(r.models.map((m) => m.description)).toEqual(['Use when: tracing ']);
+        }
+        finally {
+            for (const [k, v] of Object.entries(saved)) {
+                if (v === undefined)
+                    delete process.env[k];
+                else
+                    process.env[k] = v;
+            }
+        }
+    });
     it('un modelo roto no impide descubrir los sanos', () => {
         const root = registry(path_1.default.join(tmp, 'r2'), {
             'sano': FIXTURE.replace('NAME', 'sano'),