agentic-workflow-manager 9.22.0 → 9.22.1

package/dist/tests/integration/codex-provider-isolated.test.js

@@ -42,6 +42,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const commit_seeded_registry_1 = require("../helpers/commit-seeded-registry");
 describe('codex provider — isolated home E2E (Task 9)', () => {
     let tmpHome;
     let tmpWork;
@@ -79,8 +80,10 @@ describe('codex provider — isolated home E2E (Task 9)', () => {
     });
     /** Hand-seeds a registry content root with everything a real `awm init` needs:
      *  hooks (Claude + Codex), the bootstrap skill, one baseline bundle providing
-     *  both a skill and a Codex-native agent artifact. No git repo involved — the
-     *  registry cache is content-root-shaped, exactly what a real clone produces. */
+     *  both a skill and a Codex-native agent artifact. Content-root-shaped like a
+     *  real clone, plus a local `.git` commit so `machine.registryCache.present`
+     *  is true and `stepCache` skips network sync (SG-7 hard-fails any sync error,
+     *  and `https://example.invalid/...` is intentionally unreachable). */
     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 });
@@ -101,6 +104,8 @@ describe('codex provider — isolated home E2E (Task 9)', () => {
             name: 'dev-core', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
             dependsOn: [], skills: ['development-process'], workflows: [], agents: ['development-process'],
         }));
+        // Local commit only — no origin. Present+.git makes stepCache skip sync.
+        (0, commit_seeded_registry_1.commitSeededRegistry)(root);
         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));
     }

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

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const commit_seeded_registry_1 = require("../helpers/commit-seeded-registry");
 describe('copilot provider — isolated home E2E (devCore global-scope guard regression)', () => {
     let tmpHome;
     let tmpWork;
@@ -67,10 +68,11 @@ describe('copilot provider — isolated home E2E (devCore global-scope guard reg
             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. */
+     *  a real content-root registry with the bootstrap skill and one baseline bundle,
+     *  plus a local `.git` commit so SG-7 does not hard-fail init on an unreachable
+     *  example.invalid remote (stepCache skips when registryCache.present). 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 });
@@ -88,6 +90,7 @@ describe('copilot provider — isolated home E2E (devCore global-scope guard reg
             name: 'dev-core', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
             dependsOn: [], skills: ['development-process'], workflows: [], agents: [],
         }));
+        (0, commit_seeded_registry_1.commitSeededRegistry)(root);
         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));
     }

package/dist/tests/structural/active-documentation.test.js

@@ -75,12 +75,6 @@ describe('active documentation contract', () => {
             }
         }
     });
-    it('documents the two-stage boundary and official bundle scopes (R3, R8)', () => {
-        expect(read('docs/installation.md')).toContain('Prepare the machine');
-        expect(read('docs/project-setup.md')).toContain('Initialize a project');
-        expect(read('docs/configuration.md')).toContain('`dev` and `product`');
-        expect(read('docs/project-setup.md')).toContain('`frontend`');
-    });
     it('documents every init provider and option (R5, R14.2)', () => {
         const config = read('docs/configuration.md');
         for (const agent of providers_1.AGENT_TARGETS) {
@@ -90,39 +84,4 @@ describe('active documentation contract', () => {
             expect(config).toContain(`\`${flag}\``);
         }
     });
-    it('assigns canonical topics instead of copying provider paths (R12)', () => {
-        expect(read('docs/configuration.md')).toContain('[Support matrix](support-matrix.md)');
-        expect(read('docs/configuration.md')).not.toMatch(/~\/\.(?:claude|codex|cursor|gemini)/);
-    });
-    it('keeps generated provider support prose in the canonical language (R2)', () => {
-        const matrix = read('docs/support-matrix.md');
-        expect(matrix).toContain('### Where each artifact is installed');
-        expect(matrix).toContain('### Agent profiles, workflows, hooks, and context');
-        expect(matrix).not.toContain('Dónde aterriza cada artefacto');
-        expect(matrix).not.toContain('Perfiles de agente, workflows, hooks y contexto');
-    });
-    it('keeps R3 canonical documentation in English and reachable from the hub', () => {
-        const hub = read('docs/README.md');
-        expect(hub).toContain('decisions.md');
-        for (const file of [
-            'docs/framework.md', 'docs/configuration.md', 'docs/project-setup.md',
-            'docs/runbook.md', 'docs/cli-reference.md', 'docs/support-matrix.md',
-            'docs/architecture.md',
-        ]) {
-            expect(read(file)).not.toContain('### Metodología');
-        }
-    });
-    it('keeps provider tiers, registries, and hook targets technically precise (R2)', () => {
-        const matrix = read('docs/support-matrix.md');
-        const runbook = read('docs/runbook.md');
-        const cliReference = read('docs/cli-reference.md');
-        expect(matrix).toContain('Re-anchors process guidance');
-        expect(matrix).toContain('Only `awm sensors run` is an enforceable deterministic gate');
-        expect(runbook).toContain('A registry needs at least one content directory');
-        expect(runbook).toMatch(/`catalog\.json` is required only when the registry\s+publishes bundles/);
-        expect(cliReference).toContain('`claude-code` and `codex`');
-        expect(cliReference).toContain('`--agent` is an alias for `--target`');
-        expect(cliReference).toContain('`dev` and `product` baseline bundles');
-        expect(runbook).toContain('bundles/<bundle-name>/bundle.json');
-    });
 });

