agentic-workflow-manager 3.13.5 → 3.13.7

package/dist/tests/core/diagnostics/checks.test.js

@@ -4,7 +4,7 @@ const checks_1 = require("../../../src/core/diagnostics/checks");
 function healthyMachine() {
     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: [],
@@ -16,6 +16,7 @@ function healthyProject() {
         root: '/repo/belanz',
         profile: { present: true, extensions: ['frontend'] },
         activeBundles: { expected: ['frontend-craft'], linked: ['frontend-craft'], broken: [] },
+        orphanLinks: { repairable: [], dead: [] },
         sensors: { present: true },
         constitution: { present: true },
         context: { present: true, file: 'CLAUDE.md' },
@@ -80,12 +81,12 @@ describe('runChecks — machine.cli', () => {
 describe('runChecks — machine.hook / devCore', () => {
     it('hook degraded → warn', () => {
         const m = healthyMachine();
-        m.hook = { present: true, degraded: true };
+        m.hook = { present: true, degraded: true, applicable: true };
         expect(byId({ machine: m, project: null }, 'machine.hook').status).toBe('warn');
     });
     it('hook absent → missing + awm init', () => {
         const m = healthyMachine();
-        m.hook = { present: false };
+        m.hook = { present: false, applicable: true };
         const c = byId({ machine: m, project: null }, 'machine.hook');
         expect(c.status).toBe('missing');
         expect(c.remedy).toEqual({ kind: 'command', value: 'awm init' });
@@ -162,7 +163,7 @@ describe('machineChecks — global skill integrity', () => {
         return {
             machine: {
                 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: [],
@@ -194,8 +195,15 @@ describe('computeProviderOverall (Task 9)', () => {
             checks: states.map((state, i) => ({ id: CHECK_IDS[i % CHECK_IDS.length], state })),
         };
     }
-    it('healthy when every check is in an ok/pending/warn state', () => {
-        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'shared', 'pending-trust', 'stale'])])).toBe('healthy');
+    it('healthy when every check is in an ok/pending state', () => {
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'shared', 'pending-trust'])])).toBe('healthy');
+    });
+    it('degraded cuando algun check esta stale — un contexto viejo tiene que verse en el exit code', () => {
+        // Antes `stale` quedaba fuera de los estados degradantes, asi que doctor
+        // imprimia ⚠ junto a `status: healthy` y exit 0. Un AGENTS.md
+        // desactualizado (o pisado por otro provider) era invisible para
+        // cualquier gate de CI que mirara el codigo de salida.
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'stale'])])).toBe('degraded');
     });
     it('degrades on a single broken/missing/absent/unsupported/conflict check', () => {
         expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'absent'])])).toBe('degraded');

package/dist/tests/core/diagnostics/provider-tier.test.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //    `contextStatus` about 'global' for these providers always resolved to
 //    'absent' regardless of whether the local injection actually succeeded.
 // 3. `skillsGlobalCheck`'s renderer-awareness fix (deferred Task 4.3 finding):
-//    `classifyGlobalSkills` only ever sees symlinks, so a rendered format
+//    `classifySkillLinks` only ever sees symlinks, so a rendered format
 //    (cursor-mdc, copilot-instructions) always scanned as "0 broken" and
 //    reported a false-green 'healthy' regardless of what was actually on
 //    disk. Non-'link' renderers now report presence-only, honestly.
