agentic-workflow-manager 9.6.0 → 9.7.0

package/dist/tests/commands/watch/track-remove-request.test.js

@@ -0,0 +1,165 @@
+"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 git_fixture_1 = require("../../helpers/git-fixture");
+const tracks_1 = require("../../../src/commands/watch/tracks");
+const apply_1 = require("../../../src/commands/watch/apply");
+const emit_1 = require("../../../src/commands/track/emit");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const BRANCH = 'main';
+describe('awm track remove -> fallback teardown', () => {
+    let planRoot;
+    let baseSha;
+    beforeEach(() => {
+        planRoot = (0, git_fixture_1.initRepo)();
+        (0, git_fixture_1.commitFile)(planRoot, '.gitignore', '.awm/\n');
+        baseSha = (0, git_fixture_1.commitFile)(planRoot, 'seed.txt', 'seed');
+        (0, store_1.initJournal)(planRoot, BRANCH);
+    });
+    afterEach(() => fs_1.default.rmSync(planRoot, { recursive: true, force: true }));
+    function declareCohort(cohortPhase = 'ACTIVE') {
+        const state = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        state.cohortPhase = cohortPhase;
+        state.cohortBaseSha = baseSha;
+        state.tracks = ['a', 'b'].map((trackId) => ({
+            trackId, worktreePath: path_1.default.join(planRoot, `../nope-${trackId}`), branch: `awm-track/${trackId}`,
+            ownership: [], sharedResources: [], dependsOn: [], fencingToken: `fence-${trackId}`.padEnd(32, '0'),
+            phase: 'ACTIVE', readinessNonce: `ready-${trackId}`.padEnd(32, '0'),
+        }));
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        return (0, store_1.readJournal)(planRoot, BRANCH).state;
+    }
+    function inertRuntime() {
+        const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+        return { ...real,
+            addWorktree: () => { throw new Error('no external mutation expected'); },
+            initTrackJournal: () => { throw new Error('no external mutation expected'); },
+            spawnSupervisor: () => { throw new Error('no external mutation expected'); },
+            stopOwnSupervisor: () => { throw new Error('no external mutation expected'); },
+            removeOwnedWorktree: () => { throw new Error('no external mutation expected'); },
+            removeOwnedBranch: () => { throw new Error('no external mutation expected'); },
+        };
+    }
+    function events() {
+        if (!fs_1.default.existsSync((0, paths_1.eventsPath)(planRoot, BRANCH)))
+            return [];
+        return fs_1.default.readFileSync((0, paths_1.eventsPath)(planRoot, BRANCH), 'utf8').trim().split('\n').filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    it('consume el marker antes que join y persiste fallback cohort-wide (TR-REQ-03, TR-REQ-04)', async () => {
+        const state = declareCohort();
+        state.tracks[0].joinRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'b');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        // Consumir el marcador es su propia frontera durable: el teardown
+        // empieza recién en la siguiente llamada.
+        expect(out.effectExecuted).toBeNull();
+        expect(out.state.cohortFallbackReason).toBe('controller-requested:b');
+        expect(out.state.tracks?.find((track) => track.trackId === 'b')?.teardownRequested)
+            .toBeUndefined();
+        expect(events().some((event) => event.kind === 'track-teardown-observed' && event.trackId === 'b'))
+            .toBe(true);
+    });
+    it('un marker sobreviviente a restart converge por el mismo reducer (TR-REQ-07)', async () => {
+        const state = declareCohort();
+        state.tracks[0].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(out.state.tracks[0].teardownRequested).toBeUndefined();
+    });
+    it.each(['SERIAL', 'COMPLETE'])('consume remove tardío como moot en %s (TR-REQ-09)', async (phase) => {
+        const state = declareCohort(phase);
+        for (const track of state.tracks) {
+            track.phase = phase === 'SERIAL' ? 'REMOVED' : 'JOINED';
+            track.frozenHeadSha = phase === 'COMPLETE' ? baseSha : undefined;
+        }
+        state.tracks[0].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe(phase);
+        expect(out.state.tracks[0].teardownRequested).toBeUndefined();
+        expect(events()).toContainEqual(expect.objectContaining({ kind: 'track-teardown-moot', trackId: 'a', phase }));
+    });
+    it('una request en cohorte BLOCKED es moot y no reabre fallback', async () => {
+        const state = declareCohort('BLOCKED');
+        state.tracks[0].phase = 'BLOCKED';
+        state.tracks[1].phase = 'REMOVED';
+        state.tracks[1].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.effectExecuted).toBeNull();
+        expect(out.state.cohortPhase).toBe('BLOCKED');
+        expect(out.state.tracks[1].teardownRequested).toBeUndefined();
+        expect(events()).toContainEqual(expect.objectContaining({ kind: 'track-teardown-moot', trackId: 'b', phase: 'BLOCKED' }));
+    });
+    it('consume exactamente un marcador de teardown por reconcile antes de begin-teardown (issue #93)', async () => {
+        const s = declareCohort('ACTIVE');
+        s.tracks.forEach((track) => { track.teardownRequested = true; });
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        const first = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(first.effectExecuted).toBeNull();
+        expect(first.state.tracks?.find((track) => track.trackId === 'a')?.teardownRequested).toBeUndefined();
+        expect(first.state.tracks?.find((track) => track.trackId === 'b')?.teardownRequested).toBe(true);
+        const second = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, first.state, inertRuntime(), 2);
+        expect(second.effectExecuted).toBeNull();
+        expect(second.state.tracks?.every((track) => track.teardownRequested === undefined)).toBe(true);
+    });
+    it('una request repetida durante teardown no rebobina fases ni ejecuta trabajo destructivo (issue #93)', async () => {
+        declareCohort('ACTIVE');
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        const afterFirst = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g2', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g2');
+        const repeated = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(afterFirst.state.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('TEARDOWN_REQUESTED');
+        expect(repeated.effectExecuted).toBeNull();
+        expect(repeated.state.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('TEARDOWN_REQUESTED');
+        expect(repeated.state.cohortPhase).toBe('FALLBACK_PENDING');
+    });
+    it('request durante FINAL_INTERLOCK persiste fallback sin evidencia final stale (issue #93)', async () => {
+        const s = declareCohort('FINAL_INTERLOCK');
+        for (const track of s.tracks)
+            track.phase = 'MERGED_UNVERIFIED';
+        for (const track of s.tracks)
+            track.frozenHeadSha = `${track.trackId}-head`;
+        s.globalQaHeadSha = 'qa-head';
+        s.finalIntegrationJobId = 'integration-job';
+        s.qaFinalizeRequested = { headSha: 'qa-head', at: new Date().toISOString() };
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        let releases = 0;
+        const runtime = { ...inertRuntime(), releaseIntegrationLockIfHeld: () => { releases += 1; } };
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, runtime, 2);
+        const durable = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(durable.globalQaHeadSha).toBeUndefined();
+        expect(durable.finalIntegrationJobId).toBeUndefined();
+        expect(durable.qaFinalizeRequested).toBeUndefined();
+        expect(durable.tracks?.every((track) => track.phase === 'TEARDOWN_REQUESTED')).toBe(true);
+        expect(releases).toBe(1);
+    });
+    it('un probe de branch indemostrable detiene teardown sin serializar (issue #93)', async () => {
+        const s = declareCohort('FALLBACK_PENDING');
+        s.tracks[0].phase = 'WORKTREE_REMOVED';
+        s.tracks[1].phase = 'REMOVED';
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        const gitDir = path_1.default.join(planRoot, '.git');
+        fs_1.default.renameSync(gitDir, `${gitDir}.unavailable`);
+        await expect((0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH), 2)).rejects.toThrow(/indemostrable/);
+        fs_1.default.renameSync(`${gitDir}.unavailable`, gitDir);
+        const durable = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(durable.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(durable.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('WORKTREE_REMOVED');
+    });
+});