package/dist/tests/structural/bundle-skill-reference-contract.test.js

@@ -36,18 +36,6 @@ describe('bundle skill-reference contract', () => {
         expect(skills).toEqual(['mi-proceso']);
         expect(skills.every((skill) => typeof skill === 'string')).toBe(true);
     });
-    it('places the CLI 9 migration boundary immediately after the bundle example', () => {
-        const guide = read(GUIDE);
-        const bundleFence = '```json\n{\n  "name": "mi-proceso"';
-        const start = guide.indexOf(bundleFence);
-        const end = guide.indexOf('```', start) + 3;
-        const following = guide.slice(end, guide.indexOf('## 5.', end));
-        expect(start).toBeGreaterThanOrEqual(0);
-        expect(following).toMatch(/CLI 9[\s\S]*(?:legacy object|objeto legacy)[\s\S]*\{\s*name\s*,\s*onSignal:\s*true\s*\}/i);
-        expect(following).toMatch(/ignor(?:e|a)[\s\S]*boolean[\s\S]*onSignal/i);
-        expect(following).toMatch(/warning/i);
-        expect(following).toMatch(/CLI 10[\s\S]*(?:rejects?|rechaza)[\s\S]*(?:objects?|objetos?)/i);
-    });
     it('keeps every JSON fence in the touched guide parseable', () => {
         for (const json of jsonFences(read(GUIDE))) {
             expect(() => JSON.parse(json)).not.toThrow();

package/dist/tests/structural/cli-reference-matches-commander.test.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../../src/index");
+/**
+ * The CLI reference is what agents read to drive `awm`, so it must never name a
+ * command or a flag the CLI does not have. This is the one documentation check:
+ * it compares the docs against the Commander tree instead of pinning prose, so
+ * rewording a paragraph never breaks it, and a renamed or removed flag always does.
+ */
+const ROOT = path_1.default.resolve(__dirname, '../../..');
+const DOCS = ['docs/cli-reference.md', 'README.md'];
+function tree(command) {
+    const children = new Map();
+    for (const sub of command.commands) {
+        const node = tree(sub);
+        children.set(sub.name(), node);
+        for (const alias of sub.aliases())
+            children.set(alias, node);
+    }
+    return { command, children };
+}
+/** Every `awm ...` invocation inside inline code spans or fenced code blocks. */
+function invocations(markdown) {
+    const code = [];
+    for (const fence of markdown.matchAll(/```[^\n]*\n([\s\S]*?)```/g))
+        code.push(...fence[1].split('\n'));
+    const prose = markdown.replace(/```[^\n]*\n[\s\S]*?```/g, '');
+    for (const span of prose.matchAll(/`([^`\n]+)`/g))
+        code.push(span[1]);
+    const out = [];
+    for (const line of code) {
+        for (const match of line.matchAll(/(?:^|[\s(;&|$])awm\s+([^|;&`#\n]*)/g))
+            out.push(match[1].trim());
+    }
+    return out;
+}
+function longFlags(command) {
+    const flags = new Set(['--help']);
+    for (let c = command; c; c = c.parent) {
+        for (const option of c.options)
+            if (option.long)
+                flags.add(option.long);
+    }
+    return flags;
+}
+function check(root, doc, invocation) {
+    const tokens = invocation.split(/\s+/).filter(Boolean);
+    const first = tokens[0];
+    // `awm <command>`, `awm …`, `awm --version` and similar placeholders name no command.
+    if (!first || /^[<[A-Z-]/.test(first) || first === '...' || first === '…')
+        return [];
+    if (!root.children.has(first))
+        return [{ doc, invocation, problem: `unknown command "${first}"` }];
+    // Options may precede a subcommand (`awm watch --provider x recover-admission`),
+    // so descend on every non-flag token that names a child of the current command.
+    let node = root;
+    const names = [];
+    for (const token of tokens) {
+        if (token.startsWith('-'))
+            continue;
+        const next = node.children.get(token);
+        if (next) {
+            node = next;
+            names.push(token);
+        }
+    }
+    const known = longFlags(node.command);
+    return tokens
+        .flatMap((token) => Array.from(token.matchAll(/(?:^|[[(|])(--[a-z][a-z0-9-]*)/g), (m) => m[1]))
+        .filter((flag) => !known.has(flag))
+        .map((flag) => ({ doc, invocation, problem: `"awm ${names.join(' ')}" has no ${flag}` }));
+}
+describe('documented awm commands and flags exist in the CLI', () => {
+    const root = tree(index_1.program);
+    it.each(DOCS)('%s names only real commands and flags', (doc) => {
+        const markdown = fs_1.default.readFileSync(path_1.default.join(ROOT, doc), 'utf8');
+        const found = invocations(markdown);
+        expect(found.length).toBeGreaterThan(0);
+        const drift = found.flatMap((invocation) => check(root, doc, invocation));
+        expect(drift).toEqual([]);
+    });
+    it('detects drift (self-check against a planted invocation)', () => {
+        expect(check(root, 'planted', 'sensors run --no-such-flag')).toEqual([
+            { doc: 'planted', invocation: 'sensors run --no-such-flag', problem: '"awm sensors run" has no --no-such-flag' },
+        ]);
+        expect(check(root, 'planted', 'no-such-command --x')).toHaveLength(1);
+        expect(check(root, 'planted', 'sensors run --slice --no-cache')).toEqual([]);
+    });
+});

package/dist/tests/structural/native-release-artifacts.test.js

@@ -13,14 +13,23 @@ const REPO_ROOT = path_1.default.resolve(CLI_ROOT, '..');
 function readWorkflow(name) {
     return fs_1.default.readFileSync(path_1.default.join(REPO_ROOT, '.github', 'workflows', name), 'utf8').replace(/\r\n/g, '\n');
 }
-const HOT_IGNORE = String.raw `node_modules|[/\\]cli[/\\]tests[/\\]commands[/\\]watch[/\\]track-(finalize|freeze)\.test\.ts$`;
-const CHANGES_PATTERN = String.raw `[/\\]cli[/\\]tests[/\\](core[/\\]changes|commands[/\\]changes?)[/\\]`;
-const HOT_STEP = 'Test hot Windows ARM suites';
-const CHANGES_STEP = 'Test Change Record Windows ARM suites';
-const CHANGES_RUN = `npx jest --runInBand --bail --testPathPatterns='${CHANGES_PATTERN}'`;
-const REMAINDER_COMMENT = "      # The ARM runner's slow suites run in two separate jobs (watch track-finalize/freeze, and the Change Record suites). Keep runInBand within each job; no test file may run twice or be dropped.\n";
-const HOT_RUN = 'npx jest --runTestsByPath tests/commands/watch/track-finalize.test.ts tests/commands/watch/track-freeze.test.ts --runInBand --bail';
-const RELEASE_GATE = ['test', 'windows-arm-changes', 'windows-arm-hot'];
+// Windows spawns processes about 3x slower than Linux, so its git-heavy suites run as parallel shards
+// (job `windows-shards`, both Windows runners) while the matrix `test` job runs the Windows remainder.
+const SHARDS = [
+    { name: 'watch', pattern: String.raw `[/\\]cli[/\\]tests[/\\]commands[/\\]watch[/\\]` },
+    { name: 'changes-core', pattern: String.raw `[/\\]cli[/\\]tests[/\\]core[/\\]changes[/\\]` },
+    { name: 'changes-commands', pattern: String.raw `[/\\]cli[/\\]tests[/\\]commands[/\\]changes?[/\\]` },
+];
+const SHARD_JOB = 'windows-shards';
+const WINDOWS_RUNNERS = ['windows-2022', 'windows-11-arm'];
+const REMAINDER_IGNORE = ['node_modules', ...SHARDS.map((shard) => shard.pattern)].join('|');
+const SHARD_STEP = 'Test Windows shard';
+const SHARD_RUN = "npx jest --runInBand --bail --testPathPatterns='${{ matrix.shard.pattern }}'";
+const REGULAR_GUARD = "${{ !startsWith(matrix.target, 'win32-') }}";
+const REMAINDER_GUARD = "startsWith(matrix.target, 'win32-')";
+const REMAINDER_COMMENT = '      # On both Windows runners the git-heavy suites run in the windows-shards job (watch, core Change Record, Change Record commands). Keep runInBand within each job; no test file may run twice or be dropped.\n';
+const RELEASE_GATE = ['test', SHARD_JOB];
+const RELEASE_COMMENT = ' # rojo en cualquier plataforma o shard Windows no publica';
 const SHARD_SETUP = [
     { uses: 'actions/checkout@v4' },
     { uses: 'actions/setup-node@v4', with: { 'node-version': '22' } },
@@ -29,7 +38,7 @@ const SHARD_SETUP = [
     { name: 'Build test-only native addon', 'working-directory': 'cli', run: 'npm run native:test-build' },
 ];
 // Jest compiles --testPathPatterns with the `i` flag but --testPathIgnorePatterns
-// without it, so a directory differing only in case would run in both the shard
+// without it, so a directory differing only in case would run in both a shard
 // and the remainder. Returns every directory that falls in that gap.
 function caseOnlyShardPaths(directories, pattern) {
     const insensitive = new RegExp(pattern, 'i');
@@ -39,11 +48,10 @@ function caseOnlyShardPaths(directories, pattern) {
         return insensitive.test(candidate) && !sensitive.test(candidate);
     });
 }
-const SHARD_DIRECTORIES = [['core', 'changes'], ['commands', 'change'], ['commands', 'changes']];
+const SHARD_DIRECTORIES = [['commands', 'watch'], ['core', 'changes'], ['commands', 'change'], ['commands', 'changes']];
 // Each real shard directory must exist with its exact case, hold at least one
-// suite and match CHANGES_PATTERN, so the case-only walk cannot pass vacuously.
+// suite and match exactly one shard, so the case-only walk cannot pass vacuously.
 function shardDirectoryProblems(testsRoot) {
-    const shard = new RegExp(CHANGES_PATTERN);
     const problems = [];
     for (const segments of SHARD_DIRECTORIES) {
         const label = segments.join('/');
@@ -64,8 +72,8 @@ function shardDirectoryProblems(testsRoot) {
         if (!fs_1.default.readdirSync(current).some((entry) => entry.endsWith('.test.ts'))) {
             problems.push(`${label}: holds no *.test.ts`);
         }
-        if (!shard.test(`${current}${path_1.default.sep}`)) {
-            problems.push(`${label}: does not match CHANGES_PATTERN`);
+        if (SHARDS.filter((shard) => new RegExp(shard.pattern).test(`${current}${path_1.default.sep}`)).length !== 1) {
+            problems.push(`${label}: does not match exactly one shard`);
         }
     }
     return problems;
@@ -85,7 +93,7 @@ function keysOf(value) {
     return Object.keys(value);
 }
 // The release job publishes only when every test job passed: no if, no
-// continue-on-error, and needs is exactly the three gating jobs in any order.
+// continue-on-error, and needs is exactly the gating jobs in any order.
 function assertReleaseGate(jobs) {
     const release = getJob(jobs, 'release');
     expect(keysOf(release)).not.toContain('if');
@@ -96,99 +104,103 @@ function assertReleaseGate(jobs) {
     expect(Array.isArray(release.needs)).toBe(true);
     const needs = release.needs;
     expect(needs).toHaveLength(RELEASE_GATE.length);
-    expect([...needs].sort()).toEqual(RELEASE_GATE);
+    expect([...needs].sort()).toEqual([...RELEASE_GATE].sort());
+}
+/** Every *.test.ts under cli/tests, as the absolute path Jest matches, in both separators. */
+function suitePaths() {
+    const testsRoot = path_1.default.join(CLI_ROOT, 'tests');
+    const relative = fs_1.default.readdirSync(testsRoot, { recursive: true }).filter((file) => file.endsWith('.test.ts'));
+    expect(relative.length).toBeGreaterThan(100);
+    return relative.flatMap((file) => {
+        const posix = ['repo', 'cli', 'tests', ...file.split(/[/\\]/)];
+        return [posix.join('/'), posix.join('\\')];
+    });
 }
 // Gate semantics are asserted on the parsed workflow, so key quoting or escaping
 // cannot hide an if or a continue-on-error. Text is checked only where the exact
-// text is the contract: the run lines and the A1 comment.
-function assertArmPartition(source, gatesRelease) {
+// text is the contract: the run lines and the comments.
+function assertWindowsPartition(source, gatesRelease) {
     const workflow = source.replace(/\r\n/g, '\n');
     const jobs = parseJobs(source);
     const names = keysOf(jobs);
     const test = getJob(jobs, 'test');
-    const hot = getJob(jobs, 'windows-arm-hot');
-    const changes = getJob(jobs, 'windows-arm-changes');
-    expect(names.indexOf('windows-arm-hot')).toBeGreaterThan(names.indexOf('test'));
-    expect(names.indexOf('windows-arm-changes')).toBe(names.indexOf('windows-arm-hot') + 1);
+    const shards = getJob(jobs, SHARD_JOB);
+    expect(names.indexOf(SHARD_JOB)).toBe(names.indexOf('test') + 1);
     // No gating job tolerates failure, at job or step level.
-    for (const job of [test, hot, changes]) {
+    for (const job of [test, shards]) {
         expect(keysOf(job)).not.toContain('continue-on-error');
         for (const step of job.steps) {
             expect(keysOf(step)).not.toContain('continue-on-error');
         }
     }
-    // The ARM shards never skip, at job or step level.
-    for (const job of [hot, changes]) {
-        expect(keysOf(job)).not.toContain('if');
-        for (const step of job.steps) {
-            expect(keysOf(step)).not.toContain('if');
-        }
+    // The shards never skip, at job or step level.
+    expect(keysOf(shards)).not.toContain('if');
+    for (const step of shards.steps) {
+        expect(keysOf(step)).not.toContain('if');
     }
     // In the matrix, only the two test steps are guarded, with complementary targets.
     const guarded = test.steps.filter((step) => keysOf(step).includes('if'));
     expect(guarded).toHaveLength(2);
     const [regular, remainder] = guarded;
     expect(regular.name).toMatch(/^Tests?$/);
-    expect(regular.if).toBe("matrix.target != 'win32-arm64'");
+    expect(regular.if).toBe(REGULAR_GUARD);
     expect(regular['working-directory']).toBe('cli');
     expect(regular.run).toBe('npx jest --runInBand --bail');
-    expect(remainder.name).toMatch(/^Tests? \(Windows ARM remainder\)$/);
-    expect(remainder.if).toBe("matrix.target == 'win32-arm64'");
+    expect(remainder.name).toMatch(/^Tests? \(Windows remainder\)$/);
+    expect(remainder.if).toBe(REMAINDER_GUARD);
     expect(remainder['working-directory']).toBe('cli');
     const ignorePattern = String(remainder.run).match(/^npx jest --runInBand --bail --testPathIgnorePatterns='([^']+)'$/)?.[1];
-    expect(ignorePattern).toBe(`${HOT_IGNORE}|${CHANGES_PATTERN}`);
+    expect(ignorePattern).toBe(REMAINDER_IGNORE);
     expect(test.steps.filter((step) => step.uses === 'actions/upload-artifact@v4')).toHaveLength(1);
-    // A1 comment, directly above the remainder step.
+    // The shards run on exactly the Windows runners of the matrix (each Windows target runs every shard).
+    const matrix = test.strategy.matrix.include;
+    const windowsRunners = matrix.filter((entry) => entry.target.startsWith('win32-')).map((entry) => entry.os);
+    const shardStrategy = shards.strategy;
+    expect(shardStrategy['fail-fast']).toBe(false);
+    expect([...shardStrategy.matrix.os].sort()).toEqual([...windowsRunners].sort());
+    expect([...windowsRunners].sort()).toEqual([...WINDOWS_RUNNERS].sort());
+    expect(keysOf(shardStrategy.matrix).sort()).toEqual(['os', 'shard']);
+    expect(shardStrategy.matrix.shard).toEqual(SHARDS);
+    expect(shards['runs-on']).toBe('${{ matrix.os }}');
+    // Comment directly above the remainder step.
     expect(workflow.split(REMAINDER_COMMENT)).toHaveLength(2);
-    const aroundRemainder = workflow.split(/      - name: Tests? \(Windows ARM remainder\)\n/);
+    const aroundRemainder = workflow.split(/      - name: Tests? \(Windows remainder\)\n/);
     expect(aroundRemainder).toHaveLength(2);
     expect(aroundRemainder[0].endsWith(REMAINDER_COMMENT)).toBe(true);
-    // Both shards share the same setup; only their test step differs.
-    expect(hot['runs-on']).toBe('windows-11-arm');
-    expect(hot.steps.slice(0, -1)).toEqual(SHARD_SETUP);
-    expect(hot.steps.at(-1)).toEqual({ name: HOT_STEP, 'working-directory': 'cli', run: HOT_RUN });
-    expect(changes.steps.at(-1)).toEqual({ name: CHANGES_STEP, 'working-directory': 'cli', run: CHANGES_RUN });
-    expect({ ...changes, steps: changes.steps.slice(0, -1) }).toEqual({ ...hot, steps: hot.steps.slice(0, -1) });
+    // The shard job builds like the matrix and only then runs its shard; it never produces an artifact.
+    expect(shards.steps.slice(0, -1)).toEqual(SHARD_SETUP);
+    expect(shards.steps.at(-1)).toEqual({ name: SHARD_STEP, 'working-directory': 'cli', run: SHARD_RUN });
     if (gatesRelease) {
-        expect(changes.permissions).toEqual({ contents: 'read' });
-    }
-    for (const job of [hot, changes]) {
-        expect(job.steps.some((step) => String(step.uses ?? '').includes('upload-artifact'))).toBe(false);
-        expect(JSON.stringify(job)).not.toContain('secure-fs-win32-arm64');
+        expect(shards.permissions).toEqual({ contents: 'read' });
     }
-    const lines = workflow.split('\n');
-    expect(lines).toContain(`        run: ${HOT_RUN}`);
-    expect(lines).toContain(`        run: ${CHANGES_RUN}`);
-    // The remainder ignores exactly the hot suites plus what the Change Record shard runs.
+    expect(shards.steps.some((step) => String(step.uses ?? '').includes('upload-artifact'))).toBe(false);
+    expect(JSON.stringify(shards)).not.toContain('secure-fs-win32');
+    expect(workflow.split('\n')).toContain(`        run: ${SHARD_RUN}`);
+    // The partition, checked on every real suite: on Windows each file runs in exactly one place.
     const ignored = new RegExp(ignorePattern);
+    const selectors = shardStrategy.matrix.shard.map((shard) => new RegExp(shard.pattern, 'i'));
+    const misplaced = suitePaths().filter((file) => {
+        const places = selectors.filter((selector) => selector.test(file)).length + (ignored.test(file) ? 0 : 1);
+        return places !== 1;
+    });
+    expect(misplaced).toEqual([]);
     for (const separator of ['/', '\\']) {
         const root = ['repo', 'cli', 'tests'].join(separator);
-        for (const suite of ['track-finalize', 'track-freeze']) {
-            expect(ignored.test([root, 'commands', 'watch', `${suite}.test.ts`].join(separator))).toBe(true);
-            expect(ignored.test([root, 'other', `${suite}.test.ts`].join(separator))).toBe(false);
-        }
-    }
-    const shardPattern = String(changes.steps.at(-1)?.run).match(/--testPathPatterns='([^']+)'$/)?.[1];
-    expect(shardPattern).toBe(CHANGES_PATTERN);
-    expect(ignorePattern).toBe(`${HOT_IGNORE}|${shardPattern}`);
-    const shard = new RegExp(shardPattern, 'i');
-    for (const separator of ['/', '\\']) {
-        const root = ['repo', 'cli', 'tests'].join(separator);
-        for (const file of [['core', 'changes', 'x.test.ts'], ['commands', 'change', 'new.test.ts'], ['commands', 'changes', 'list.test.ts']]) {
+        for (const file of [['commands', 'watch', 'track-finalize.test.ts'], ['core', 'changes', 'x.test.ts'], ['commands', 'change', 'new.test.ts'], ['commands', 'changes', 'list.test.ts']]) {
             const candidate = [root, ...file].join(separator);
-            expect(shard.test(candidate)).toBe(true);
+            expect(selectors.filter((selector) => selector.test(candidate))).toHaveLength(1);
             expect(ignored.test(candidate)).toBe(true);
         }
-        for (const file of [['core', 'changesets', 'x.test.ts'], ['commands', 'changesets', 'x.test.ts'], ['commands', 'watch', 'track-finalize.test.ts']]) {
-            expect(shard.test([root, ...file].join(separator))).toBe(false);
+        for (const file of [['core', 'changesets', 'x.test.ts'], ['commands', 'changesets', 'x.test.ts'], ['commands', 'watcher', 'x.test.ts'], ['core', 'watch', 'x.test.ts']]) {
+            const candidate = [root, ...file].join(separator);
+            expect(selectors.some((selector) => selector.test(candidate))).toBe(false);
+            expect(ignored.test(candidate)).toBe(false);
         }
-        expect(ignored.test([root, 'core', 'changesets', 'x.test.ts'].join(separator))).toBe(false);
     }
     if (gatesRelease) {
         assertReleaseGate(jobs);
-        // CI-2 keeps the comment on the release job's needs line.
         const releaseText = workflow.slice(workflow.search(/^  release:\n/m));
-        expect(releaseText.match(/^    needs: [^\n]*$/m)?.[0]).toMatch(/ # rojo en cualquier plataforma o shard ARM no publica$/);
+        expect(releaseText.match(/^    needs: [^\n]*$/m)?.[0]).toMatch(new RegExp(`${RELEASE_COMMENT}$`));
     }
     else {
         expect(names).not.toContain('release');
@@ -207,60 +219,55 @@ function permutations(items) {
         return [items];
     return items.flatMap((item, index) => permutations([...items.slice(0, index), ...items.slice(index + 1)]).map((rest) => [item, ...rest]));
 }
-// Every bypass of the partition or the release gate must make assertArmPartition
+// Every bypass of the partition or the release gate must make assertWindowsPartition
 // throw: a failed assertion or a mutated text that no longer parses as YAML.
 function assertMutationsRejected(workflow, gates) {
     const jobLevel = (job, line) => workflow.replace(new RegExp(`^  ${job}:\\n`, 'm'), `  ${job}:\n    ${line}\n`);
     const inStep = (step, line) => workflow.replace(`      - name: ${step}\n`, `      - name: ${step}\n        ${line}\n`);
     const mutations = [
         // Swapped matrix guards.
-        workflow.replace(/if: matrix\.target (?:!=|==) 'win32-arm64'/g, (guard) => guard.includes('!=') ? "if: matrix.target == 'win32-arm64'" : "if: matrix.target != 'win32-arm64'"),
+        workflow.replace(REGULAR_GUARD, 'PLACEHOLDER').replace(`if: ${REMAINDER_GUARD}`, `if: ${REGULAR_GUARD}`).replace('PLACEHOLDER', REMAINDER_GUARD),
         // A second producer of the native artifact.
         workflow.replace('uses: actions/upload-artifact@v4', 'uses: actions/upload-artifact@v4\n      - uses: actions/upload-artifact@v4'),
         // A remainder that drops more than the shards run.
         workflow.replace(/(--testPathIgnorePatterns='[^']+)(?=')/, '$1|runner\\.test\\.ts$'),
-        // A shard pattern that differs from the remainder's exclusion.
-        workflow.replace(/(--testPathPatterns='[^']+)changes\?/, '$1changes'),
-        // Masked shard runs.
-        workflow.replace(/(run: npx jest --runTestsByPath [^\n]+ --runInBand --bail)(?=\n)/, '$1; exit 0'),
+        // A shard pattern that drifts from the remainder's exclusion.
+        workflow.replace(/(pattern: '[^']+commands\[\/\\\\\]changes)\?/, '$1'),
+        // A dropped shard, and a dropped Windows runner.
+        workflow.replace(/          - name: changes-core\n            pattern: '[^']+'\n/, ''),
+        workflow.replace('os: [windows-2022, windows-11-arm]', 'os: [windows-11-arm]'),
+        // Fail-fast would cancel sibling shards and hide their results.
+        workflow.replace(/(  windows-shards:\n    strategy:\n      fail-fast: )false/, '$1true'),
+        // Masked shard run.
         workflow.replace(/(run: npx jest --runInBand --bail --testPathPatterns='[^']+')(?=\n)/, '$1; exit 0'),
         // Skipped steps or jobs, in any key quoting.
-        inStep(HOT_STEP, 'if: false'),
-        inStep(HOT_STEP, '"if": always()'),
-        inStep(HOT_STEP, "'if': false"),
-        inStep(CHANGES_STEP, 'if: false'),
-        inStep(CHANGES_STEP, '"if": always()'),
-        inStep(CHANGES_STEP, "'if': false"),
+        inStep(SHARD_STEP, 'if: false'),
+        inStep(SHARD_STEP, '"if": always()'),
+        inStep(SHARD_STEP, "'if': false"),
         inStep('Upload native secure-fs artifact', "'if': false"),
-        jobLevel('windows-arm-hot', '"if": always()'),
-        jobLevel('windows-arm-hot', "'if': false"),
-        jobLevel('windows-arm-changes', '"if": always()'),
-        jobLevel('windows-arm-changes', "'if': false"),
+        jobLevel(SHARD_JOB, '"if": always()'),
+        jobLevel(SHARD_JOB, "'if': false"),
         // Tolerated failures, in any key quoting, escaping or expression form.
-        jobLevel('test', "continue-on-error: ${{ matrix.target == 'win32-arm64' }}"),
+        jobLevel('test', "continue-on-error: ${{ startsWith(matrix.target, 'win32-') }}"),
         jobLevel('test', '"continue-on-error": true'),
         jobLevel('test', '"continue\\x2Don-error": true'),
-        jobLevel('windows-arm-hot', 'continue-on-error: true'),
-        jobLevel('windows-arm-hot', 'continue-on-error: ${{ true }}'),
-        jobLevel('windows-arm-hot', '"continue-on-error": true'),
-        jobLevel('windows-arm-changes', 'continue-on-error: true'),
-        jobLevel('windows-arm-changes', 'continue-on-error: ${{ true }}'),
-        jobLevel('windows-arm-changes', '"continue-on-error": true'),
-        inStep(HOT_STEP, '"continue-on-error": true'),
-        inStep(CHANGES_STEP, "'continue-on-error': true"),
+        jobLevel(SHARD_JOB, 'continue-on-error: true'),
+        jobLevel(SHARD_JOB, 'continue-on-error: ${{ true }}'),
+        jobLevel(SHARD_JOB, '"continue-on-error": true'),
+        inStep(SHARD_STEP, '"continue-on-error": true'),
         workflow.replace(/^(        run: npx jest --runInBand --bail\n)/m, '$1        continue-on-error: true\n'),
         workflow.replace(/(run: npx jest --runInBand --bail --testPathIgnorePatterns='[^']+'\n)/, '$1        continue-on-error: true\n'),
         workflow.replace(/(run: npx jest --runInBand --bail --testPathIgnorePatterns='[^']+'\n)/, '$1        continue-on-error: ${{ true }}\n'),
     ];
     if (gates) {
-        mutations.push(rewriteReleaseNeeds(workflow, (jobs) => jobs.filter((job) => job !== 'windows-arm-changes')), rewriteReleaseNeeds(workflow, (jobs) => [...jobs, 'windows-arm-changes']), jobLevel('release', 'if: always()'), jobLevel('release', 'if: ${{ !cancelled() }}'), jobLevel('release', '"if": always()'), jobLevel('release', "'if': false"), jobLevel('release', 'continue-on-error: true'), jobLevel('release', '"continue-on-error": true'), 
+        mutations.push(rewriteReleaseNeeds(workflow, (jobs) => jobs.filter((job) => job !== SHARD_JOB)), rewriteReleaseNeeds(workflow, (jobs) => [...jobs, SHARD_JOB]), jobLevel('release', 'if: always()'), jobLevel('release', 'if: ${{ !cancelled() }}'), jobLevel('release', '"if": always()'), jobLevel('release', "'if': false"), jobLevel('release', 'continue-on-error: true'), jobLevel('release', '"continue-on-error": true'), 
         // The needs comment is part of CI-2.
         workflow.slice(0, workflow.search(/^  release:\n/m))
-            + workflow.slice(workflow.search(/^  release:\n/m)).replace(/^(    needs: [^\n]*?) # rojo en cualquier plataforma o shard ARM no publica$/m, '$1'));
+            + workflow.slice(workflow.search(/^  release:\n/m)).replace(new RegExp(`^(    needs: [^\\n]*?)${RELEASE_COMMENT}$`, 'm'), '$1'));
     }
     for (const mutated of mutations) {
         expect(mutated).not.toBe(workflow);
-        expect(() => assertArmPartition(mutated, gates)).toThrow();
+        expect(() => assertWindowsPartition(mutated, gates)).toThrow();
     }
 }
 describe('native release artifacts', () => {
@@ -278,19 +285,19 @@ describe('native release artifacts', () => {
         }
         expect(release).toContain('cancel-in-progress: false');
     });
-    it('partitions the hot and Change Record ARM shards without duplicating the native artifact', () => {
+    it('partitions the Windows shards and remainder without duplicating the native artifact', () => {
         for (const name of ['ci.yml', 'release.yml']) {
             const workflow = readWorkflow(name);
-            assertArmPartition(workflow, name === 'release.yml');
+            assertWindowsPartition(workflow, name === 'release.yml');
         }
     });
     it('checks the same partition after a Windows CRLF checkout', () => {
         for (const name of ['ci.yml', 'release.yml']) {
             const workflow = readWorkflow(name);
-            assertArmPartition(workflow.replace(/\n/g, '\r\n'), name === 'release.yml');
+            assertWindowsPartition(workflow.replace(/\n/g, '\r\n'), name === 'release.yml');
         }
     });
-    it('rejects swapped matrix guards, non-gating ARM shards, drifted partitions and duplicate artifacts', () => {
+    it('rejects swapped matrix guards, non-gating Windows shards, drifted partitions and duplicate artifacts', () => {
         for (const name of ['ci.yml', 'release.yml']) {
             assertMutationsRejected(readWorkflow(name), name === 'release.yml');
         }
@@ -303,11 +310,11 @@ describe('native release artifacts', () => {
         expect(reorderedJobs).toBeDefined();
         const reordered = rewriteReleaseNeeds(workflow, () => reorderedJobs);
         expect(reordered).not.toBe(workflow);
-        expect(() => assertArmPartition(reordered, true)).not.toThrow();
+        expect(() => assertWindowsPartition(reordered, true)).not.toThrow();
         expect(() => assertMutationsRejected(reordered, true)).not.toThrow();
     });
     it('reports a shard directory that is missing, renamed by case or holds no suite', () => {
-        const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-arm-shard-'));
+        const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-windows-shard-'));
         try {
             const testsRoot = path_1.default.join(tmp, 'cli', 'tests');
             for (const segments of SHARD_DIRECTORIES) {
@@ -328,9 +335,11 @@ describe('native release artifacts', () => {
         }
     });
     it('flags test directories that only the case-insensitive shard pattern selects', () => {
-        expect(caseOnlyShardPaths(['repo/cli/tests/core/Changes'], CHANGES_PATTERN)).toEqual(['repo/cli/tests/core/Changes']);
-        expect(caseOnlyShardPaths(['repo\\cli\\tests\\commands\\CHANGE'], CHANGES_PATTERN)).toEqual(['repo\\cli\\tests\\commands\\CHANGE']);
-        expect(caseOnlyShardPaths(['repo/cli/tests/core/changes', 'repo/cli/tests/commands/change', 'repo/cli/tests/core/Changesets'], CHANGES_PATTERN)).toEqual([]);
+        const [watch, core, commands] = SHARDS.map((shard) => shard.pattern);
+        expect(caseOnlyShardPaths(['repo/cli/tests/core/Changes'], core)).toEqual(['repo/cli/tests/core/Changes']);
+        expect(caseOnlyShardPaths(['repo\\cli\\tests\\commands\\CHANGE'], commands)).toEqual(['repo\\cli\\tests\\commands\\CHANGE']);
+        expect(caseOnlyShardPaths(['repo/cli/tests/commands/Watch'], watch)).toEqual(['repo/cli/tests/commands/Watch']);
+        expect(caseOnlyShardPaths(['repo/cli/tests/core/changes', 'repo/cli/tests/commands/change', 'repo/cli/tests/commands/watch', 'repo/cli/tests/core/Changesets'], core)).toEqual([]);
     });
     it('has no test directory selected by the shard but kept by the remainder through case alone', () => {
         const testsRoot = path_1.default.join(CLI_ROOT, 'tests');
@@ -338,9 +347,9 @@ describe('native release artifacts', () => {
             .map((relative) => path_1.default.join(testsRoot, relative))
             .filter((candidate) => fs_1.default.statSync(candidate).isDirectory());
         expect(shardDirectoryProblems(testsRoot)).toEqual([]);
-        const flagged = caseOnlyShardPaths(directories, CHANGES_PATTERN);
+        const flagged = SHARDS.flatMap((shard) => caseOnlyShardPaths(directories, shard.pattern));
         if (flagged.length > 0) {
-            throw new Error(`Case-only Change Record directories would run in both ARM shards: ${flagged.join(', ')}`);
+            throw new Error(`Case-only directories would run in both a Windows shard and the remainder: ${flagged.join(', ')}`);
         }
     });
     it('keeps native prebuilds generated instead of versioned source', () => {