agentic-workflow-manager 3.13.5 → 3.13.6

package/dist/tests/core/init/context-injection-no-project.test.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `stepContextInjection` is a MACHINE-level step — it runs even when `ctx.project`
+// is null. For providers whose context delivery is project-scope (managed-agents-md
+// with `globalPath: null` — Cursor, Copilot) it then fell back to writing at `d.cwd`:
+//
+//     $ cd ~/scratch && awm init -a copilot     # not a project: no .git, no package.json
+//     ~/scratch/AGENTS.md                       ← written
+//     ~/scratch/.awm/context/awm-context.md     ← written
+//
+// `planInitMutationTargets` enumerates both of those paths only inside
+// `if (projectRoot)`, so with no project root neither entered the backup session. A
+// later failed step rolled back everything that WAS enumerated and left these two
+// behind — while the outcome reported `rolledBack: true` and listed `restoredFiles`,
+// i.e. claimed a clean restore it had not performed.
+//
+// `--machine-only` reached the same place from the other side: it nulls `ctx.project`
+// deliberately, so the step took the `?? d.cwd` branch even inside a real project.
+//
+// Two different situations were being read as one. Running in a directory the user
+// means as their project but which has no marker yet is legitimate — Copilot has no
+// other channel, so removing that write would leave it with no context at all. What
+// was wrong is that the path was never enumerated, so it survived rollback; that is
+// fixed in mutation-targets, which now covers `cwd` for these providers regardless of
+// whether a project root was found.
+//
+// `--machine-only` is the case that must not write at all: it nulls `ctx.project` on
+// purpose, and this step read that as "no project found" and wrote into cwd anyway —
+// under the one flag whose entire promise is that it won't touch the project.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const steps_1 = require("../../../src/core/init/steps");
+const mutation_targets_1 = require("../../../src/core/init/mutation-targets");
+const materializer_1 = require("../../../src/core/context/materializer");
+function deps(agent, cwd, projectRoot, machineOnly = false) {
+    const installed = [];
+    const d = {
+        cwd,
+        agent,
+        enabledAgents: [agent],
+        bundles: [],
+        installMethod: 'symlink',
+        registryRoot: '',
+        contentDir: '',
+        sensorPacksRoot: '',
+        machineOnly,
+        ctx: {
+            machine: {},
+            project: projectRoot ? { root: projectRoot } : null,
+        },
+        actions: {
+            contextStatus: () => 'absent',
+            installContext: (op) => { installed.push(op); },
+        },
+    };
+    return { d, installed };
+}
+describe('project-scope context injection without a project', () => {
+    let cwd;
+    beforeEach(() => { cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-noproj-')); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    it.each(['copilot', 'cursor'])('%s: writes nothing at all under --machine-only', (agent) => {
+        const { d, installed } = deps(agent, cwd, null, true);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(installed).toEqual([]);
+        expect(result.action).toBe('skipped');
+        expect(result.detail).toMatch(/machine-only/i);
+    });
+    it.each(['copilot', 'cursor'])('%s: still delivers into an unmarked cwd — its only channel — now that the path is backed up', (agent) => {
+        const { d, installed } = deps(agent, cwd, null);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(result.action).toBe('applied');
+        expect(installed[0].projectRoot).toBe(cwd);
+        // the write is only safe because mutation-targets enumerates it — asserted below
+        expect((0, mutation_targets_1.planInitMutationTargets)({ cwd, agent, bundles: [] }))
+            .toContain(path_1.default.join(cwd, 'AGENTS.md'));
+    });
+    it('leaves a GLOBAL-scope provider untouched by --machine-only', () => {
+        // --machine-only excludes the project, not the machine. Codex's context is
+        // machine-global, so it must still be installed.
+        const { d, installed } = deps('codex', cwd, null, true);
+        expect((0, steps_1.stepContextInjection)(d).action).toBe('applied');
+        expect(installed).toHaveLength(1);
+    });
+    it('still injects for a local-scope provider when a project root IS known', () => {
+        const { d, installed } = deps('copilot', cwd, cwd);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(result.action).toBe('applied');
+        expect(installed).toHaveLength(1);
+        expect(installed[0].projectRoot).toBe(cwd);
+    });
+    it('leaves global-scope injection (codex) alone — it needs no project', () => {
+        const { d, installed } = deps('codex', cwd, null);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(result.action).toBe('applied');
+        expect(installed).toHaveLength(1);
+        expect(installed[0].scope).toBe('global');
+    });
+});
+describe('mutation-targets covers the local-scope context paths independently', () => {
+    let cwd;
+    beforeEach(() => { cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-noproj-mt-')); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    it.each(['copilot', 'cursor'])('%s: enumerates AGENTS.md and .awm/context even with no project root', (agent) => {
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd, agent, bundles: [] });
+        expect(targets).toContain(path_1.default.join(cwd, 'AGENTS.md'));
+        expect(targets).toContain((0, materializer_1.projectContextPath)(cwd));
+    });
+    it('does not invent those targets for a provider that never writes them', () => {
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd, agent: 'claude-code', bundles: [] });
+        expect(targets).not.toContain((0, materializer_1.projectContextPath)(cwd));
+    });
+});

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