package/dist/tests/commands/watch/track-teardown-crash.test.js

@@ -23,6 +23,8 @@ const child_process_1 = require("child_process");
 const git_fixture_1 = require("../../helpers/git-fixture");
 const tracks_1 = require("../../../src/commands/watch/tracks");
 const store_1 = require("../../../src/core/journal/store");
+const apply_1 = require("../../../src/commands/watch/apply");
+const emit_1 = require("../../../src/commands/track/emit");
 const git_1 = require("../../../src/core/tracks/git");
 const descriptor_1 = require("../../../src/core/tracks/descriptor");
 const BRANCH = 'main';
@@ -263,6 +265,31 @@ describe('reconcileTracks — crash/restart de teardown con git real (Task 13, R
         expect(fs_1.default.existsSync(path_1.default.join(root, 'track-a'))).toBe(false);
         expect(branchListed(planRoot, 'awm-track/a')).toBe(false);
     });
+    test('request bridge sobrevive crash tras el marcador y converge a SERIAL sin repetir remociones (issue #93)', async () => {
+        let s = declareCohort(planRoot, root, baseSha);
+        materializeTrackA(s);
+        s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        s.cohortPhase = 'PREPARING';
+        s.tracks = s.tracks.map((track) => track.trackId === 'a'
+            ? { ...track, phase: 'WORKTREE_CREATED', supervisorProcessRef: deadRef() }
+            : track);
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        expect((0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1').applied).toBe(1);
+        // Crash immediately after the request marker becomes the durable
+        // protocol observation: no teardown effect has run yet.
+        s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, buildRuntime(planRoot, []), 2)).state;
+        expect(trackA(s).phase).toBe('TEARDOWN_REQUESTED');
+        const effects = [];
+        const restarted = buildRuntime(planRoot, effects);
+        for (let i = 0; i < 20 && s.cohortPhase !== 'SERIAL'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, restarted, 2)).state;
+        }
+        expect(s.cohortPhase).toBe('SERIAL');
+        expect(trackA(s).phase).toBe('REMOVED');
+        expect(effects.filter((effect) => effect === 'worktree-effect:a')).toHaveLength(1);
+        expect(effects.filter((effect) => effect === 'branch-effect:awm-track/a')).toHaveLength(1);
+    });
     // R4.6/R4.10/C9: un worktree cuyo ownership es indemostrable (descriptor
     // ausente/corrupto, o simplemente no es el que `teardownIntent` espera)
     // NUNCA se adopta ni se borra — el track se bloquea, y el contenido

