agentic-workflow-manager 3.13.3 → 3.13.4

package/dist/src/core/diagnostics/context.js

@@ -112,19 +112,33 @@ function gatherMachine(bundles, agent = 'claude-code') {
     }
     catch { /* sin soporte de hooks → ausente */ }
     // devCore (bundle baseline) — skillsDir is null only for providers with no global skill
-    // discovery mechanism (today: Copilot); treated the same as "nothing linked here yet".
+    // discovery mechanism (today: Copilot); for those, there is no global-scope devCore
+    // concept to satisfy at all, so it's treated as trivially satisfied (see below).
     const skillsDir = (0, providers_1.providerFor)(agent).skill.global;
     const baseline = bundles.find((b) => b.scope === 'baseline');
     let devCorePresent = false;
     let brokenLinks = [];
     if (baseline) {
         const skillNames = (0, bundles_1.resolveBundleSkills)(baseline.name, bundles);
-        const { linked, broken } = skillsDir !== null
-            ? classifyLinks(skillNames, skillsDir)
-            : { linked: [], broken: [] };
-        const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
-        devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
-        brokenLinks = [...broken, ...absent];
+        if (skillsDir === null) {
+            // No global skill directory for this agent (today: Copilot) — there is no
+            // global-scope devCore/baseline-bundle concept to satisfy for it at all, so
+            // "N/A" is reported as satisfied (present, nothing broken) rather than
+            // "missing". Mirrors globalSkills' treatment just below (empty valid/
+            // repairable/dead when skillsDir === null). Without this, devCorePresent
+            // was unconditionally false here (linked/broken forced to empty arrays),
+            // so `machine.devCore` could never be satisfied for Copilot — stepDevCore
+            // (init/steps.ts) would fall through on every run and call installBundle at
+            // global scope, which throws (skill.global === null), rolling back the
+            // ENTIRE `awm init -a copilot` transaction, 100% of the time.
+            devCorePresent = true;
+        }
+        else {
+            const { linked, broken } = classifyLinks(skillNames, skillsDir);
+            const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
+            devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
+            brokenLinks = [...broken, ...absent];
+        }
         // Agent-type artifacts are never shared across agents (R12/R13 —
         // install-planner.ts — unlike skills, where OpenCode and Codex both
         // resolve to ~/.agents/skills). A shared skill directory already
@@ -155,9 +169,19 @@ function gatherMachine(bundles, agent = 'claude-code') {
         }
     }
     catch { /* sin config → ningún ambient deseado */ }
