agentic-workflow-manager 9.17.0 → 9.18.0

package/dist/tests/commands/registry/doctor.test.js

@@ -0,0 +1,283 @@
+"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 types_1 = require("../../../src/core/facts/types");
+function writeJson(file, value) {
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    fs_1.default.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
+}
+function handbook(rows) {
+    const body = rows.length === 0 ? '' : rows.map((r) => `| ${r} |`).join('\n') + '\n';
+    return `# fixture
+
+## Capabilities
+| id | status | notes |
+|----|--------|-------|
+${body}
+## Capability: facts
+Facts chapter.
+`;
+}
+/** Minimal registry that passes structural doctor when facts are unused. */
+function scaffoldBare(root, opts) {
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills'), { recursive: true });
+    writeJson(path_1.default.join(root, 'awm-registry.json'), {
+        overrides: [],
+        ...(opts?.minCliVersion !== undefined ? { minCliVersion: opts.minCliVersion } : {}),
+    });
+    const catalogVersion = opts?.catalogVersion ?? '1.0.0';
+    if (opts?.withBundle !== false) {
+        writeJson(path_1.default.join(root, 'catalog.json'), {
+            version: 1,
+            bundles: [{ name: 'demo', source: 'bundles/demo', version: catalogVersion, scope: 'project' }],
+        });
+        writeJson(path_1.default.join(root, 'bundles', 'demo', 'bundle.json'), {
+            name: 'demo',
+            version: opts?.bundleVersion ?? catalogVersion,
+            skills: [],
+        });
+    }
+    else {
+        writeJson(path_1.default.join(root, 'catalog.json'), { version: 1, bundles: [] });
+    }
+    fs_1.default.writeFileSync(path_1.default.join(root, 'REGISTRY.md'), opts?.handbook ?? handbook(['facts | active | see chapter']));
+    if (opts?.facts !== undefined) {
+        writeJson(path_1.default.join(root, 'facts.json'), opts.facts);
+    }
+}
+describe('doctorRegistry (RF-4.4–4.8, RF-5.1)', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-doctor-'));
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    function loadDoctor() {
+        return require('../../../src/commands/registry/doctor');
+    }
+    it('reports missing REGISTRY.md as structural', () => {
+        const root = path_1.default.join(tmp, 'no-handbook');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        fs_1.default.unlinkSync(path_1.default.join(root, 'REGISTRY.md'));
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /missing REGISTRY\.md/i.test(m))).toBe(true);
+    });
+    it('reports missing Capabilities index as structural', () => {
+        const root = path_1.default.join(tmp, 'no-caps');
+        scaffoldBare(root, {
+            withBundle: false,
+            minCliVersion: types_1.FACTS_MIN_CLI_VERSION,
+            handbook: '# fixture\n\nNo capabilities table here.\n',
+        });
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /Capabilities/i.test(m))).toBe(true);
+    });
+    it('reports catalog vs bundle.json version skew as structural (RF-4.7)', () => {
+        const root = path_1.default.join(tmp, 'skew');
+        scaffoldBare(root, {
+            minCliVersion: types_1.FACTS_MIN_CLI_VERSION,
+            catalogVersion: '1.0.0',
+            bundleVersion: '2.0.0',
+        });
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /version/i.test(m) && /demo/i.test(m))).toBe(true);
+    });
+    it('reports environment store files under registry tree as structural (RF-4.5)', () => {
+        const root = path_1.default.join(tmp, 'store-in-tree');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        const store = path_1.default.join(root, 'environments', 'default', 'values.json');
+        writeJson(store, { 'repos.root': { value: '/x', status: 'fresh', updatedAt: '2026-01-01T00:00:00Z' } });
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /environments/i.test(m) || /values\.json/i.test(m))).toBe(true);
+    });
+    it('reports environments symlink into external store as structural (RF-4.5)', () => {
+        const root = path_1.default.join(tmp, 'store-symlink');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        const external = path_1.default.join(tmp, 'external-env');
+        writeJson(path_1.default.join(external, 'default', 'values.json'), {
+            'repos.root': { value: '/x', status: 'fresh', updatedAt: '2026-01-01T00:00:00Z' },
+        });
+        fs_1.default.symlinkSync(external, path_1.default.join(root, 'environments'));
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /environments/i.test(m) && /symlink|RF-4\.5/i.test(m))).toBe(true);
+    });
+    it('reports values.json / meta.json symlinks under environments as structural (RF-4.5)', () => {
+        const root = path_1.default.join(tmp, 'store-file-symlink');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        const external = path_1.default.join(tmp, 'external-values.json');
+        fs_1.default.writeFileSync(external, '{"x":1}\n');
+        fs_1.default.mkdirSync(path_1.default.join(root, 'environments', 'default'), { recursive: true });
+        fs_1.default.symlinkSync(external, path_1.default.join(root, 'environments', 'default', 'values.json'));
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /values\.json/i.test(m))).toBe(true);
+    });
+    it('treats unknown capability id widgets as advisory only; doctorExitCode is 0 (RF-4.4/4.6)', () => {
+        const root = path_1.default.join(tmp, 'widgets');
+        scaffoldBare(root, {
+            withBundle: false,
+            minCliVersion: types_1.FACTS_MIN_CLI_VERSION,
+            handbook: handbook(['widgets | planned | future']),
+        });
+        const { doctorRegistry, doctorExitCode } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural).toEqual([]);
+        expect(report.advisories.some((m) => /widgets/i.test(m))).toBe(true);
+        expect(doctorExitCode(report)).toBe(0);
+        expect(doctorExitCode({ structural: ['x'], advisories: [] })).toBe(1);
+    });
+    it('fails structurally when facts present and minCliVersion below FACTS_MIN_CLI_VERSION (RF-4.8)', () => {
+        const root = path_1.default.join(tmp, 'old-cli');
+        scaffoldBare(root, {
+            withBundle: false,
+            minCliVersion: '9.17.0',
+            facts: { schemaVersion: 1, facts: {} },
+        });
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /minCliVersion/i.test(m) || /9\.18\.0/.test(m))).toBe(true);
+    });
+    it('advises on prose home-path hints like ~/Developments', () => {
+        const root = path_1.default.join(tmp, 'prose');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        const skillDir = path_1.default.join(root, 'skills', 'demo');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillDir, 'SKILL.md'), `---\nname: demo\ndescription: d\n---\nClone under ~/Developments/team.\n`);
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.advisories.some((m) => /~\/Developments|home path|machine path/i.test(m))).toBe(true);
+    });
+    it('reports orphan needs as structural when facts.json exists (RF-1.3)', () => {
+        const root = path_1.default.join(tmp, 'orphan');
+        scaffoldBare(root, {
+            withBundle: false,
+            minCliVersion: types_1.FACTS_MIN_CLI_VERSION,
+            facts: {
+                schemaVersion: 1,
+                facts: { 'repos.root': { valueType: 'path' } },
+            },
+        });
+        const skillDir = path_1.default.join(root, 'skills', 'demo');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillDir, 'SKILL.md'), `---\nname: demo\ndescription: d\nneeds:\n  - ghost.fact\n---\n# Demo\n`);
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /ghost\.fact|orphan/i.test(m))).toBe(true);
+    });
+    it('reports needs without facts.json as structural (fail closed)', () => {
+        const root = path_1.default.join(tmp, 'needs-no-catalog');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        const skillDir = path_1.default.join(root, 'skills', 'demo');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillDir, 'SKILL.md'), `---\nname: demo\ndescription: d\nneeds:\n  - repos.root\n---\n# Demo\n`);
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /needs/i.test(m) && /facts\.json/i.test(m) && /missing/i.test(m))).toBe(true);
+        expect(report.structural.every((m) => !/invalid|unreadable/i.test(m) || !/needs/i.test(m))).toBe(true);
+    });
+    it('reports needs + invalid facts.json as invalid/unreadable, not missing', () => {
+        const root = path_1.default.join(tmp, 'needs-bad-catalog');
+        scaffoldBare(root, {
+            withBundle: false,
+            minCliVersion: types_1.FACTS_MIN_CLI_VERSION,
+            facts: { schemaVersion: 1, facts: {} },
+        });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'facts.json'), '{not-json');
+        const skillDir = path_1.default.join(root, 'skills', 'demo');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillDir, 'SKILL.md'), `---\nname: demo\ndescription: d\nneeds:\n  - repos.root\n---\n# Demo\n`);
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        const needsMsg = report.structural.find((m) => /needs/i.test(m) && /facts\.json/i.test(m));
+        expect(needsMsg).toBeDefined();
+        expect(needsMsg).toMatch(/invalid|unreadable/i);
+        expect(needsMsg).not.toMatch(/\bmissing\b/i);
+    });
+    it('fails structurally when facts present and minCliVersion key absent (RF-4.8)', () => {
+        const root = path_1.default.join(tmp, 'facts-no-min');
+        scaffoldBare(root, {
+            withBundle: false,
+            facts: { schemaVersion: 1, facts: {} },
+        });
+        // scaffoldBare omits minCliVersion when not provided
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /minCliVersion/i.test(m))).toBe(true);
+    });
+    it('rejects empty / non-string root with structural error before path.resolve', () => {
+        const { doctorRegistry } = loadDoctor();
+        expect(doctorRegistry('').structural.some((m) => /root|required|non-empty|string/i.test(m))).toBe(true);
+        expect(doctorRegistry('   ').structural.some((m) => /root|required|non-empty|string/i.test(m))).toBe(true);
+        expect(doctorRegistry(null).structural.some((m) => /root|required|non-empty|string/i.test(m))).toBe(true);
+    });
+    it('reports symlink skill dirs and non-regular SKILL.md as structural (fail closed)', () => {
+        const root = path_1.default.join(tmp, 'skill-symlink');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        const externalSkill = path_1.default.join(tmp, 'external-skill');
+        fs_1.default.mkdirSync(externalSkill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(externalSkill, 'SKILL.md'), '---\nname: linked\ndescription: d\n---\n');
+        fs_1.default.symlinkSync(externalSkill, path_1.default.join(root, 'skills', 'linked'));
+        const regular = path_1.default.join(root, 'skills', 'regular');
+        fs_1.default.mkdirSync(regular, { recursive: true });
+        const externalMd = path_1.default.join(tmp, 'external-SKILL.md');
+        fs_1.default.writeFileSync(externalMd, '---\nname: regular\ndescription: d\n---\n');
+        fs_1.default.symlinkSync(externalMd, path_1.default.join(regular, 'SKILL.md'));
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural.some((m) => /linked/i.test(m) && /symlink|skill/i.test(m))).toBe(true);
+        expect(report.structural.some((m) => /regular/i.test(m) && /SKILL\.md|symlink|regular file/i.test(m))).toBe(true);
+    });
+    // chmod(0) is a POSIX permission seam; on win32 NTFS ACLs often still allow
+    // the creating user to read, so the unreadable path is not reproducible there.
+    (process.platform === 'win32' ? it.skip : it)('reports unreadable SKILL.md as structural (fail closed)', () => {
+        const root = path_1.default.join(tmp, 'skill-unreadable');
+        scaffoldBare(root, { withBundle: false, minCliVersion: types_1.FACTS_MIN_CLI_VERSION });
+        const skillDir = path_1.default.join(root, 'skills', 'locked');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        const skillMd = path_1.default.join(skillDir, 'SKILL.md');
+        fs_1.default.writeFileSync(skillMd, '---\nname: locked\ndescription: d\n---\n');
+        fs_1.default.chmodSync(skillMd, 0);
+        try {
+            const { doctorRegistry } = loadDoctor();
+            const report = doctorRegistry(root);
+            expect(report.structural.some((m) => /locked|SKILL\.md|Cannot read|unreadable/i.test(m))).toBe(true);
+        }
+        finally {
+            fs_1.default.chmodSync(skillMd, 0o644);
+        }
+    });
+    it('does not require facts chapter beyond Capabilities when no facts.json and no needs', () => {
+        const root = path_1.default.join(tmp, 'legacy');
+        scaffoldBare(root, {
+            withBundle: false,
+            handbook: handbook(['hooks | n/a | none']),
+        });
+        const { doctorRegistry } = loadDoctor();
+        const report = doctorRegistry(root);
+        expect(report.structural).toEqual([]);
+    });
+    it('doctor API is path-only and does not require writing-skills (RF-5.1)', () => {
+        const source = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../../src/commands/registry/doctor.ts'), 'utf8');
+        expect(source).toMatch(/export function doctorRegistry\(\s*root:\s*string/);
+        expect(source).not.toMatch(/writing-skills/);
+        expect(source).not.toMatch(/writeSkill|writeFileSync.*SKILL/);
+    });
+    it('wires awm registry doctor [name|path] via doctorExitCode', () => {
+        const indexSource = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../../src/commands/registry/index.ts'), 'utf8');
+        expect(indexSource).toMatch(/doctorRegistry/);
+        expect(indexSource).toMatch(/doctorExitCode/);
+        expect(indexSource).toMatch(/process\.exit\(doctorExitCode\(/);
+    });
+});

package/dist/tests/commands/registry/scaffold.test.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const types_1 = require("../../../src/core/facts/types");
+const versioning_1 = require("../../../src/core/versioning");
+const GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t ${cmd}`, { cwd, stdio: 'pipe' });
+describe('scaffoldRegistry (RF-4.1, RF-4.2, RF-4.3)', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-scaffold-'));
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    function loadScaffold() {
+        return require('../../../src/commands/registry/scaffold');
+    }
+    function loadDoctor() {
+        return require('../../../src/commands/registry/doctor');
+    }
+    function loadValidate() {
+        return require('../../../src/core/registries');
+    }
+    it('writes min layout with versions, facts, handbook; doctor structural empty (RF-4.1/4.2)', () => {
+        const dir = path_1.default.join(tmp, 'new-reg');
+        const { scaffoldRegistry } = loadScaffold();
+        const result = scaffoldRegistry(dir);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'awm-registry.json'), 'utf-8'));
+        expect(typeof manifest.minCliVersion).toBe('string');
+        expect(manifest.minCliVersion).not.toMatch(/^v/i);
+        expect((0, versioning_1.compareSemver)(manifest.minCliVersion, types_1.FACTS_MIN_CLI_VERSION)).toBeGreaterThanOrEqual(0);
+        const catalog = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'catalog.json'), 'utf-8'));
+        expect(catalog).toEqual({ version: 1, bundles: [] });
+        expect(fs_1.default.statSync(path_1.default.join(dir, 'skills')).isDirectory()).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'skills', '.gitkeep'))).toBe(true);
+        const facts = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'facts.json'), 'utf-8'));
+        expect(facts).toEqual({ schemaVersion: 1, facts: {} });
+        const handbook = fs_1.default.readFileSync(path_1.default.join(dir, 'REGISTRY.md'), 'utf-8');
+        expect(handbook).toMatch(/^##\s+Capabilities\s*$/m);
+        expect(handbook).toMatch(/^\|\s*id\s*\|\s*status\s*\|\s*notes\s*\|$/m);
+        const capsStart = handbook.search(/^##\s+Capabilities\s*$/m);
+        const nextH2 = handbook.slice(capsStart + 1).search(/^##\s+/m);
+        const capsWindow = nextH2 === -1
+            ? handbook.slice(capsStart)
+            : handbook.slice(capsStart, capsStart + 1 + nextH2);
+        expect(capsWindow).toMatch(/\|\s*facts\s*\|\s*active\s*\|/);
+        expect(handbook).toMatch(/^##\s+Capability:\s*facts\s*$/m);
+        const { doctorRegistry } = loadDoctor();
+        expect(doctorRegistry(dir).structural).toEqual([]);
+    });
+    it('survives git commit+clone: layout valid and doctor structural empty (RF-4.1)', () => {
+        const src = path_1.default.join(tmp, 'scaffold-src');
+        const { scaffoldRegistry } = loadScaffold();
+        const scaffolded = scaffoldRegistry(src);
+        expect(scaffolded.ok).toBe(true);
+        if (!scaffolded.ok)
+            return;
+        GIT(src, 'init -q');
+        GIT(src, 'add -A');
+        GIT(src, 'commit -qm scaffold');
+        const clone = path_1.default.join(tmp, 'scaffold-clone');
+        (0, child_process_1.execSync)(`git clone -q "${src}" "${clone}"`, { stdio: 'pipe' });
+        expect(fs_1.default.existsSync(path_1.default.join(clone, 'skills', '.gitkeep'))).toBe(true);
+        const { validateRegistryLayout } = loadValidate();
+        expect(validateRegistryLayout(clone)).toBe(true);
+        const { doctorRegistry } = loadDoctor();
+        expect(doctorRegistry(clone).structural).toEqual([]);
+    });
+    it('addRegistry accepts local path clone of scaffolded registry (RF-4.1)', async () => {
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-scaffold-add-home-'));
+        const prevHome = process.env.HOME;
+        const prevAwm = process.env.AWM_HOME;
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+        jest.resetModules();
+        try {
+            const src = path_1.default.join(tmp, 'scaffold-for-add');
+            const { scaffoldRegistry } = require('../../../src/commands/registry/scaffold');
+            const scaffolded = scaffoldRegistry(src);
+            expect(scaffolded.ok).toBe(true);
+            if (!scaffolded.ok)
+                return;
+            GIT(src, 'init -q');
+            GIT(src, 'add -A');
+            GIT(src, 'commit -qm scaffold');
+            const { addRegistry } = require('../../../src/commands/registry/add');
+            const { validateRegistryLayout, registryContentRoot } = require('../../../src/core/registries');
+            const result = await addRegistry(src, 'scaffold-local');
+            expect(result.ok).toBe(true);
+            if (!result.ok)
+                return;
+            expect(validateRegistryLayout(registryContentRoot('scaffold-local'))).toBe(true);
+            const { doctorRegistry } = require('../../../src/commands/registry/doctor');
+            expect(doctorRegistry(registryContentRoot('scaffold-local')).structural).toEqual([]);
+        }
+        finally {
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+            if (prevHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = prevHome;
+            if (prevAwm === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = prevAwm;
+        }
+    });
+    it('refuses non-empty existing dir without writing (RF-4.3)', () => {
+        const dir = path_1.default.join(tmp, 'occupied');
+        fs_1.default.mkdirSync(dir);
+        const sentinel = path_1.default.join(dir, 'keep-me.txt');
+        fs_1.default.writeFileSync(sentinel, 'pre-existing\n');
+        const { scaffoldRegistry } = loadScaffold();
+        const result = scaffoldRegistry(dir);
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            return;
+        expect(result.error).toMatch(/exist|non-empty|not empty|overwrite/i);
+        expect(fs_1.default.readFileSync(sentinel, 'utf-8')).toBe('pre-existing\n');
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'awm-registry.json'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'REGISTRY.md'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'facts.json'))).toBe(false);
+    });
+    it('cleans up a directory it created when a mid-write fails (RF-4.3)', () => {
+        const dir = path_1.default.join(tmp, 'partial-fail');
+        expect(fs_1.default.existsSync(dir)).toBe(false);
+        const { scaffoldRegistry } = loadScaffold();
+        let writes = 0;
+        const result = scaffoldRegistry(dir, {
+            writeFileSync: (file, data) => {
+                writes += 1;
+                if (writes >= 3) {
+                    throw new Error('injected write failure');
+                }
+                fs_1.default.writeFileSync(file, data);
+            },
+        });
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            return;
+        expect(result.error).toContain('injected write failure');
+        expect(fs_1.default.existsSync(dir)).toBe(false);
+    });
+    it('empty preexisting target: mid-fail leaves it empty so retry succeeds (RF-4.3)', () => {
+        const dir = path_1.default.join(tmp, 'empty-preexisting');
+        fs_1.default.mkdirSync(dir);
+        expect(fs_1.default.readdirSync(dir)).toEqual([]);
+        const { scaffoldRegistry } = loadScaffold();
+        let writes = 0;
+        const failed = scaffoldRegistry(dir, {
+            writeFileSync: (file, data) => {
+                writes += 1;
+                if (writes >= 3) {
+                    throw new Error('injected write failure');
+                }
+                fs_1.default.writeFileSync(file, data);
+            },
+        });
+        expect(failed.ok).toBe(false);
+        if (failed.ok)
+            return;
+        expect(failed.error).toContain('injected write failure');
+        // Target must not hold partial scaffold files (stage-then-rename).
+        if (fs_1.default.existsSync(dir)) {
+            expect(fs_1.default.readdirSync(dir)).toEqual([]);
+        }
+        const retry = scaffoldRegistry(dir);
+        expect(retry.ok).toBe(true);
+        if (!retry.ok)
+            return;
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'awm-registry.json'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'REGISTRY.md'))).toBe(true);
+        const { doctorRegistry } = loadDoctor();
+        expect(doctorRegistry(dir).structural).toEqual([]);
+    });
+});

package/dist/tests/commands/watch/reopened-196.test.js

@@ -921,9 +921,16 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             }
             expect(stdout).toContain('supervisor activo');
             child.kill('SIGINT');
-            const exit = await new Promise(resolve => child.once('close', code => resolve(code)));
-            expect(exit).toBe(130);
+            const exit = await new Promise(resolve => {
+                child.once('exit', (code, signal) => resolve({ code, signal }));
+            });
+            // Contract: truthful interrupt report. Exit status is secondary —
+            // on Darwin, child_process often reports code null + SIGINT when the
+            // signal disposition races process.exitCode=130 (never use process.exit
+            // in watch/index: it kills in-process Jest callers). Either 130 or
+            // null+SIGINT is an interrupted stop; require the detenido line either way.
             expect(stdout).toMatch(/detenido; ciclo IN_PROGRESS/);
+            expect(exit.code === 130 || (exit.code === null && exit.signal === 'SIGINT')).toBe(true);
             expect(stdout).not.toContain('COMPLETE');
             expect(stderr).not.toContain('Error');
         }