@@ -174,9 +174,9 @@ describe('skillsGlobalCheck — renderer-aware (Task 4.4 / deferred Task 4.3 fin
         const rulesDir = path_1.default.join(tmpHome, '.cursor/rules');
         fs_1.default.mkdirSync(rulesDir, { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(rulesDir, 'development-process.mdc'), '---\ndescription: dev process\nalwaysApply: true\n---\n\nBody.');
-        // classifyGlobalSkills only ever sees symlinks (`if (!lst.isSymbolicLink()) continue;`)
+        // classifySkillLinks only ever sees symlinks (`if (!lst.isSymbolicLink()) continue;`)
         // — a real scan over rulesDir would find nothing here either. Stubbed explicitly so the
-        // test proves the FIX (renderer-gating), not an accident of what classifyGlobalSkills does.
+        // test proves the FIX (renderer-gating), not an accident of what classifySkillLinks does.
         const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
         const { gatherProviderChecks } = require('../../../src/core/diagnostics/provider-checks');
         const facts = gatherProviderChecks(['cursor'], scanSkills);

package/dist/tests/core/diagnostics/rendered-artifact-visibility.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regresion: el ESCRITOR estampa la extension del renderer sobre el nombre
+// (`using-awm.mdc`, `using-awm.instructions.md`, `development-process.toml`)
+// pero los LECTORES de diagnostico buscaban el nombre pelado. Consecuencia para
+// Cursor y Copilot: nada figuraba jamas como instalado, asi que
+//   - `awm init` NUNCA era idempotente — reinstalaba el baseline entero en cada
+//     corrida, dejando 2 directorios de backup sin podar por corrida;
+//   - `awm doctor` mostraba `✖ dev-core` / `✖ active bundles` de forma
+//     permanente, con un remedio (`awm init` / `awm sync`) que no podia
+//     satisfacerlo nunca.
+// Y lo mismo para los artefactos `agent` de claude-code — el provider POR
+// DEFECTO — porque su installName es `<n>.md` y el lector mapeaba solo el caso
+// `.toml` de codex.
+//
+// Estos tests recorren la misma funcion que usa el escritor
+// (`renderedFilename`), asi que lector y escritor no pueden volver a discrepar.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const registry_1 = require("../../../src/core/renderers/registry");
+const install_planner_1 = require("../../../src/core/install-planner");
+describe('renderedFilename: una sola fuente de verdad para el nombre en disco', () => {
+    it.each([
+        ['link deja el nombre tal cual', 'using-awm', 'link', 'using-awm'],
+        ['link conserva el .md del installName', 'development-process.md', 'link', 'development-process.md'],
+        ['cursor-mdc', 'using-awm', 'cursor-mdc', 'using-awm.mdc'],
+        ['cursor-mdc recorta el .md antes de estampar', 'using-awm.md', 'cursor-mdc', 'using-awm.mdc'],
+        ['copilot-instructions', 'using-awm', 'copilot-instructions', 'using-awm.instructions.md'],
+        ['codex-agent-toml', 'development-process.md', 'codex-agent-toml', 'development-process.toml'],
+    ])('%s', (_n, installName, renderer, expected) => {
+        expect((0, registry_1.renderedFilename)(installName, renderer)).toBe(expected);
+    });
+    it('no usa path.parse().name — un nombre con puntos internos no se trunca', () => {
+        // `path.parse('v1.2-migration').name` === 'v1', lo que perderia
+        // `2-migration` y podria colisionar con otro skill llamado `v1`.
+        expect((0, registry_1.renderedFilename)('v1.2-migration', 'cursor-mdc')).toBe('v1.2-migration.mdc');
+    });
+});
+describe('el lector de diagnostico ve lo que el escritor dejo en disco', () => {
+    let projectRoot;
+    beforeEach(() => {
+        projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rendered-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    // El invariante que importa: el nombre que el escritor produce y el que el
+    // lector busca salen de la MISMA funcion. Se verifica sobre el destino real
+    // que planifica `physicalTarget`, no sobre una reconstruccion a mano.
+    it.each([
+        ['cursor'], ['copilot'], ['claude-code'], ['codex'], ['opencode'], ['antigravity'],
+    ])('%s: el basename del destino planificado coincide con renderedFilename', (agent) => {
+        const { targetPath, renderer } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, agent, 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe((0, registry_1.renderedFilename)('using-awm', renderer));
+    });
+    it('cursor: el destino termina en .mdc (el lector que buscaba el nombre pelado nunca lo encontraba)', () => {
+        const { targetPath } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, 'cursor', 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe('using-awm.mdc');
+        expect(fs_1.default.existsSync(path_1.default.join(path_1.default.dirname(targetPath), 'using-awm'))).toBe(false);
+    });
+    it('copilot: el destino termina en .instructions.md', () => {
+        const { targetPath } = (0, install_planner_1.physicalTarget)({ name: 'using-awm', type: 'skill', installName: 'using-awm', sourcePath: '/tmp/src' }, 'copilot', 'local', projectRoot);
+        expect(path_1.default.basename(targetPath)).toBe('using-awm.instructions.md');
+    });
+});

package/dist/tests/core/init/all-baseline-bundles.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// `awm init` and `awm update` disagreed about what "the baseline" is.
+//
+//   init   (steps.ts)          bundles.find(b => b.scope === 'baseline')     ← the FIRST one
+//   update (reconciliation.ts) bundles.filter(b => b.scope === 'baseline' …) ← all of them
+//
+// A registry shipping two baseline bundles therefore installed one on `awm init` and
+// two on the next `awm update` — and the diagnostic that decides whether the baseline
+// is satisfied used `find` too, so it agreed with init and disagreed with update. The
+// second bundle appeared out of nowhere on an unrelated command, and nothing before
+// that had reported it missing.
+//
+// `filter` is the correct reading: `scope: 'baseline'` is a property a bundle HAS, not
+// a slot only one bundle can occupy.
+const steps_1 = require("../../../src/core/init/steps");
+function bundle(name, scope) {
+    return {
+        name, description: '', version: '1.0.0', scope, visibility: 'public',
+        dependsOn: [], skills: [], workflows: [], agents: [], source: `bundles/${name}`,
+    };
+}
+function deps(bundles) {
+    const installs = [];
+    const d = {
+        cwd: '/repo',
+        agent: 'claude-code',
+        enabledAgents: ['claude-code'],
+        bundles,
+        installMethod: 'symlink',
+        registryRoot: '',
+        contentDir: '',
+        sensorPacksRoot: '',
+        ctx: {
+            machine: { devCore: { present: false, brokenLinks: [] } },
+            project: null,
+        },
+        actions: { installBundle: (o) => { installs.push(o.bundleName); } },
+    };
+    return { d, installs };
+}
+describe('awm init installs every baseline bundle, like awm update reconciles every one', () => {
+    it('installs all of them, not just the first', () => {
+        const { d, installs } = deps([
+            bundle('dev-core', 'baseline'),
+            bundle('team-baseline', 'baseline'),
+            bundle('frontend', 'project'),
+        ]);
+        const result = (0, steps_1.stepDevCore)(d);
+        expect(installs).toEqual(['dev-core', 'team-baseline']);
+        expect(result.action).toBe('applied');
+    });
+    it('installs nothing from a non-baseline scope', () => {
+        const { d, installs } = deps([bundle('dev-core', 'baseline'), bundle('extras', 'ambient')]);
+        (0, steps_1.stepDevCore)(d);
+        expect(installs).toEqual(['dev-core']);
+    });
+    it('still skips entirely when the baseline is already satisfied', () => {
+        const { d, installs } = deps([bundle('dev-core', 'baseline'), bundle('team-baseline', 'baseline')]);
+        d.ctx.machine.devCore.present = true;
+        expect((0, steps_1.stepDevCore)(d).action).toBe('skipped');
+        expect(installs).toEqual([]);
+    });
+});

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 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");
+const tmp_1 = require("../../support/tmp");
+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 = (0, tmp_1.mkCanonicalTmpDir)('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 = (0, tmp_1.mkCanonicalTmpDir)('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/mutation-targets-canonical.test.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `planInitMutationTargets` mezclaba dos formas de la misma ruta.
+//
+// Deriva algunos destinos de `cwd` tal como lo recibe, y otros de
+// `findProjectRoot(cwd)` — que hace `realpathSync`. Mientras las dos coincidan, el `Set`
+// deduplica y nadie lo nota. En macOS NO coinciden: `/var/folders/…` es un symlink a
+// `/private/var/folders/…`, asi que la CI de macOS mostro `AGENTS.md` y
+// `.awm/context/awm-context.md` DOS VECES en la lista de destinos, una por cada forma:
+//
+//     /var/folders/…/AGENTS.md              ← derivado de cwd
+//     /private/var/folders/…/AGENTS.md      ← derivado de findProjectRoot(cwd)
+//
+// Esa lista es lo que `beginBackupSession` respalda y lo que el rollback restaura. Un
+// mismo archivo entrando dos veces significa dos entradas de backup para un solo
+// archivo, y un rollback que lo restaura dos veces — sobre un mecanismo cuyo unico
+// trabajo es dejar el disco exactamente como estaba.
+//
+// El bug no necesita macOS: cualquier `cwd` que pase por un symlink lo reproduce. Este
+// test arma esa situacion a mano, asi que corre igual en los tres sistemas.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const mutation_targets_1 = require("../../../src/core/init/mutation-targets");
+describe('los destinos de mutacion son canonicos: un archivo, una entrada', () => {
+    let real;
+    let linkDir;
+    beforeEach(() => {
+        // `real` es el directorio de verdad; `linkDir` es un symlink que apunta ahi.
+        // Pasar `linkDir` como cwd es exactamente lo que hace macOS con /var → /private/var.
+        const base = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-canon-')));
+        real = path_1.default.join(base, 'real');
+        linkDir = path_1.default.join(base, 'link');
+        fs_1.default.mkdirSync(path_1.default.join(real, '.git'), { recursive: true }); // marcador de proyecto
+        fs_1.default.symlinkSync(real, linkDir, 'dir');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(path_1.default.dirname(real), { recursive: true, force: true });
+    });
+    /** Todo destino resuelto a su forma canonica: dos entradas que resuelven al mismo
+     *  archivo son la misma entrada, sin importar como se escribieron. */
+    const canonical = (p) => {
+        try {
+            return fs_1.default.realpathSync(p);
+        }
+        catch { /* aun no existe */ }
+        const parent = path_1.default.dirname(p);
+        try {
+            return path_1.default.join(fs_1.default.realpathSync(parent), path_1.default.basename(p));
+        }
+        catch {
+            return p;
+        }
+    };
+    it.each(['copilot', 'cursor'])('%s: no enumera el mismo archivo dos veces cuando cwd pasa por un symlink', (agent) => {
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd: linkDir, agent, bundles: [] });
+        const seen = new Map();
+        for (const t of targets) {
+            const key = canonical(t);
+            seen.set(key, [...(seen.get(key) ?? []), t]);
+        }
+        const duplicados = [...seen.entries()].filter(([, forms]) => forms.length > 1);
+        expect(duplicados).toEqual([]);
+    });
+    it('sigue enumerando AGENTS.md y el contexto materializado — deduplicar no es perder', () => {
+        // La correccion es colapsar formas equivalentes, NO dejar de cubrir el archivo:
+        // sub-enumerar es el unico modo de falla que derrota el rollback en silencio.
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd: linkDir, agent: 'copilot', bundles: [] })
+            .map(canonical);
+        expect(targets).toContain(path_1.default.join(real, 'AGENTS.md'));
+        expect(targets).toContain(path_1.default.join(real, '.awm', 'context', 'awm-context.md'));
+    });
+    it('no depende del symlink: con un cwd ya canonico da el mismo resultado', () => {
+        const viaLink = (0, mutation_targets_1.planInitMutationTargets)({ cwd: linkDir, agent: 'copilot', bundles: [] }).map(canonical).sort();
+        const viaReal = (0, mutation_targets_1.planInitMutationTargets)({ cwd: real, agent: 'copilot', bundles: [] }).map(canonical).sort();
+        expect(viaLink).toEqual(viaReal);
+    });
+});

package/dist/tests/core/init/mutation-targets.test.js

@@ -17,9 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // tests/core/skill-integrity.test.ts. Per CLAUDE.md, no test may touch the
 // real ~/.awm.
 const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const materializer_1 = require("../../../src/core/context/materializer");
+const tmp_1 = require("../../support/tmp");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
@@ -32,7 +32,7 @@ let originalHome;
 let originalAwmHome;
 let extraDirs;
 beforeEach(() => {
-    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-'));
+    tmpHome = (0, tmp_1.mkCanonicalTmpDir)('awm-mutation-targets-');
     originalHome = process.env.HOME;
     originalAwmHome = process.env.AWM_HOME;
     process.env.HOME = tmpHome;
@@ -67,7 +67,7 @@ function load() {
 }
 /** A cwd guaranteed to have no project-root marker (.git/package.json/.awm) in its ancestry. */
 function bareCwd() {
-    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-cwd-'));
+    const dir = (0, tmp_1.mkCanonicalTmpDir)('awm-mutation-targets-cwd-');
     extraDirs.push(dir);
     return dir;
 }
@@ -158,7 +158,7 @@ describe('planInitMutationTargets', () => {
     });
     describe('project-level targets', () => {
         function makeProjectRoot() {
-            const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-project-'));
+            const root = (0, tmp_1.mkCanonicalTmpDir)('awm-mutation-targets-project-');
             fs_1.default.mkdirSync(path_1.default.join(root, '.git')); // project-root marker for findProjectRoot
             extraDirs.push(root);
             return root;

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' }));