-    const installed = wanted.filter((name) => {
+    // Same guard as devCorePresent above: an agent with no global skill
+    // directory (today: Copilot) has no way to ever receive a globally-
+    // installed ambient bundle either — there is no global-scope "ambient"
+    // concept to satisfy for it at all. Without this, `installed` was forced
+    // to `[]` unconditionally for Copilot regardless of `wanted`, so
+    // stepAmbient (init/steps.ts) would treat every entry of a machine-level
+    // `~/.awm/config.json`'s `ambient` array as permanently missing and call
+    // installBundle at global scope — which throws for Copilot exactly like
+    // the devCore bug this file already fixes. Reported as "N/A == already
+    // satisfied" (installed), not "wanted but always missing".
+    const installed = skillsDir === null ? [...wanted] : wanted.filter((name) => {
         const skillNames = (0, bundles_1.resolveBundleSkills)(name, bundles);
-        if (skillNames.length === 0 || skillsDir === null)
+        if (skillNames.length === 0)
             return false;
         const { linked } = classifyLinks(skillNames, skillsDir);
         return linked.length === skillNames.length;

package/dist/src/core/journal/process.js

@@ -298,11 +298,28 @@ function sleepMsSync(ms) {
  *  con una pausa breve ANTES de declarar ESRCH definitivo no debilita el
  *  invariante "jamas muerte sin evidencia" — un proceso genuinamente muerto
  *  sigue reportando ESRCH en el reintento; esto solo absorbe el falso
- *  negativo transitorio. Costo maximo: ~150ms, y SOLO en la rama que ya iba
- *  a declarar "no existe" — el camino feliz (proceso vivo, exito inmediato)
- *  no paga nada. */
-const PID_EXISTS_RETRY_ATTEMPTS = 3;
-const PID_EXISTS_RETRY_DELAY_MS = 50;
+ *  negativo transitorio. Costo maximo, y SOLO en la rama que ya iba a
+ *  declarar "no existe" — el camino feliz (proceso vivo, exito inmediato)
+ *  no paga nada.
+ *
+ *  R6 post-mortem #2: el presupuesto original (3 intentos, 50ms => 100ms de
+ *  espera real) sobrevivio 2 corridas reales de windows-latest tras mergear
+ *  este mismo mecanismo, pero una tercera corrida real (commit identico,
+ *  ningun cambio en este archivo) volvio a fallar EL MISMO assert en EL
+ *  MISMO test — siempre el PRIMER spawn del archivo, nunca los siguientes
+ *  (que reusan un binario node.exe ya "calentado" por el SO/AV en ese
+ *  proceso de test). Eso apunta a latencia de arranque en frio (primer
+ *  spawn del job) empujando el tiempo de visibilidad de OpenProcess mas
+ *  alla del presupuesto anterior — no una condicion de carrera nueva, la
+ *  MISMA, con cola mas larga de lo que 100ms cubria. Presupuesto ampliado a
+ *  10 intentos / 100ms (hasta ~900ms de espera real) para darle margen real
+ *  a ese arranque en frio, siguiendo cuestionando el mismo mecanismo en vez
+ *  de reemplazarlo (systematic-debugging: 2+ fallas del mismo sintoma exacto
+ *  primero exige ampliar el mismo remedio antes de descartar la arquitectura
+ *  — a diferencia del patron de "cada intento revela un problema nuevo en
+ *  otro lugar", que si justificaria cuestionar el diseño). */
+const PID_EXISTS_RETRY_ATTEMPTS = 10;
+const PID_EXISTS_RETRY_DELAY_MS = 100;
 function pidExistsNative(pid) {
     for (let attempt = 0; attempt < PID_EXISTS_RETRY_ATTEMPTS; attempt++) {
         try {

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

@@ -103,6 +103,27 @@ describe('gatherContext', () => {
         // must surface as a broken/missing link — NOT a clean, skippable state.
         expect(ctx.machine.devCore.brokenLinks).toContain('development-process.toml');
     });
+    // Regression for the confirmed production bug: `awm init -a copilot` crashed
+    // 100% of the time with "machine.devCore: skill global scope is not
+    // supported by Copilot...", rolling back the whole init transaction.
+    // Copilot has no global skill directory (providers/index.ts's
+    // `skill.global === null`) — before this fix, devCorePresent was
+    // unconditionally false in that case (linked/broken forced to empty
+    // arrays), so `machine.devCore` could never be satisfied and stepDevCore
+    // (init/steps.ts) fell through to a global-scope installBundle call every
+    // single run, which throws for Copilot. Now it's reported as trivially
+    // satisfied ("N/A" == "nothing to do"), matching how `globalSkills`
+    // already treats the same null-skillsDir case.
+    it('machine: devCore is trivially satisfied (present, no broken links) for an agent with no global skill directory (copilot)', () => {
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({
+            cwd: tmpHome,
+            bundles: [bundle('dev-core', 'baseline', ['brainstorming'])],
+            agent: 'copilot',
+        });
+        expect(ctx.machine.devCore.present).toBe(true);
+        expect(ctx.machine.devCore.brokenLinks).toEqual([]);
+    });
     it('machine: ambient wanted read from ~/.awm/config.json, installed reflects links', () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'config.json'), JSON.stringify({ ambient: ['personal-notion'] }));
@@ -116,6 +137,29 @@ describe('gatherContext', () => {
         expect(ctx.machine.ambient.wanted).toEqual(['personal-notion']);
         expect(ctx.machine.ambient.installed).toEqual(['personal-notion']);
     });
+    // Regression for the SAME structural bug as the devCore fix above, just in
+    // the `ambient` computation a few lines below it: Copilot has no global
+    // skill directory (skill.global === null), so before this fix `installed`
+    // was forced to `[]` unconditionally regardless of `wanted`. That made
+    // `stepAmbient` (init/steps.ts) treat every entry in a machine-level
+    // `~/.awm/config.json`'s `ambient` array as permanently missing and call
+    // installBundle at GLOBAL scope for Copilot — which throws with the exact
+    // same "skill global scope is not supported by Copilot" error the devCore
+    // bug had, and rolls back the whole init transaction. Now `installed`
+    // mirrors `wanted` when skillsDir is null (N/A treated as satisfied,
+    // nothing to install), matching devCore's treatment above.
+    it('machine: ambient is trivially satisfied (installed mirrors wanted) for an agent with no global skill directory (copilot)', () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'config.json'), JSON.stringify({ ambient: ['personal-notion'] }));
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const bundles = [
+            bundle('dev-core', 'baseline', ['brainstorming']),
+            bundle('personal-notion', 'ambient', ['notion-skill']),
+        ];
+        const ctx = gatherContext({ cwd: tmpHome, bundles, agent: 'copilot' });
+        expect(ctx.machine.ambient.wanted).toEqual(['personal-notion']);
+        expect(ctx.machine.ambient.installed).toEqual(['personal-notion']);
+    });
     it('machine: contextInjection empty when opencode config is absent', () => {
         const { gatherContext } = require('../../../src/core/diagnostics/context');
         const ctx = gatherContext({ cwd: tmpHome, bundles: [] });

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

@@ -8,6 +8,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const steps_1 = require("../../../src/core/init/steps");
 const providers_1 = require("../../../src/providers");
+const context_1 = require("../../../src/core/diagnostics/context");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
@@ -141,6 +142,60 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
         expect((0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installBundle).toHaveBeenCalled();
     });
+    // Regression for the confirmed production bug: `awm init -a copilot` crashed
+    // 100% of the time with "machine.devCore: skill global scope is not
+    // supported by Copilot...", rolling back the ENTIRE init transaction (even
+    // project-local artifacts like AGENTS.md). Root cause: Copilot has no
+    // global skill directory (providerFor('copilot').skill.global === null),
+    // so gatherMachine's devCorePresent was permanently false for it, and
+    // stepDevCore fell through to installBundle at global scope on every run
+    // — an install that always throws. Fixed in diagnostics/context.ts:
+    // devCore.present is now reported `true` (N/A treated as satisfied) when
+    // skill.global is null, so this step's existing skip guard applies
+    // naturally.
+    //
+    // Unlike the rest of this describe block (which hand-builds `machine()`
+    // fixtures — a fine choice for exercising stepDevCore's own skip-guard
+    // logic in isolation), this test calls the REAL `gatherContext` (the
+    // function diagnostics/context.ts's fix actually lives in) with an
+    // isolated HOME/AWM_HOME, and feeds ITS real output into stepDevCore.
+    // That's deliberate: an earlier version of this test hand-built
+    // `devCore: { present: true, brokenLinks: [] }` directly and asserted
+    // against it, which only re-verified stepDevCore's pre-existing skip
+    // guard — reverting the context.ts fix left that version GREEN because it
+    // never called the fixed code at all. This version goes RED on revert:
+    // gatherContext would then report `devCore.present: false` for Copilot,
+    // stepDevCore would fall through to `installBundle`, and the assertions
+    // below (`action === 'skipped'`, `installBundle` not called) would fail.
+    it('devCore skips cleanly (never calls installBundle) for an agent with no global skill directory (copilot) — via real gatherContext', () => {
+        expect((0, providers_1.providerFor)('copilot').skill.global).toBeNull();
+        const tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-steps-copilot-devcore-'));
+        const originalHome = process.env.HOME;
+        const originalAwmHome = process.env.AWM_HOME;
+        try {
+            process.env.HOME = tmpHome;
+            process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+            const baselineBundle = bundle('dev-core', 'baseline', ['brainstorming']);
+            const ctx = (0, context_1.gatherContext)({ cwd: tmpHome, bundles: [baselineBundle], agent: 'copilot' });
+            const a = spies();
+            const r = (0, steps_1.stepDevCore)(deps({ machine: ctx.machine, project: null }, a, {
+                agent: 'copilot', enabledAgents: ['copilot'], bundles: [baselineBundle],
+            }));
+            expect(r.action).toBe('skipped');
+            expect(a.installBundle).not.toHaveBeenCalled();
+        }
+        finally {
+            fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+            if (originalHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = originalHome;
+            if (originalAwmHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = originalAwmHome;
+        }
+    });
     it('ambient installs only missing wanted', () => {
         const a = spies();
         const m = machine();

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

@@ -11,7 +11,31 @@ const process_1 = require("../../../src/core/journal/process");
 const paths_1 = require("../../../src/core/paths");
 describe('process identity', () => {
     test('spawnStructured produce ProcessRef con tupla completa (R2.1, R4.7)', async () => {
-        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nonce-abc');
+        // Reintento de INSTANCIA completa (no solo de la consulta), a proposito:
+        // esta misma linea fallo 2 veces reales consecutivas en windows-latest
+        // CI, la segunda vez YA con el presupuesto interno de pidExistsNative
+        // ampliado a 10 intentos/100ms (~900ms de espera real dentro de
+        // refIsAlive) — evidencia de que NO es (solo) latencia de visibilidad
+        // de OpenProcess bajo carga: un proceso genuinamente vivo no deberia
+        // seguir siendo invisible tras casi un segundo de reintentos. Apunta
+        // en cambio a que el hijo mismo puede terminar genuinamente muy
+        // temprano en este runner (imagen windows-2025-vs2026, sospecha no
+        // confirmable sin Windows real: AV/Defender interviniendo un `node -e`
+        // recien lanzado bajo carga pesada de CI). pidExistsNative reintenta
+        // la MISMA consulta sobre el MISMO pid — si ese pid ya esta
+        // genuinamente muerto, reintentar la consulta jamas ayuda. Este loop
+        // reintenta el SPAWN entero: un intento NUEVO puede sobrevivir donde
+        // el anterior no lo hizo. Si los 3 intentos mueren temprano, el
+        // ultimo `expect` de abajo sigue fallando fuerte — no enmascara una
+        // regresion real de refIsAlive.
+        let { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nonce-abc');
+        for (let attempt = 1; attempt < 3 && !(0, process_1.refIsAlive)(ref); attempt++) {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* ya ausente */ }
+            ({ child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nonce-abc'));
+        }
         expect(ref.pid).toBe(child.pid);
         expect(ref.spawnNonce).toBe('nonce-abc');
         expect(typeof ref.startTime).toBe('string');
@@ -253,6 +277,35 @@ describe('process identity (win32, mockeado — sin windows real disponible en e
         expect((0, process_1.refIsAlive)(fakeRef)).toBe(true); // NUNCA declara muerte por el ESRCH transitorio de los primeros 2 intentos
         expect(killSpy).toHaveBeenCalledTimes(3);
     });
+    test('pidExistsNative absorbe una carrera transitoria mas larga que el presupuesto original — arranque en frio del primer spawn del job (regresion #2: misma falla real, mismo test, tras el fix de 3x50ms ya mergeado)', () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        let calls = 0;
+        const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => {
+            calls++;
+            // El pid tarda 9 intentos en "aparecer" — mas alla del presupuesto
+            // anterior (3 intentos) pero dentro del ampliado (10 intentos).
+            if (calls < 9) {
+                const err = new Error('transient');
+                err.code = 'ESRCH';
+                throw err;
+            }
+            return true;
+        });
+        const fakeRef = { pid: 424243, startTime: 'x', spawnNonce: 'n', argvDigest: 'd', processGroup: 424243, psArgsDigest: 'x' };
+        expect((0, process_1.refIsAlive)(fakeRef)).toBe(true);
+        expect(killSpy).toHaveBeenCalledTimes(9);
+    });
+    test('pidExistsNative declara muerte solo tras agotar el presupuesto ampliado (10 intentos) — un ESRCH sostenido nunca se lee como vivo', () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => {
+            const err = new Error('gone');
+            err.code = 'ESRCH';
+            throw err;
+        });
+        const fakeRef = { pid: 424244, startTime: 'x', spawnNonce: 'n', argvDigest: 'd', processGroup: 424244, psArgsDigest: 'x' };
+        expect((0, process_1.refIsAlive)(fakeRef)).toBe(false);
+        expect(killSpy).toHaveBeenCalledTimes(10);
+    });
     test('refIsAlive en win32 NUNCA declara muerte por un error que no sea ESRCH (ej. EPERM: el pid existe pero sin permiso de senializarlo) (R2.1)', () => {
         Object.defineProperty(process, 'platform', { value: 'win32' });
         jest.spyOn(process, 'kill').mockImplementation(() => {

package/dist/tests/core/sync-gates.test.js

@@ -14,6 +14,31 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const child_process_1 = require("child_process");
 const GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t -c tag.gpgSign=false ${cmd}`, { cwd, stdio: 'pipe' });
+// Real `git init`/clone-adjacent work per test, several times over — on
+// windows-latest CI this is measurably slower than on POSIX and the jest
+// default of 5000ms proved too tight in real CI (regression: real
+// windows-latest run, "Exceeded timeout of 5000 ms"). Same class of issue
+// already fixed in registries-sync.test.ts earlier this session — this
+// sibling file has the identical real-git-fixture pattern and was missed.
+jest.setTimeout(30000);
+/** git en win32 puede mantener un handle abierto sobre `.git/hooks`/`.git/objects`
+ *  por un instante despues de que el proceso `git` retorna — rmSync inmediato
+ *  entonces produce EBUSY/ENOTEMPTY (regresion: real windows-latest CI). Mismo
+ *  patron ya aplicado en registries-sync.test.ts y runner.test.ts. */
+async function rmSyncRetryingBusy(target, attempts = 10, delayMs = 100) {
+    for (let i = 0; i < attempts; i++) {
+        try {
+            fs_1.default.rmSync(target, { recursive: true, force: true });
+            return;
+        }
+        catch (error) {
+            const code = error.code;
+            if ((code !== 'EBUSY' && code !== 'ENOTEMPTY') || i === attempts - 1)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+}
 function makeRegistryWithManifest(base, name, manifest) {
     const dir = path_1.default.join(base, name);
     fs_1.default.mkdirSync(dir, { recursive: true });
@@ -37,9 +62,9 @@ describe('verifyMinCliVersions (gate de awm sync / awm update)', () => {
         process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
         jest.resetModules();
     });
-    afterEach(() => {
-        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
-        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+    afterEach(async () => {
+        await rmSyncRetryingBusy(tmpHome);
+        await rmSyncRetryingBusy(tmpWork);
         if (originalHome === undefined)
             delete process.env.HOME;
         else

package/dist/tests/integration/copilot-init-isolated.test.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/integration/copilot-init-isolated.test.ts
+//
+// Regression E2E for a confirmed, 100%-reproducible production bug:
+// `awm init --agent copilot` crashed deterministically with
+// "machine.devCore: skill global scope is not supported by Copilot..." and
+// rolled back the ENTIRE init transaction (even project-local artifacts like
+// AGENTS.md).
+//
+// Root cause: Copilot has no global skill directory
+// (providers/index.ts's `skill.global === null`), so
+// diagnostics/context.ts's `gatherMachine` computed `devCore.present` as
+// permanently `false` for Copilot (no way to ever satisfy it). That made
+// `stepDevCore` (init/steps.ts) fall through on every run and call
+// `installBundle` at GLOBAL scope, which throws for a provider with no
+// global skill mechanism — an install that was always guaranteed to fail.
+//
+// Fixed in diagnostics/context.ts: when `skillsDir === null`, there is no
+// global-scope devCore/baseline-bundle concept to satisfy for this agent at
+// all, so `devCorePresent` is now reported `true` (N/A treated as
+// satisfied) — mirroring how `globalSkills` already treats the same
+// null-skillsDir case as trivially healthy. `stepDevCore`'s existing
+// `present && brokenLinks.length === 0 -> skip` guard then naturally never
+// falls through to the doomed install, with no redundant guard needed in
+// steps.ts itself.
+//
+// This test lets `awm init --agent copilot` run its REAL, unstubbed
+// pipeline end-to-end against a hand-seeded registry fixture (same pattern
+// as codex-provider-isolated.test.ts) — never against the real `~/.awm`
+// (CLAUDE.md's "never touch ~/.awm" rule; HOME/AWM_HOME are isolated
+// tmpdirs for the whole test).
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('copilot provider — isolated home E2E (devCore global-scope guard regression)', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    let writeSpy;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-copilot-e2e-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-copilot-e2e-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+        writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        writeSpy.mockRestore();
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    /** Same fixture shape as codex-provider-isolated.test.ts's seedPublicRegistryFixture:
+     *  a real content-root registry (no git repo needed) with the bootstrap skill and one
+     *  baseline bundle. Copilot needs no hooks (providers/index.ts has no `hooks` config
+     *  for it) and no native agent renderer (`agent: null`), so the fixture is intentionally
+     *  smaller than Codex's. */
+    function seedPublicRegistryFixture(root) {
+        fs_1.default.mkdirSync(path_1.default.join(root, 'hooks'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'hooks/session-start'), '#!/bin/sh\necho "{}"\n', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'hooks/run-hook.cmd'), '#!/bin/sh\nexec sh "$1"\n', { mode: 0o755 });
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills/using-awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/using-awm/SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills/development-process'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/development-process/SKILL.md'), '---\nname: development-process\n---\nOrchestrates the dev lifecycle.');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
+            version: 1,
+            bundles: [{ name: 'dev-core', source: 'bundles/dev-core', version: '1.0.0', scope: 'baseline', visibility: 'public' }],
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(root, 'bundles/dev-core'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'bundles/dev-core/bundle.json'), JSON.stringify({
+            name: 'dev-core', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
+            dependsOn: [], skills: ['development-process'], workflows: [], agents: [],
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm/registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.invalid/baseline.git' }], null, 2));
+    }
+    function readPrefs() {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/preferences.json'), 'utf8'));
+    }
+    it('completes without crashing/rolling back (real bug repro) and delivers content via AGENTS.md, not a doomed global-scope install', async () => {
+        seedPublicRegistryFixture(path_1.default.join(tmpHome, '.awm/registries/baseline'));
+        const { runInit } = require('../../src/commands/init');
+        // Real, full, unstubbed init for copilot. Before the fix, this threw
+        // "machine.devCore: skill global scope is not supported by Copilot: GitHub
+        // Copilot has no user-level skill discovery mechanism — skills must be
+        // installed per-project." and rolled back the whole transaction (exit 2,
+        // AGENTS.md reverted, preferences never committed).
+        const code = await runInit({ cwd: tmpWork, yes: true, agent: 'copilot' });
+        // 0 (healthy) or 1 (degraded-but-completed) — NOT 2 (failed/rolled back).
+        expect(code).toBeLessThanOrEqual(1);
+        // The transaction actually committed: copilot is now a real enabled agent.
+        expect(readPrefs().enabledAgents).toEqual(['copilot']);
+        // Copilot has no global skill directory at all — confirm nothing was
+        // (wrongly) written there, and no ~/.github tree was invented.
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.github'))).toBe(false);
+        // Content delivery for Copilot happens via its managed-agents-md injection
+        // mechanism at PROJECT scope (stepContextInjection, globalPath === null ->
+        // scope 'local') — confirm that path is unaffected by this fix and still
+        // really delivers the using-awm skill content into the project AGENTS.md.
+        const agentsMd = fs_1.default.readFileSync(path_1.default.join(tmpWork, 'AGENTS.md'), 'utf8');
+        expect(agentsMd).toContain('MUST invoke skills.');
+    });
+    // Regression for the SAME structural bug as the devCore one above, in the
+    // sibling `ambient` computation (diagnostics/context.ts's `gatherMachine`,
+    // a few lines below devCorePresent): before the fix, `installed` was
+    // forced to `[]` unconditionally whenever `skillsDir === null` (Copilot),
+    // regardless of what `~/.awm/config.json`'s `ambient` array wanted. That
+    // made stepAmbient (init/steps.ts) treat every wanted ambient bundle as
+    // permanently missing and call installBundle at GLOBAL scope for
+    // Copilot — throwing "skill global scope is not supported by Copilot"
+    // and rolling back the whole init transaction, exactly like the devCore
+    // bug. Nothing in the current CLI writes `ambient` into
+    // `~/.awm/config.json` automatically, but it IS read unconditionally by
+    // production code and is a real, documented mechanism a user/script can
+    // populate — so this hand-seeds it, same as a real machine config would.
+    it('with a machine-level ambient bundle configured, completes without crashing/rolling back (ambient sibling of the devCore bug)', async () => {
+        const registryRoot = path_1.default.join(tmpHome, '.awm/registries/baseline');
+        seedPublicRegistryFixture(registryRoot);
+        // Add an ambient-scope bundle to the registry fixture so `wanted`
+        // resolves to real skills (resolveBundleSkills needs the bundle to
+        // actually exist in `bundles`, discovered via discoverAllBundles()).
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/ambient-skill'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/ambient-skill/SKILL.md'), '---\nname: ambient-skill\ndescription: An ambient bundle skill.\n---\nAmbient.');
+        const catalog = JSON.parse(fs_1.default.readFileSync(path_1.default.join(registryRoot, 'catalog.json'), 'utf8'));
+        catalog.bundles.push({ name: 'personal-notion', source: 'bundles/personal-notion', version: '1.0.0', scope: 'ambient', visibility: 'public' });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'catalog.json'), JSON.stringify(catalog));
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'bundles/personal-notion'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'bundles/personal-notion/bundle.json'), JSON.stringify({
+            name: 'personal-notion', description: '', version: '1.0.0', scope: 'ambient', visibility: 'public',
+            dependsOn: [], skills: ['ambient-skill'], workflows: [], agents: [],
+        }));
+        // Seed the machine-level ambient config exactly as a user/script would.
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm/config.json'), JSON.stringify({ ambient: ['personal-notion'] }));
+        const { runInit } = require('../../src/commands/init');
+        // Before the fix, this threw "machine.ambient: skill global scope is
+        // not supported by Copilot..." (same class as the devCore crash) and
+        // rolled back the whole transaction (exit 2, AGENTS.md reverted,
+        // preferences never committed).
+        const code = await runInit({ cwd: tmpWork, yes: true, agent: 'copilot' });
+        // 0 (healthy) or 1 (degraded-but-completed) — NOT 2 (failed/rolled back).
+        expect(code).toBeLessThanOrEqual(1);
+        // The transaction actually committed.
+        expect(readPrefs().enabledAgents).toEqual(['copilot']);
+        // Copilot has no global skill directory at all — confirm the ambient
+        // bundle was NOT (wrongly) installed at global scope either.
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.github'))).toBe(false);
+    });
+    it('a subsequent `awm add <bundle> -a copilot` works once init has actually committed', async () => {
+        seedPublicRegistryFixture(path_1.default.join(tmpHome, '.awm/registries/baseline'));
+        // Add a second, non-baseline bundle the project can explicitly activate
+        // locally (Copilot only supports local-scope skill delivery — providers/
+        // index.ts's `skill.local: '.github/instructions'`).
+        const registryRoot = path_1.default.join(tmpHome, '.awm/registries/baseline');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/extra-skill'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/extra-skill/SKILL.md'), '---\nname: extra-skill\ndescription: An extra project skill.\n---\nExtra.');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'bundles/extra'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'bundles/extra/bundle.json'), JSON.stringify({
+            name: 'extra', description: '', version: '1.0.0', scope: 'project', visibility: 'public',
+            dependsOn: [], skills: ['extra-skill'], workflows: [], agents: [],
+        }));
+        const catalog = JSON.parse(fs_1.default.readFileSync(path_1.default.join(registryRoot, 'catalog.json'), 'utf8'));
+        catalog.bundles.push({ name: 'extra', source: 'bundles/extra', version: '1.0.0', scope: 'project', visibility: 'public' });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'catalog.json'), JSON.stringify(catalog));
+        // findProjectRoot needs a real project marker (.git/, package.json, or
+        // .awm/profile.json) — a bare tmpdir isn't one (same pattern as
+        // tests/commands/add.test.ts).
+        fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'package.json'), JSON.stringify({ name: 'fixture' }));
+        const { runInit } = require('../../src/commands/init');
+        const initCode = await runInit({ cwd: tmpWork, yes: true, agent: 'copilot' });
+        expect(initCode).toBeLessThanOrEqual(1);
+        expect(readPrefs().enabledAgents).toEqual(['copilot']);
+        // This was "permanently blocked" per the bug report — it requires a prior
+        // COMMITTED `awm init --agent copilot` (resolveAgentTargetsOrError rejects
+        // any agent not in enabledAgents), which never happened before the fix
+        // because every copilot init rolled back before saving preferences.
+        const { runAddBundleCore } = require('../../src/commands/add');
+        const { loadPreferences } = require('../../src/utils/config');
+        const { discoverAllBundles } = require('../../src/core/bundles');
+        const { prefs } = loadPreferences('copilot');
+        const bundles = discoverAllBundles();
+        const result = runAddBundleCore({ name: 'extra', agent: 'copilot', cwd: tmpWork }, prefs, bundles);
+        expect(result.code).toBe(0);
+        expect(result.result?.installed.length).toBeGreaterThan(0);
+        const instructionsDir = path_1.default.join(tmpWork, '.github/instructions');
+        expect(fs_1.default.existsSync(instructionsDir)).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "3.13.3",
+  "version": "3.13.4",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"