package/dist/tests/core/context/orchestrator.test.js

@@ -255,6 +255,8 @@ describe('InjectionOrchestrator (declared orchestrators from an installed regist
         const registryRoot = (0, registries_1.registryContentRoot)('declaring');
         fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/using-awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md'), '---\nversion: "1.0.0"\n---\nBODY');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/mi-proceso'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/mi-proceso/SKILL.md'), '---\nname: mi-proceso\n---\n');
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({
             orchestrator: { name: 'mi-proceso', appliesWhen: 'al arrancar', terminatesTo: 'development-process' },
         }));

package/dist/tests/core/discovery-multiroot.test.js

@@ -60,4 +60,9 @@ describe('discovery multi-root', () => {
         expect(discoverSkills([rootA, rootB]).length).toBe(1);
         expect(discoverAgents([rootA, rootB])).toEqual([]);
     });
+    it('rejects a real directory named SKILL.md as a nonregular artifact without blocking', () => {
+        fs_1.default.mkdirSync(path_1.default.join(rootA, 'skills', 'unsafe', 'SKILL.md'), { recursive: true });
+        const { discoverSkills } = require('../../src/core/discovery');
+        expect(() => discoverSkills([rootA])).toThrow(/SKILL\.md.*regular file/);
+    });
 });

package/dist/tests/core/discovery-parent-race.test.js

