agentic-workflow-manager 3.13.1 → 3.13.3

package/dist/src/commands/doctor.js

@@ -99,6 +99,14 @@ function providerCheckLine(check) {
 function renderProviderReport(report) {
     const lines = [];
     lines.push(picocolors_1.default.bold('AWM · harness status'));
+    lines.push(picocolors_1.default.dim(`  platform: ${(0, paths_1.platformLabel)()}`));
+    // Advisory only, native Windows only. This is the text rendered by the
+    // real `awm doctor` command (`runDoctor` below) — the diagnostics surface
+    // an operator actually goes looking at for platform-specific detail.
+    // `init`/`update`/`sync` also note it once each, at the top of their own
+    // run (`runInit`/`runUpdateCore`/`runSyncCore`), independently of this.
+    if ((0, paths_1.isWindowsNative)())
+        lines.push(picocolors_1.default.dim(`  ${paths_1.WINDOWS_KNOWN_GAP.replace(/\n\s*/g, ' ')}`));
     lines.push('');
     for (const provider of report.providers) {
         lines.push(`Provider: ${provider.label} ${picocolors_1.default.dim(`(${provider.tier})`)}`);

package/dist/src/commands/init.js

@@ -125,6 +125,11 @@ function reportInitFailure(o) {
     return 2;
 }
 async function runInit(opts = {}) {
+    // Fires at most once per `awm init` run (native Windows only) — this is
+    // the single emission point; `renderReport`/`renderInitOutcome` below do
+    // NOT also embed it (that used to triple-fire the same text: once here,
+    // once in the "Initial state" render, once in "Final state").
+    (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
     const cwd = opts.cwd ?? process.cwd();
     const agent = opts.agent === undefined ? 'claude-code' : (0, providers_1.requireAgentTarget)(opts.agent);
     // R2: gate BEFORE anything is read or written — an unsupported provider
@@ -313,7 +318,6 @@ function registerInitCommand(program) {
         .option('--machine-only', 'Only run machine-level steps (skip project steps)')
         .option('--json', 'Emit the InitOutcome as JSON — on success and on failure (failed steps + rollback)')
         .action(async (options) => {
-        (0, paths_1.warnIfUnsupportedPlatform)((m) => console.warn(picocolors_1.default.yellow(`⚠ ${m}`)));
         const code = await runInit({
             yes: options.yes,
             agent: options.agent,

package/dist/src/commands/sync.js

@@ -16,6 +16,7 @@ exports.runSyncCore = runSyncCore;
 // intro/outro chrome lives in `index.ts`'s Commander registration instead
 // (which already imports clack at the top and is never `require()`d by tests).
 const picocolors_1 = __importDefault(require("picocolors"));
+const paths_1 = require("../core/paths");
 const profile_1 = require("../core/profile");
 const registries_1 = require("../core/registries");
 const bundles_1 = require("../core/bundles");
@@ -31,6 +32,9 @@ const defaultDeps = {
 };
 /** Core, UI-free `awm sync` logic — see `runSync` for the Commander-facing wrapper. */
 async function runSyncCore(options, deps = {}) {
+    // Fires at most once per `awm sync` run, native Windows only — the single
+    // emission point for this command (mirrors `runInit`/`runUpdateCore`).
+    (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
     const d = { ...defaultDeps, ...deps };
     const cwd = options.cwd ?? process.cwd();
     const projectRoot = (0, profile_1.findProjectRoot)(cwd);

package/dist/src/commands/update.js

@@ -20,6 +20,7 @@ exports.runUpdateCore = runUpdateCore;
 // instead (which already imports clack at the top and is never `require()`d
 // by tests).
 const picocolors_1 = __importDefault(require("picocolors"));
+const paths_1 = require("../core/paths");
 const config_1 = require("../utils/config");
 const agent_targets_1 = require("../core/agent-targets");
 const registries_1 = require("../core/registries");
@@ -49,6 +50,9 @@ const defaultDeps = {
  * `runInit`'s `actions` seam).
  */
 async function runUpdateCore(options = {}, deps = {}) {
+    // Fires at most once per `awm update` run, native Windows only — the
+    // single emission point for this command (mirrors `runInit`/`runSyncCore`).
+    (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
     const d = { ...defaultDeps, ...deps };
     const prefs = (0, config_1.getPreferences)();
     const resolved = (0, agent_targets_1.resolveAgentTargetsOrError)({ prefs, explicit: options.agent });

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

@@ -275,17 +275,51 @@ function spawnStructured(argv, cwd, nonce, extraEnv = {}) {
  *  rompia el invariante "JAMAS safe sin evidencia" (safeToReplace
  *  devolvia 'safe' para un proceso vivo). process.kill(pid,0) evita la
  *  capa de emulacion por completo. */
+/** Sleep sincronico REAL, multiplataforma, sin depender de un binario externo
+ *  (`sleep` no existe nativamente en win32 — ver el comentario de sleepSync
+ *  mas arriba). `Atomics.wait` sobre un buffer compartido bloquea el hilo
+ *  actual durante `ms` sin abrir ningun subproceso; funciona identico en
+ *  cualquier plataforma que soporte Node. Usado SOLO por pidExistsNative
+ *  para el reintento acotado de abajo — nunca en un hot-path de alta
+ *  frecuencia. */
+function sleepMsSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/** Reintento acotado (R6, post-mortem de CI real): dos corridas reales de
+ *  windows-latest sobre el MISMO commit (uno vía `release.yml`, uno vía
+ *  `ci.yml`, ambos re-corriendo el suite completo desde cero) dieron
+ *  resultados DISTINTOS para el mismo test — `pidExistsNative` reportando
+ *  ESRCH para un proceso recien spawneado por el propio test, genuinamente
+ *  vivo — evidencia directa de una condicion de carrera transitoria
+ *  especifica de esta plataforma/runner, no un bug determinista (el codigo
+ *  no cambio entre ambas corridas). Un solo intento en el hot-path exacto
+ *  "acabo de spawnear esto, ¿esta vivo?" no le da tiempo al SO a que el pid
+ *  sea consultable via OpenProcess bajo carga pesada del runner. Reintentar
+ *  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;
 function pidExistsNative(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        // ESRCH = el SO confirmo que el pid no existe. Cualquier otro
-        // codigo (ej. EPERM: existe pero sin permiso de senializarlo) NO
-        // es evidencia de muerte — falla a favor de "vivo" (R2.1).
-        return error.code !== 'ESRCH';
+    for (let attempt = 0; attempt < PID_EXISTS_RETRY_ATTEMPTS; attempt++) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            // ESRCH = el SO confirmo que el pid no existe. Cualquier otro
+            // codigo (ej. EPERM: existe pero sin permiso de senializarlo) NO
+            // es evidencia de muerte — falla a favor de "vivo" (R2.1).
+            if (error.code !== 'ESRCH')
+                return true;
+            if (attempt < PID_EXISTS_RETRY_ATTEMPTS - 1)
+                sleepMsSync(PID_EXISTS_RETRY_DELAY_MS);
+        }
     }
+    return false;
 }
 /** Vivo Y con la MISMA identidad — tupla completa, nunca PID solo (R2.1,
  *  bloqueador 6): startTime + pgid + digest de ps args.

package/dist/src/core/paths.js

@@ -3,13 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WINDOWS_NATIVE_WARNING = void 0;
+exports.WINDOWS_KNOWN_GAP = void 0;
 exports.homeDir = homeDir;
 exports.awmHome = awmHome;
 exports.platform = platform;
 exports.isWindowsNative = isWindowsNative;
 exports.platformLabel = platformLabel;
-exports.warnIfUnsupportedPlatform = warnIfUnsupportedPlatform;
+exports.noteWindowsCaveat = noteWindowsCaveat;
 exports.resolveOnPath = resolveOnPath;
 // cli/src/core/paths.ts
 //
@@ -35,11 +35,14 @@ function platform() {
 function isWindowsNative() {
     return platform() === 'win32';
 }
-/** Human-friendly platform label for diagnostics. */
+/** Human-friendly platform label for diagnostics. Windows is a first-class,
+ *  CI-verified platform since R6 (`.github/workflows/ci.yml` runs the full
+ *  suite on `ubuntu-latest` + `windows-latest` on every PR) — this no longer
+ *  hedges toward WSL. */
 function platformLabel() {
     switch (platform()) {
         case 'win32':
-            return 'Windows (native — not supported yet, use WSL)';
+            return 'Windows (native, CI-verified)';
         case 'darwin':
             return 'macOS';
         case 'linux':
@@ -48,13 +51,28 @@ function platformLabel() {
             return platform();
     }
 }
-exports.WINDOWS_NATIVE_WARNING = 'AWM detected native Windows. Native support is deferred; the recommended path today is WSL.\n' +
-    '  Install WSL (https://learn.microsoft.com/windows/wsl/install) and run AWM inside your Linux distro.\n' +
-    '  Continuing in best-effort mode, but some steps (symlinks, hooks) may not work.';
-/** Emit the unsupported-platform warning via the provided logger, only on native Windows. */
-function warnIfUnsupportedPlatform(log) {
+/**
+ * The one honest, narrow gap left on native Windows: `awm watch`'s supervisor
+ * crash-recovery E2E tests (spawn -> identity capture -> adoption after the
+ * supervisor is killed) never converged on real `windows-latest` CI despite 4
+ * evidence-based fix attempts in R6 (WMI-based `refIsAlive`, `activitySnapshot`
+ * degraded off `ps`/`pgrep`, `spawnStructured`'s `detached` flag tried both
+ * ways) — scoped POSIX-only (`itPosix`) in `cli/tests/commands/watch/
+ * supervisor-loop.test.ts` (2 tests) and `cli/tests/commands/watch/
+ * e2e-crash.test.ts` (2 tests); see the `refIsAlive` comment in
+ * `cli/src/core/journal/process.ts` for the full investigation. This is
+ * deliberately narrow, not a blanket "some things may not work" hedge:
+ * `awm init`/`update`/`sync`/`sensors`/`preflight`/`doctor`/hooks are all
+ * exercised green by the same CI matrix and are unaffected by this gap.
+ */
+exports.WINDOWS_KNOWN_GAP = 'AWM on native Windows: supported and continuously verified in CI (ubuntu-latest + windows-latest, every PR).\n' +
+    '  One known, narrow gap: `awm watch`\'s supervisor crash-recovery (spawn -> identity capture -> adoption\n' +
+    '  after the supervisor is killed) has not yet converged on real windows-latest CI — see\n' +
+    '  cli/src/core/journal/process.ts (refIsAlive) for detail. Everything else is CI-verified on Windows.';
+/** Emit `WINDOWS_KNOWN_GAP` via the provided logger, only on native Windows. */
+function noteWindowsCaveat(log) {
     if (isWindowsNative())
-        log(exports.WINDOWS_NATIVE_WARNING);
+        log(exports.WINDOWS_KNOWN_GAP);
 }
 /** Resolve a binary on PATH portably: `where` on win32, POSIX `command -v` elsewhere. */
 function resolveOnPath(bin) {

package/dist/src/index.js

@@ -42,7 +42,6 @@ const sync_1 = require("./commands/sync");
 const update_1 = require("./commands/update");
 const agent_targets_1 = require("./core/agent-targets");
 const update_check_1 = require("./core/update-check");
-const paths_1 = require("./core/paths");
 const cli_version_1 = require("./core/cli-version");
 const program = new commander_1.Command();
 program.name('awm').description('Agentic Workflow Manager').version((0, cli_version_1.cliVersion)());
@@ -390,7 +389,6 @@ program.command('update')
     .option('-a, --agent <agent>', `Target agent(s), comma-separated: ${providers_1.AGENT_TARGETS.join(', ')} (defaults to every enabled agent)`)
     .action(async (options) => {
     (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Update Registries ')));
-    (0, paths_1.warnIfUnsupportedPlatform)((m) => console.warn(picocolors_1.default.yellow(`⚠ ${m}`)));
     const result = await (0, update_1.runUpdateCore)(options);
     (0, prompts_1.outro)(result.code === 0 ? '✅ Registries, skills and hooks updated.' : picocolors_1.default.red('Update failed — see errors above.'));
     process.exitCode = result.code;
@@ -401,7 +399,6 @@ program.command('sync')
     .option('-m, --method <method>', 'Install method: symlink or copy', 'symlink')
     .action(async (options) => {
     (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Sync Project Profile ')));
-    (0, paths_1.warnIfUnsupportedPlatform)((m) => console.warn(picocolors_1.default.yellow(`⚠ ${m}`)));
     const { code } = await (0, sync_1.runSyncCore)(options);
     (0, prompts_1.outro)(code === 0 ? 'Done.' : picocolors_1.default.red('Sync failed — see errors above.'));
     process.exitCode = code;

package/dist/tests/commands/doctor-platform.test.js

@@ -6,17 +6,61 @@ describe('doctor renderReport — platform line', () => {
     afterEach(() => {
         Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
     });
+    function setPlatform(p) {
+        Object.defineProperty(process, 'platform', { value: p, configurable: true });
+    }
     function emptyReport() {
         return { overall: 'healthy', hasProject: false, projectName: undefined, results: [] };
     }
     it('renders the platform label under the Machine header', () => {
-        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        setPlatform('linux');
         const out = (0, doctor_1.renderReport)(emptyReport());
         expect(out).toContain('platform: Linux');
     });
-    it('flags native Windows with a WSL hint', () => {
-        Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+    it('labels native Windows as supported and CI-verified, not deferred to WSL', () => {
+        setPlatform('win32');
+        const out = (0, doctor_1.renderReport)(emptyReport());
+        expect(out).toContain('platform: Windows (native, CI-verified)');
+        expect(out).not.toContain('WSL');
+    });
+    // `renderReport` (init's before/after dashboard) deliberately does NOT
+    // embed the Windows caveat — it used to (R7), which made a single `awm
+    // init` run print the same caveat text 3 times (once via `noteWindowsCaveat`
+    // at the top of `runInit`, once for "Initial state", once for "Final
+    // state"). The caveat now lives solely in `runInit`'s own single emission
+    // and in `renderProviderReport` below (the real `awm doctor` output).
+    it('never embeds the awm-watch supervisor caveat in the init before/after dashboard', () => {
+        setPlatform('win32');
         const out = (0, doctor_1.renderReport)(emptyReport());
-        expect(out).toContain('WSL');
+        expect(out).not.toMatch(/awm watch/i);
+    });
+});
+// Regression coverage for the confirmed bug: the `WINDOWS_KNOWN_GAP` caveat
+// used to live only inside `renderReport`, whose only callers are `init.ts`'s
+// before/after dashboard — `awm doctor`'s REAL command path
+// (`runDoctor` → `renderProviderReport`) never touched it, so a user running
+// `awm doctor` on native Windows never saw the caveat its own code comment
+// claimed doctor was the place for. This exercises `renderProviderReport`
+// directly, the function `runDoctor` actually calls for its text output.
+describe('doctor renderProviderReport — platform caveat (the real `awm doctor` path)', () => {
+    const realPlatform = process.platform;
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
+    });
+    function setPlatform(p) {
+        Object.defineProperty(process, 'platform', { value: p, configurable: true });
+    }
+    function emptyProviderReport() {
+        return { overall: 'healthy', providers: [] };
+    }
+    it('surfaces the narrow awm-watch supervisor caveat on native Windows only, not on macOS or Linux', () => {
+        setPlatform('win32');
+        const winOut = (0, doctor_1.renderProviderReport)(emptyProviderReport());
+        expect(winOut).toMatch(/awm watch/i);
+        for (const p of ['linux', 'darwin']) {
+            setPlatform(p);
+            const out = (0, doctor_1.renderProviderReport)(emptyProviderReport());
+            expect(out).not.toMatch(/awm watch/i);
+        }
     });
 });

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

@@ -121,6 +121,25 @@ describe('runDoctor', () => {
         const code = (0, doctor_1.runDoctor)({ cwd: tmpHome });
         expect(code).toBe(1);
     });
+    // Finding #1 (R7 QA): the real `awm doctor` command (this `runDoctor`,
+    // text mode — not `renderReport`, which only `init.ts` calls) must
+    // actually surface the Windows caveat on native Windows.
+    it('surfaces the Windows caveat in real text output on native Windows only', () => {
+        const realPlatform = process.platform;
+        try {
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            writeSpy.mockClear();
+            (0, doctor_1.runDoctor)({ cwd: tmpHome });
+            expect(stdout()).toMatch(/awm watch/i);
+            Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+            writeSpy.mockClear();
+            (0, doctor_1.runDoctor)({ cwd: tmpHome });
+            expect(stdout()).not.toMatch(/awm watch/i);
+        }
+        finally {
+            Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
+        }
+    });
     it('--json emits a parseable provider report and keeps the same exit code', () => {
         const code = (0, doctor_1.runDoctor)({ cwd: tmpHome, json: true });
         const parsed = JSON.parse(stdout());

package/dist/tests/commands/init.test.js

@@ -70,6 +70,45 @@ describe('runInit', () => {
         else
             process.env.AWM_HOME = originalAwmHome;
     });
+    // Finding #2/#3 (R7 QA): the Windows caveat used to fire via a direct
+    // call in registerInitCommand's Commander `.action()` closure — a call
+    // site no test exercised, since every other `runInit` test here bypasses
+    // the Commander wrapper entirely. It now lives at the top of `runInit`
+    // itself (the unit these tests already drive directly), firing at most
+    // once per run, native Windows only.
+    describe('Windows caveat (noteWindowsCaveat)', () => {
+        const realPlatform = process.platform;
+        let logSpy;
+        beforeEach(() => {
+            logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            logSpy.mockRestore();
+            Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
+        });
+        it('logs the caveat exactly once on native Windows', async () => {
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const { runInit } = require('../../src/commands/init');
+            await runInit({
+                cwd: tmpHome,
+                yes: true,
+                actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) },
+            });
+            const caveatCalls = logSpy.mock.calls.filter((c) => /awm watch/i.test(String(c[0])));
+            expect(caveatCalls).toHaveLength(1);
+        });
+        it('never logs the caveat on non-Windows platforms', async () => {
+            Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+            const { runInit } = require('../../src/commands/init');
+            await runInit({
+                cwd: tmpHome,
+                yes: true,
+                actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) },
+            });
+            const caveatCalls = logSpy.mock.calls.filter((c) => /awm watch/i.test(String(c[0])));
+            expect(caveatCalls).toHaveLength(0);
+        });
+    });
     it('returns exit 1 on a bare HOME and never prompts with --yes (cache stubbed)', async () => {
         const { runInit } = require('../../src/commands/init');
         const code = await runInit({

package/dist/tests/commands/multi-agent-targeting.test.js

@@ -208,6 +208,71 @@ describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
         });
         expect(outcome.code).toBe(1); // no silent catch{} — verifies Step 6's "no aborta" removal
     });
+    // Finding #3 (R7 QA): `noteWindowsCaveat` used to be called only from the
+    // raw Commander `.action()` closures in `index.ts` (update.ts:441,
+    // sync.ts:453 pre-fix) — call sites no test exercised, since `update`/
+    // `sync` are always driven here via `runUpdateCore`/`runSyncCore`
+    // directly. It now lives at the top of those core functions themselves,
+    // firing at most once per run, native Windows only.
+    describe('Windows caveat (noteWindowsCaveat) — update & sync', () => {
+        const realPlatform = process.platform;
+        let logSpy;
+        beforeEach(() => {
+            logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            logSpy.mockRestore();
+            Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
+        });
+        function caveatCalls() {
+            return logSpy.mock.calls.filter((c) => /awm watch/i.test(String(c[0])));
+        }
+        it('update logs the caveat exactly once on native Windows, never on Linux', async () => {
+            writePrefs(['claude-code']);
+            const { runUpdateCore } = require('../../src/commands/update');
+            const deps = {
+                syncRegistries: async () => [],
+                verifyMinCliVersions: () => [],
+                regenerateGlobalContext: () => [],
+                planReconciliation: () => ({ operations: [], records: [], reports: [] }),
+                applyInstallPlan: () => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }),
+                resyncInstalledHooks: () => [],
+                offerSelfUpdate: async () => { },
+            };
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            await runUpdateCore({}, deps);
+            expect(caveatCalls()).toHaveLength(1);
+            logSpy.mockClear();
+            Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+            await runUpdateCore({}, deps);
+            expect(caveatCalls()).toHaveLength(0);
+        });
+        it('sync logs the caveat exactly once on native Windows, never on Linux', async () => {
+            writePrefs(['claude-code']);
+            const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sync-project-'));
+            fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: [] }));
+            const { runSyncCore } = require('../../src/commands/sync');
+            const deps = {
+                syncRegistries: async () => [],
+                verifyMinCliVersions: () => [],
+                verifyProjectPins: async () => [],
+                syncProfile: () => ({ installed: [], skipped: [], extensions: [], transactionIds: [], modifiedFiles: [] }),
+            };
+            try {
+                Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+                await runSyncCore({ cwd: projectRoot }, deps);
+                expect(caveatCalls()).toHaveLength(1);
+                logSpy.mockClear();
+                Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+                await runSyncCore({ cwd: projectRoot }, deps);
+                expect(caveatCalls()).toHaveLength(0);
+            }
+            finally {
+                fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+            }
+        });
+    });
     it('sync reports a syncProfile failure and returns a non-zero exit code instead of crashing uncaught', async () => {
         writePrefs(['claude-code'], 'claude-code');
         const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sync-project-'));

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

@@ -237,6 +237,22 @@ describe('process identity (win32, mockeado — sin windows real disponible en e
         expect((0, process_1.refIsAlive)(fakeRef)).toBe(false);
         expect(killSpy).toHaveBeenCalledWith(999999, 0);
     });
+    test('pidExistsNative reintenta un ESRCH transitorio antes de declarar muerte — no confia en un unico intento (regresion: CI real windows-latest, dos corridas del mismo commit dieron resultados distintos para un proceso recien spawneado)', () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        let calls = 0;
+        const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => {
+            calls++;
+            if (calls < 3) {
+                const err = new Error('transient');
+                err.code = 'ESRCH';
+                throw err;
+            }
+            return true; // el pid "aparece" recien al tercer intento — simula la carrera real observada
+        });
+        const fakeRef = { pid: 424242, startTime: 'x', spawnNonce: 'n', argvDigest: 'd', processGroup: 424242, psArgsDigest: 'x' };
+        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('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/paths.test.js

@@ -67,17 +67,44 @@ describe('core/paths', () => {
         setPlatform('darwin');
         expect((0, paths_1.platformLabel)()).toBe('macOS');
         setPlatform('win32');
-        expect((0, paths_1.platformLabel)()).toContain('WSL');
+        // Windows is a first-class, CI-verified platform since R6 — the label no
+        // longer hedges toward WSL, and must not silently regress back to it.
+        expect((0, paths_1.platformLabel)()).toBe('Windows (native, CI-verified)');
+        expect((0, paths_1.platformLabel)()).not.toContain('WSL');
     });
-    it('warnIfUnsupportedPlatform calls the logger only on win32', () => {
+    it('noteWindowsCaveat calls the logger only on win32, with the narrow watch-supervisor gap', () => {
         const calls = [];
         const log = (m) => calls.push(m);
         setPlatform('linux');
-        (0, paths_1.warnIfUnsupportedPlatform)(log);
+        (0, paths_1.noteWindowsCaveat)(log);
         expect(calls).toHaveLength(0);
         setPlatform('win32');
-        (0, paths_1.warnIfUnsupportedPlatform)(log);
-        expect(calls).toEqual([paths_1.WINDOWS_NATIVE_WARNING]);
+        (0, paths_1.noteWindowsCaveat)(log);
+        expect(calls).toEqual([paths_1.WINDOWS_KNOWN_GAP]);
+        // The message must assert Windows support, not disclaim it, and must name
+        // the one specific gap rather than a blanket "some things may not work"
+        // hedge — pinning both halves so neither regresses independently.
+        expect(paths_1.WINDOWS_KNOWN_GAP).toMatch(/supported and continuously verified/i);
+        expect(paths_1.WINDOWS_KNOWN_GAP).toMatch(/awm watch/i);
+        expect(paths_1.WINDOWS_KNOWN_GAP).not.toMatch(/WSL/i);
+        expect(paths_1.WINDOWS_KNOWN_GAP).not.toMatch(/not supported/i);
+    });
+    it('noteWindowsCaveat propagates a throwing logger instead of swallowing it', () => {
+        // `noteWindowsCaveat` has no try/catch around the logger call — callers
+        // (init.ts/update.ts/sync.ts/doctor.ts) all pass simple `console.log`
+        // wrappers that are not expected to throw, and every caller controls its
+        // own logger, so there is no shared reason for this helper to be
+        // defensive on their behalf. Pin that behavior explicitly: a throwing
+        // logger's error propagates out of `noteWindowsCaveat`, it is not
+        // swallowed.
+        setPlatform('win32');
+        const boom = new Error('logger exploded');
+        const throwingLog = () => { throw boom; };
+        expect(() => (0, paths_1.noteWindowsCaveat)(throwingLog)).toThrow(boom);
+        // And on non-Windows the logger is never even invoked, so a throwing
+        // logger is harmless there.
+        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', () => {

package/package.json

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