@@ -58,7 +58,7 @@ describe('runInitSteps — orchestrator', () => {
     function buildDeps(cwd) {
         const { gatherContext } = require('../../../src/core/diagnostics/context');
         const { discoverAllBundles } = require('../../../src/core/bundles');
-        const { contentRoots, REGISTRIES_DIR } = require('../../../src/core/registries');
+        const { contentRoots, registriesDir } = require('../../../src/core/registries');
         const { defaultActions } = require('../../../src/core/init/steps');
         // Seed content at ~/.awm/registries/baseline (content root IS the registry root).
         const contentRoot = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');

package/dist/tests/core/init/steps-registry-sync.test.js

@@ -57,7 +57,7 @@ describe('stepCache — registry sync error results', () => {
         const ctx = {
             machine: {
                 registryCache: { present: false },
-                hook: { present: true, degraded: false },
+                hook: { present: true, degraded: false, applicable: true },
                 devCore: { present: true, brokenLinks: [] },
                 ambient: { wanted: [], installed: [] },
                 contextInjection: [],

package/dist/tests/core/init/steps.test.js

@@ -19,7 +19,7 @@ function bundle(name, scope, skills) {
 function machine() {
     return {
         registryCache: { present: true, gitState: 'clean' },
-        hook: { present: true, degraded: false },
+        hook: { present: true, degraded: false, applicable: true },
         devCore: { present: true, brokenLinks: [] },
         ambient: { wanted: [], installed: [] },
         contextInjection: [],
@@ -31,6 +31,7 @@ function project(over = {}) {
         root: '/repo',
         profile: { present: true, extensions: [] },
         activeBundles: { expected: [], linked: [], broken: [] },
+        orphanLinks: { repairable: [], dead: [] },
         sensors: { present: true },
         constitution: { present: true },
         context: { present: true, file: 'CLAUDE.md' },
@@ -101,14 +102,14 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
     it('hook installs when absent', () => {
         const a = spies();
         const m = machine();
-        m.hook = { present: false };
+        m.hook = { present: false, applicable: true };
         expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installHook).toHaveBeenCalled();
     });
     it('hook reinstalls when present but degraded', () => {
         const a = spies();
         const m = machine();
-        m.hook = { present: true, degraded: true };
+        m.hook = { present: true, degraded: true, applicable: true };
         expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installHook).toHaveBeenCalled();
     });
@@ -123,7 +124,7 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
     it('hook skips (not calls installHook) for an agent with no hook mechanism', () => {
         const a = spies();
         const m = machine();
-        m.hook = { present: false };
+        m.hook = { present: false, applicable: true };
         const r = (0, steps_1.stepHook)(deps({ machine: m, project: null }, a, { agent: 'opencode', enabledAgents: ['opencode'] }));
         expect(r.action).toBe('skipped');
         expect(a.installHook).not.toHaveBeenCalled();
@@ -533,7 +534,7 @@ describe('stepContextInjection', () => {
     it('installs Copilot context at local scope with projectRoot (no global AGENTS.md-equivalent)', () => {
         const a = spies();
         a.contextStatus.mockReturnValue('absent');
-        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/repo' }));
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: project({ root: '/repo' }) }, a, { agent: 'copilot', cwd: '/repo' }));
         expect(r.action).toBe('applied');
         expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
     });
@@ -550,6 +551,11 @@ describe('stepContextInjection', () => {
         expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
     });
     it('falls back to raw cwd when no project was discovered', () => {
+        // Legitimate: Copilot has no channel other than a project AGENTS.md, and a
+        // directory without .git/package.json is still where the user is working. What
+        // made this a rollback hole was mutation-targets.ts enumerating that path only
+        // inside `if (projectRoot)` — fixed there; see
+        // tests/core/init/context-injection-no-project.test.ts.
         const a = spies();
         a.contextStatus.mockReturnValue('absent');
         const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/nowhere' }));

package/dist/tests/core/path-resolution-no-shell.test.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// SECURITY regression: `resolveOnPath` used to interpolate its argument into a
+// SHELL string (`command -v ${bin}` / `where ${bin}`) and run it through
+// execSync. The argument is the first token of a sensor's `cmd`, which comes
+// from `.awm/sensors.json` — a file that is COMMITTED IN THE REPO and also
+// regenerated from a registry sensor-pack's `defaultCmd`. So both a cloned
+// untrusted repo and a third-party registry could reach it.
+//
+// The token cannot contain whitespace (it is a split token), but that stops
+// nothing: `${IFS}` and `$(...)` sidestep it entirely. Confirmed exploit on the
+// real binary — `awm sensors status` (and `awm preflight`) executed an attacker
+// command and then reported the sensor as HEALTHY, because the injected command
+// exited 0:
+//
+//     {"sensors":{"lint":{"cmd":"foo;touch${IFS}/tmp/PWNED","fast":true}}}
+//     $ awm sensors status      # -> /tmp/PWNED created, status "✔ HEALTHY"
+//
+// `awm sensors status` and `awm preflight` are commands a user reasonably
+// expects to be INERT — read-only inspection. The fix removes the shell
+// entirely: PATH is resolved in-process, so there is no interpreter to inject
+// into, on any platform.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../../src/core/paths");
+describe('resolveOnPath: sin shell, inmune a inyeccion', () => {
+    const realPlatform = process.platform;
+    let binDir;
+    let originalPath;
+    beforeEach(() => {
+        binDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pathres-'));
+        originalPath = process.env.PATH;
+        process.env.PATH = binDir;
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: realPlatform });
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        fs_1.default.rmSync(binDir, { recursive: true, force: true });
+    });
+    function setPlatform(p) {
+        Object.defineProperty(process, 'platform', { value: p });
+    }
+    /** Un binario "real" en el PATH falso. */
+    function putBinary(name, mode = 0o755) {
+        const p = path_1.default.join(binDir, name);
+        fs_1.default.writeFileSync(p, '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(p, mode);
+        return p;
+    }
+    it('encuentra un binario real presente en PATH', () => {
+        setPlatform('linux');
+        putBinary('mytool');
+        expect((0, paths_1.resolveOnPath)('mytool')).toBe(true);
+    });
+    it('devuelve false para un binario ausente', () => {
+        setPlatform('linux');
+        expect((0, paths_1.resolveOnPath)('definitivamente-no-existe')).toBe(false);
+    });
+    it('NO ejecuta un payload de inyeccion — el efecto lateral jamas ocurre (regresion de seguridad)', () => {
+        setPlatform('linux');
+        const marker = path_1.default.join(binDir, 'PWNED');
+        // El mismo payload confirmado contra el binario real.
+        const payload = `foo;touch\${IFS}${marker}`;
+        expect((0, paths_1.resolveOnPath)(payload)).toBe(false);
+        expect(fs_1.default.existsSync(marker)).toBe(false);
+    });
+    it.each([
+        ['sustitucion de comando', 'foo$(touch MARKER)'],
+        ['backticks', 'foo`touch MARKER`'],
+        ['encadenado con &&', 'foo&&touch'],
+        ['pipe', 'foo|touch'],
+        ['redireccion', 'foo>MARKER'],
+        ['newline embebido', 'foo\ntouch MARKER'],
+        ['expansion de variable', '$HOME'],
+    ])('trata %s como un nombre literal, nunca como sintaxis', (_n, payload) => {
+        setPlatform('linux');
+        // No existe un archivo con ese nombre literal => false, y nada se ejecuta.
+        expect((0, paths_1.resolveOnPath)(payload)).toBe(false);
+    });
+    // Solo donde el filesystem PUEDE expresar la premisa. `setPlatform('linux')` cambia
+    // lo que hace el codigo, no lo que hace el disco: en un runner Windows `chmod 0o644`
+    // no quita ningun bit de ejecucion (no existe), asi que `accessSync(X_OK)` aprueba el
+    // archivo y el test fallaba sobre un producto que se comporta bien. La rama win32 —
+    // "no exige bit de ejecucion" — la cubre su propio caso mas abajo, que SI es
+    // observable ahi.
+    const itPosix = realPlatform === 'win32' ? it.skip : it;
+    itPosix('en POSIX exige el bit de ejecucion — un archivo no ejecutable no es un binario resoluble', () => {
+        setPlatform('linux');
+        putBinary('noexec', 0o644);
+        expect((0, paths_1.resolveOnPath)('noexec')).toBe(false);
+    });
+    it('en win32 resuelve por PATHEXT, incluyendo los shims .cmd de npm (regresion: R1, bug publicado en v3.9.0)', () => {
+        setPlatform('win32');
+        // En win32 el usuario escribe `eslint`, y lo que existe en disco es
+        // `eslint.cmd` — no resolverlo fue un bug real que rompia los sensores.
+        fs_1.default.writeFileSync(path_1.default.join(binDir, 'eslint.cmd'), '@echo off\r\n');
+        process.env.PATHEXT = '.COM;.EXE;.BAT;.CMD';
+        expect((0, paths_1.resolveOnPath)('eslint')).toBe(true);
+        expect((0, paths_1.resolveOnPath)('noexiste')).toBe(false);
+    });
+    it('en win32 no exige bit de ejecucion (no existe ese concepto ahi)', () => {
+        setPlatform('win32');
+        fs_1.default.writeFileSync(path_1.default.join(binDir, 'tool.exe'), '');
+        process.env.PATHEXT = '.COM;.EXE;.BAT;.CMD';
+        expect((0, paths_1.resolveOnPath)('tool')).toBe(true);
+    });
+    it('un nombre con separador de ruta se chequea como ruta directa, sin recorrer PATH', () => {
+        // La plataforma REAL, no una simulada: el invariante es "un nombre que trae el
+        // separador de SU plataforma se resuelve como ruta". Fijar 'linux' mientras el
+        // disco entrega `D:\...\directo` mezclaba las dos mitades — el codigo buscaba
+        // '/' y la ruta traia '\\' — y fallaba por la contradiccion del arreglo, no por
+        // el producto. Asi el caso corre de verdad en los dos sistemas operativos.
+        setPlatform(realPlatform);
+        const abs = putBinary('directo');
+        expect((0, paths_1.resolveOnPath)(abs)).toBe(true);
+        expect((0, paths_1.resolveOnPath)(path_1.default.join(binDir, 'no-esta'))).toBe(false);
+    });
+    it('entradas vacias o no-string no resuelven ni crashean', () => {
+        setPlatform('linux');
+        expect((0, paths_1.resolveOnPath)('')).toBe(false);
+        expect((0, paths_1.resolveOnPath)('   ')).toBe(false);
+        expect((0, paths_1.resolveOnPath)(undefined)).toBe(false);
+    });
+    it('un PATH ausente no crashea', () => {
+        setPlatform('linux');
+        delete process.env.PATH;
+        expect((0, paths_1.resolveOnPath)('cualquiera')).toBe(false);
+    });
+});

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

@@ -5,10 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const child_process_1 = require("child_process");
 const paths_1 = require("../../src/core/paths");
-jest.mock('child_process', () => ({ execSync: jest.fn() }));
-const mockExecSync = child_process_1.execSync;
 describe('core/paths', () => {
     let origHome;
     let origAwmHome;
@@ -16,7 +13,6 @@ describe('core/paths', () => {
     beforeEach(() => {
         origHome = process.env.HOME;
         origAwmHome = process.env.AWM_HOME;
-        mockExecSync.mockReset();
     });
     afterEach(() => {
         if (origHome === undefined)
@@ -106,34 +102,11 @@ describe('core/paths', () => {
         setPlatform('linux');
         expect(() => (0, paths_1.noteWindowsCaveat)(throwingLog)).not.toThrow();
     });
-    describe('resolveOnPath', () => {
-        it('uses `command -v` on POSIX and returns true when the binary resolves', () => {
-            setPlatform('linux');
-            mockExecSync.mockImplementation(((cmd) => {
-                if (cmd === 'command -v semgrep')
-                    return Buffer.from('/usr/bin/semgrep');
-                throw new Error(`not found: ${cmd}`);
-            }));
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(true);
-        });
-        it('returns false on POSIX when `command -v` fails to resolve the binary', () => {
-            setPlatform('linux');
-            mockExecSync.mockImplementation(() => { throw new Error('not found'); });
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(false);
-        });
-        it('uses `where` on win32, not `command -v`', () => {
-            setPlatform('win32');
-            mockExecSync.mockImplementation(((cmd) => {
-                if (cmd === 'where semgrep')
-                    return Buffer.from('C:\\tools\\semgrep.exe');
-                throw new Error(`not found: ${cmd}`);
-            }));
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(true);
-        });
-        it('returns false on win32 when `where` cannot find the binary', () => {
-            setPlatform('win32');
-            mockExecSync.mockImplementation(() => { throw new Error('not found'); });
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(false);
-        });
-    });
+    // `resolveOnPath` ya no invoca un shell (ni ningun subproceso): resuelve PATH
+    // en proceso. Los tests que vivian aca mockeaban `execSync` y verificaban las
+    // strings `command -v X` / `where X`, o sea la implementacion removida — y dos
+    // de ellos ademas pasaban por accidente en cualquier maquina que tuviera el
+    // binario del fixture instalado de verdad. Su reemplazo, con PATH controlado y
+    // el exploit de inyeccion como ancla, esta en
+    // tests/core/path-resolution-no-shell.test.ts.
 });

package/dist/tests/core/project-skill-links.test.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Project-scope skill symlinks had no maintenance path at all.
+//
+// The machinery exists and is exercised every `awm init` / `awm registry sync`:
+// `classifySkillLinks` finds dangling symlinks, `repairSkillLinks` re-links the ones
+// the registry can still serve and prunes the ones it cannot. But every entry point
+// pointed it at `provider.skill.global` only. A dangling link under a PROJECT's
+// `.claude/skills/` (registry re-cloned, skill renamed upstream, bundle removed from
+// `.awm/profile.json`) was:
+//
+//   - never healed — `awm sync` installs what the profile declares and looks at
+//     nothing else, so a link whose bundle was dropped is simply left behind;
+//   - never pruned — it stays in the tree indefinitely, and the agent trips on it
+//     when it tries to read the skill's SKILL.md;
+//   - never reported — `awm doctor`'s `globalSkills` reads the global dir, so nothing
+//     on any surface mentions it.
+//
+// For Copilot the gap is total, not partial: `skill.global` is null, so *every* skill
+// it has is project-scope, and none of them had any integrity path whatsoever.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const skill_integrity_1 = require("../../src/core/skill-integrity");
+const providers_1 = require("../../src/providers");
+describe('project-scope skill links get the same integrity path as global ones', () => {
+    let registry;
+    let projectRoot;
+    const made = [];
+    beforeEach(() => {
+        registry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-projlink-reg-'));
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-projlink-proj-'));
+        made.push(registry, projectRoot);
+        fs_1.default.mkdirSync(path_1.default.join(registry, 'skills', 'alive'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'skills', 'alive', 'SKILL.md'), '# alive\n');
+    });
+    afterAll(() => { for (const d of made)
+        fs_1.default.rmSync(d, { recursive: true, force: true }); });
+    /** The dir where `agent`'s project-scope skills live, with the links pre-created. */
+    function localSkillsDir(agent, links) {
+        const dir = path_1.default.join(projectRoot, (0, providers_1.providerFor)(agent).skill.local);
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        for (const [name, target] of Object.entries(links))
+            fs_1.default.symlinkSync(target, path_1.default.join(dir, name));
+        return dir;
+    }
+    it('classifies a dangling project link as repairable when the registry still has it', () => {
+        const dir = localSkillsDir('claude-code', { alive: path_1.default.join(registry, 'gone', 'alive') });
+        const out = (0, skill_integrity_1.classifySkillLinks)(dir, [registry]);
+        expect(out.repairable).toEqual(['alive']);
+        expect(out.dead).toEqual([]);
+    });
+    it('classifies a dangling project link as dead when the registry no longer has it', () => {
+        const dir = localSkillsDir('claude-code', { removed: path_1.default.join(registry, 'skills', 'removed') });
+        const out = (0, skill_integrity_1.classifySkillLinks)(dir, [registry]);
+        expect(out.dead).toEqual(['removed']);
+        expect(out.repairable).toEqual([]);
+    });
+    it('awm sync heals a project link the registry can still serve', () => {
+        const dir = localSkillsDir('claude-code', { alive: path_1.default.join(registry, 'moved', 'alive') });
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code'], [registry]);
+        expect(results.find(r => r.agent === 'claude-code').result.relinked).toEqual(['alive']);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'alive', 'SKILL.md'))).toBe(true);
+    });
+    it('prunes a project link nothing can serve any more', () => {
+        const dir = localSkillsDir('claude-code', { removed: path_1.default.join(registry, 'skills', 'removed') });
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code'], [registry]);
+        expect(results.find(r => r.agent === 'claude-code').result.pruned).toEqual(['removed']);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'removed'))).toBe(false);
+        expect(fs_1.default.lstatSync(dir).isDirectory()).toBe(true);
+    });
+    it('covers Copilot, whose skills are ONLY ever project-scope', () => {
+        expect((0, providers_1.providerFor)('copilot').skill.global).toBeNull(); // premise of this test
+        const dir = localSkillsDir('copilot', { alive: path_1.default.join(registry, 'moved', 'alive') });
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['copilot'], [registry]);
+        expect(results.find(r => r.agent === 'copilot').result.relinked).toEqual(['alive']);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'alive', 'SKILL.md'))).toBe(true);
+    });
+    it('leaves the user\'s own files alone — only dangling symlinks are touched', () => {
+        const dir = localSkillsDir('claude-code', { alive: path_1.default.join(registry, 'skills', 'alive') });
+        fs_1.default.mkdirSync(path_1.default.join(dir, 'hand-written'));
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'hand-written', 'SKILL.md'), '# mine\n');
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code'], [registry]);
+        const r = results.find(x => x.agent === 'claude-code').result;
+        expect(r.relinked).toEqual([]);
+        expect(r.pruned).toEqual([]);
+        expect(fs_1.default.readFileSync(path_1.default.join(dir, 'hand-written', 'SKILL.md'), 'utf-8')).toBe('# mine\n');
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'alive'))).toBe(true);
+    });
+    it('skips agents whose project skills dir does not exist', () => {
+        const results = (0, skill_integrity_1.reconcileProjectSkillLinks)(projectRoot, ['claude-code', 'copilot'], [registry]);
+        expect(results).toEqual([]);
+    });
+});
+// Wiring, not just capability: I15's actual defect was that the healing primitive
+// already existed and nothing called it for project scope. A green unit test of the
+// primitive would have looked identical before and after. So assert the call.
+describe('awm sync reaches the project-scope reconciliation', () => {
+    let projectRoot;
+    let home;
+    let saved;
+    beforeEach(() => {
+        jest.resetModules();
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-syncwire-home-'));
+        saved = { HOME: process.env.HOME, AWM_HOME: process.env.AWM_HOME };
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+        fs_1.default.mkdirSync(path_1.default.join(home, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(home, '.awm', 'preferences.json'), JSON.stringify({
+            enabledAgents: ['claude-code'], defaultAgent: 'claude-code',
+            installMethod: 'symlink', defaultScope: 'global',
+        }));
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-syncwire-proj-'));
+        fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+    });
+    afterEach(() => {
+        if (saved.HOME === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = saved.HOME;
+        if (saved.AWM_HOME === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = saved.AWM_HOME;
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    const writeProfile = (extensions) => fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions }));
+    async function sync(spy) {
+        const { runSyncCore } = require('../../src/commands/sync');
+        return runSyncCore({ cwd: projectRoot }, {
+            syncRegistries: async () => [],
+            verifyMinCliVersions: () => [],
+            verifyProjectPins: async () => [],
+            syncProfile: () => ({ installed: [], skipped: [], extensions: [], transactionIds: [], modifiedFiles: [] }),
+            reconcileProjectSkillLinks: spy,
+        });
+    }
+    it('reconciles project links on a normal sync', async () => {
+        writeProfile(['demo']);
+        const spy = jest.fn((_root, _agents, _roots) => []);
+        await sync(spy);
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy.mock.calls[0][0]).toBe(projectRoot);
+        expect(spy.mock.calls[0][1]).toEqual(['claude-code']);
+    });
+    it('reconciles project links even when the profile has no extensions left', async () => {
+        // The case that produces orphans in the first place: the extension that owned
+        // them was removed. That path used to return early, touching nothing.
+        writeProfile([]);
+        const spy = jest.fn((_root, _agents, _roots) => []);
+        const out = await sync(spy);
+        expect(out.code).toBe(0);
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+});