@@ -0,0 +1,95 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const discovery_1 = require("../../src/core/discovery");
+describe('real skill parent races', () => {
+    let fixture;
+    let root;
+    let skillDir;
+    let skillFile;
+    beforeEach(() => {
+        fixture = fs_1.default.mkdtempSync(path_1.default.join(fs_1.default.realpathSync(os_1.default.tmpdir()), 'skill-parent-race-'));
+        root = path_1.default.join(fixture, 'registry');
+        skillDir = path_1.default.join(root, 'skills', 'safe');
+        skillFile = path_1.default.join(skillDir, 'SKILL.md');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(skillFile, '---\ndescription: Inside skill\n---\n');
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        fs_1.default.rmSync(fixture, { recursive: true, force: true });
+    });
+    it('reads an unchanged skill through its descriptor', () => {
+        expect((0, discovery_1.discoverSkills)([root])).toEqual([
+            { name: 'safe', path: skillDir, description: 'Inside skill' },
+        ]);
+    });
+    describe.each(['root', 'skills', 'skill directory'])('%s substitution', (component) => {
+        it.each(['symlink', 'directory'])('rejects a %s swapped after parent inspection before reading outside bytes', (replacement) => {
+            const parent = component === 'root' ? root : component === 'skills' ? path_1.default.dirname(skillDir) : skillDir;
+            const outside = path_1.default.join(fixture, 'outside');
+            const outsideFile = path_1.default.join(outside, path_1.default.relative(parent, skillFile));
+            fs_1.default.mkdirSync(path_1.default.dirname(outsideFile), { recursive: true });
+            fs_1.default.writeFileSync(outsideFile, '---\ndescription: Outside skill\n---\n');
+            const lstat = fs_1.default.lstatSync;
+            let swapped = false;
+            // Keep real lstat results; only schedule a real rename/symlink at the race boundary.
+            jest.spyOn(fs_1.default, 'lstatSync').mockImplementation(((...args) => {
+                const stat = lstat(...args);
+                if (args[0] === parent && !swapped) {
+                    swapped = true;
+                    fs_1.default.renameSync(parent, path_1.default.join(fixture, 'original-parent'));
+                    if (replacement === 'symlink')
+                        fs_1.default.symlinkSync(outside, parent, 'junction');
+                    else
+                        fs_1.default.renameSync(outside, parent);
+                }
+                return stat;
+            }));
+            const read = jest.spyOn(fs_1.default, 'readFileSync');
+            expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/symbolic link|directory identity/i);
+            expect(swapped).toBe(true);
+            expect(read.mock.calls.filter(([file]) => typeof file === 'number'
+                || String(file).startsWith(fixture + path_1.default.sep))).toEqual([]);
+        });
+    });
+    it('rejects an observable parent symlink introduced after open and closes the descriptor without reading', () => {
+        const open = fs_1.default.openSync;
+        let descriptor;
+        jest.spyOn(fs_1.default, 'openSync').mockImplementation((...args) => {
+            descriptor = open(...args);
+            const moved = path_1.default.join(fixture, 'original-parent');
+            fs_1.default.renameSync(skillDir, moved);
+            fs_1.default.symlinkSync(moved, skillDir, 'junction');
+            return descriptor;
+        });
+        const read = jest.spyOn(fs_1.default, 'readFileSync');
+        const close = jest.spyOn(fs_1.default, 'closeSync');
+        let thrown;
+        try {
+            (0, discovery_1.discoverSkills)([root]);
+        }
+        catch (error) {
+            thrown = error;
+        }
+        if (process.platform === 'win32') {
+            // Windows holds the opened file's parent directory handle, so the
+            // replacement itself is denied before a symlink can be introduced.
+            // This is the same security guarantee: outside bytes cannot be read.
+            expect(thrown).toBeInstanceOf(Error);
+            expect(thrown.message).toMatch(/EPERM.*rename|rename.*EPERM/i);
+        }
+        else {
+            expect(thrown).toBeInstanceOf(Error);
+            expect(thrown.message).toMatch(/symbolic link/i);
+            expect(close).toHaveBeenCalledWith(descriptor);
+        }
+        expect(read.mock.calls.filter(([file]) => typeof file === 'number'
+            || String(file).startsWith(fixture + path_1.default.sep))).toEqual([]);
+    });
+});

package/dist/tests/core/discovery-safe-read.test.js

@@ -0,0 +1,115 @@
+"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 discovery_1 = require("../../src/core/discovery");
+jest.mock('fs');
+const root = path_1.default.resolve('registry');
+const skillDir = path_1.default.join(root, 'skills', 'safe');
+const skillFile = path_1.default.join(skillDir, 'SKILL.md');
+const content = '---\ndescription: >-\n  Ordinary skill\n---\n';
+const descriptor = 42;
+const inspected = {
+    dev: 7n, ino: 9007199254740993n, size: BigInt(Buffer.byteLength(content)),
+    isFile: () => true, isSymbolicLink: () => false, isDirectory: () => false,
+};
+const directory = { dev: 7n, ino: 8n, isFile: () => false, isSymbolicLink: () => false, isDirectory: () => true };
+describe.each([true, false])('skill descriptor safety (O_NOFOLLOW available: %s)', (noFollowAvailable) => {
+    beforeEach(() => {
+        jest.resetAllMocks();
+        const actual = jest.requireActual('fs');
+        jest.replaceProperty(fs_1.default, 'constants', {
+            ...actual.constants,
+            O_NOFOLLOW: noFollowAvailable ? 0x20000 : undefined,
+            O_NONBLOCK: 0x800,
+        });
+        fs_1.default.existsSync.mockReturnValue(true);
+        fs_1.default.readdirSync.mockReturnValue([{ name: 'safe', isDirectory: () => true }]);
+        fs_1.default.lstatSync.mockImplementation((file) => {
+            if (file === skillFile)
+                return inspected;
+            if (file.endsWith('awm-registry.json'))
+                throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+            return directory;
+        });
+        fs_1.default.openSync.mockReturnValue(descriptor);
+        fs_1.default.fstatSync.mockReturnValue(inspected);
+        fs_1.default.readFileSync.mockReturnValue(content);
+    });
+    afterEach(() => jest.restoreAllMocks());
+    it('reads an ordinary skill from the validated descriptor and closes it', () => {
+        expect((0, discovery_1.discoverSkills)([root])).toEqual([{ name: 'safe', path: skillDir, description: 'Ordinary skill' }]);
+        expect(fs_1.default.readFileSync).toHaveBeenCalledWith(descriptor, 'utf-8');
+        expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+        const flags = fs_1.default.openSync.mock.calls[0][1];
+        expect(typeof flags).toBe('number');
+        if (noFollowAvailable)
+            expect(flags & fs_1.default.constants.O_NOFOLLOW).toBe(fs_1.default.constants.O_NOFOLLOW);
+        expect(flags & fs_1.default.constants.O_NONBLOCK).toBe(fs_1.default.constants.O_NONBLOCK);
+    });
+    it.each([
+        ['another inode', { ino: inspected.ino + 1n }],
+        ['another device', { dev: inspected.dev + 1n }],
+        ['changed size', { size: inspected.size + 1n }],
+        ['FIFO replacement', { isFile: () => false }],
+        ['symlink replacement', { isFile: () => false, isSymbolicLink: () => true }],
+        ['unobservable device', { dev: undefined }],
+        ['unobservable inode', { ino: undefined }],
+    ])('rejects %s after inspection, without reading replacement bytes', (_label, change) => {
+        fs_1.default.fstatSync.mockReturnValue({ ...inspected, ...change });
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/SKILL\.md.*(identity|regular|size|symbolic)/i);
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+        expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+    });
+    it('opens nonblocking so a FIFO replacement cannot hang before fstat rejects it', () => {
+        // No FIFO is created: the open mock enforces the flag needed to avoid blocking.
+        fs_1.default.openSync.mockImplementation((_file, flags) => {
+            if (!(flags & fs_1.default.constants.O_NONBLOCK))
+                throw new Error('would block opening FIFO');
+            return descriptor;
+        });
+        fs_1.default.fstatSync.mockReturnValue({ ...inspected, isFile: () => false });
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/regular file/i);
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+        expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+    });
+    it.each(['openSync', 'fstatSync', 'readFileSync'])('fails closed on %s errors', (operation) => {
+        fs_1.default[operation].mockImplementation(() => { throw new Error('replaced or unreadable'); });
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/SKILL\.md.*replaced or unreadable/);
+        if (operation === 'openSync')
+            expect(fs_1.default.closeSync).not.toHaveBeenCalled();
+        else
+            expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+        if (operation !== 'readFileSync')
+            expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+    it.each([root, path_1.default.join(root, 'skills'), skillDir])('rejects an observable directory symlink at %s', (linked) => {
+        const lstat = fs_1.default.lstatSync.getMockImplementation();
+        fs_1.default.lstatSync.mockImplementation((file, options) => file === linked
+            ? { ...directory, isDirectory: () => false, isSymbolicLink: () => true }
+            : lstat(file, options));
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/symbolic link/i);
+        expect(fs_1.default.openSync).not.toHaveBeenCalled();
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+    it.each(['dev', 'ino', 'size'])('fails closed when inspected %s is unobservable', (field) => {
+        const unknown = { ...inspected, [field]: undefined };
+        const lstat = fs_1.default.lstatSync.getMockImplementation();
+        fs_1.default.lstatSync.mockImplementation((file, options) => file === skillFile ? unknown : lstat(file, options));
+        fs_1.default.fstatSync.mockReturnValue(unknown);
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/identity|size/i);
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+    it.each(['dev', 'ino'])('fails closed when parent %s is unobservable', (field) => {
+        const lstat = fs_1.default.lstatSync.getMockImplementation();
+        fs_1.default.lstatSync.mockImplementation((file, options) => file === skillDir
+            ? { ...directory, [field]: undefined }
+            : lstat(file, options));
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/directory identity/i);
+        expect(fs_1.default.openSync).not.toHaveBeenCalled();
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/core/discovery.test.js

@@ -15,16 +15,30 @@ const WORKFLOWS_ROOT = CONTENT_ROOT;
 // For backward-compat with mock expectations that check SKILLS_DIR-style paths:
 const SKILLS_DIR = path_1.default.join(CONTENT_ROOT, 'skills');
 const WORKFLOWS_DIR = path_1.default.join(CONTENT_ROOT, 'workflows');
+const directoryStat = { dev: 1n, ino: 3n, isDirectory: () => true, isSymbolicLink: () => false };
+const skillStat = { dev: 1n, ino: 2n, size: 0n, isFile: () => true, isSymbolicLink: () => false };
 describe('Artifact Discovery', () => {
     beforeEach(() => {
         jest.clearAllMocks();
-        fs_1.default.lstatSync.mockImplementation(() => {
+        fs_1.default.lstatSync.mockImplementation((p) => {
+            if (!p.endsWith('.md') && !p.endsWith('.json'))
+                return directoryStat;
             const error = Object.assign(new Error('missing'), { code: 'ENOENT' });
             throw error;
         });
+        fs_1.default.openSync.mockReturnValue(42);
+        fs_1.default.fstatSync.mockReturnValue(skillStat);
+        fs_1.default.readFileSync.mockReturnValue('');
     });
     describe('discoverSkills', () => {
         it('should return a list of skill directories that contain a SKILL.md', () => {
+            fs_1.default.lstatSync.mockImplementation((p) => {
+                if (p.endsWith('SKILL.md'))
+                    return skillStat;
+                if (!p.endsWith('.json'))
+                    return directoryStat;
+                throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+            });
             fs_1.default.existsSync.mockImplementation((p) => {
                 if (p === SKILLS_DIR)
                     return true;
@@ -48,6 +62,19 @@ describe('Artifact Discovery', () => {
             const skills = (0, discovery_1.discoverSkills)([SKILLS_ROOT]);
             expect(skills).toEqual([]);
         });
+        it.each(['fifo', 'symlink'])('rejects a %s SKILL.md before attempting any read', (kind) => {
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readdirSync.mockReturnValue([{ name: 'unsafe', isDirectory: () => true }]);
+            fs_1.default.lstatSync.mockImplementation((p) => {
+                if (p.endsWith('SKILL.md'))
+                    return { isFile: () => false, isSymbolicLink: () => kind === 'symlink' };
+                if (!p.endsWith('.json'))
+                    return directoryStat;
+                throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+            });
+            expect(() => (0, discovery_1.discoverSkills)([SKILLS_ROOT])).toThrow(/regular file|symbolic link/);
+            expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+        });
         it('should skip skill directories without a SKILL.md', () => {
             fs_1.default.existsSync.mockImplementation((p) => {
                 if (p === SKILLS_DIR)

package/dist/tests/core/journal/types.test.js

@@ -148,6 +148,17 @@ describe('journal types', () => {
         state.tracks[0].supervisorIntent.nonce = '';
         expect((0, types_1.isWellFormedState)(state)).toBe(false);
     });
+    test('TrackRef acepta teardownRequested booleano y rechaza otro runtime shape', () => {
+        const state = (0, types_1.emptyState)('main');
+        state.tracks = [{
+                trackId: 'cli', worktreePath: '/tmp/wt', branch: 'awm-track/cli', ownership: ['cli/'],
+                sharedResources: [], dependsOn: [], fencingToken: 'f'.repeat(32), phase: 'ACTIVE',
+                readinessNonce: 'r'.repeat(32), teardownRequested: true,
+            }];
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.tracks[0].teardownRequested = 'true';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
     test('trackContext, cohortPhase y trackIntegration validan shape cuando presentes (R9.1, R9.3)', () => {
         const state = (0, types_1.emptyState)('main');
         state.trackContext = { trackId: 'cli', taskIds: ['t1'], planDigest: 'd', baseSha: 'abc', planJournalId: 'j-plan' };