agentic-workflow-manager 9.6.1 → 9.7.1

package/dist/src/core/tracks/git.js

@@ -136,13 +136,25 @@ function ownedWorktreeExists(repo, worktreePath, branch) {
  *  worktree (contenido de filesystem que SÍ podría ser ajeno), una branch es
  *  solo un ref; nada más crea una con ese nombre exacto. */
 function branchExists(repo, branch) {
+    // `show-ref --quiet` puede devolver 1 tanto para una ref ausente como
+    // para un repositorio que ni siquiera pudo abrirse. Primero probamos que
+    // git puede identificar el repositorio; solo después status 1 significa
+    // honestamente "la branch no existe".
+    try {
+        git(repo, ['rev-parse', '--git-dir']);
+    }
+    catch (error) {
+        throw new Error(`branchExists: repo de ${branch} indemostrable: ${error.message}`);
+    }
     try {
         git(repo, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
-        return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        if (error.status === 1)
+            return false;
+        throw new Error(`branchExists: existencia de ${branch} indemostrable: ${error.message}`);
     }
+    return true;
 }
 /** Task 9 (paso BRANCH_REMOVED, Task 13 endurece el guard — R4.10/C9): borra
  *  la branch local determinista de un track SOLO después de que su worktree

package/dist/src/core/tracks/protocol.js

@@ -269,7 +269,25 @@ function nextProtocolEffect(s) {
 }
 function reconcileProtocol(s, observation) {
     const out = structuredClone(s);
-    if (observation.kind === 'prepare-failed') {
+    if (observation.kind === 'teardown-requested') {
+        const requested = out.tracks[observation.trackId];
+        if (requested === undefined)
+            throw new Error(`track desconocido: ${observation.trackId}`);
+        if (out.cohortPhase !== 'BLOCKED' && out.cohortPhase !== 'SERIAL' && out.cohortPhase !== 'COMPLETE'
+            && out.cohortPhase !== 'FALLBACK_PENDING') {
+            out.cohortPhase = 'FALLBACK_PENDING';
+            out.fallbackReason = `controller-requested:${observation.trackId}`;
+            // La evidencia de QA/integración describe la ruta de finalización
+            // que acabamos de abandonar. Debe desaparecer ANTES de mover los
+            // tracks a teardown: de otro modo el invariante de integración
+            // final ve evidence viva junto a tracks no mergeados y rechaza la
+            // transición segura hacia fallback.
+            out.globalQaHeadSha = undefined;
+            out.finalIntegrationJobId = undefined;
+            markTeardownRequested(out.tracks);
+        }
+    }
+    else if (observation.kind === 'prepare-failed') {
         out.cohortPhase = 'FALLBACK_PENDING';
         out.fallbackReason = `prepare-failed:${observation.trackId}`;
         markTeardownRequested(out.tracks);
@@ -295,10 +313,11 @@ function reconcileProtocol(s, observation) {
             // `decideTeardown` documenta para BLOCKED: solo el operador lo
             // saca de acá.
             const t = out.tracks[observation.trackId];
-            if (t !== undefined) {
-                t.phase = 'BLOCKED';
-                t.blockedReason = observation.detail;
-            }
+            if (t === undefined)
+                throw new Error(`track desconocido: ${observation.trackId}`);
+            t.phase = 'BLOCKED';
+            t.blockedReason = observation.detail;
+            out.cohortPhase = 'BLOCKED';
         }
         // effect-failed fuera de PREPARING/begin-teardown: sin transición definida todavía (no ejercitado por T1).
     }
@@ -351,6 +370,7 @@ function reconcileProtocol(s, observation) {
         if (decision === 'block-foreign') {
             t.phase = 'BLOCKED';
             t.blockedReason = observation.foreignSupervisor ? 'identidad de supervisor ajena' : 'worktree preexistente ajeno';
+            out.cohortPhase = 'BLOCKED';
         }
         else if (decision === 'accept-supervisor-stopped') {
             t.phase = 'SUPERVISOR_STOPPED';
@@ -432,7 +452,7 @@ function reconcileProtocol(s, observation) {
 }
 function observeProtocolEffect(s, effect, observation) {
     if (observation.kind === 'effect-failed' || observation.kind === 'prepare-failed' || observation.kind === 'join-observation'
-        || observation.kind === 'freeze-observation' || observation.kind === 'join-requested'
+        || observation.kind === 'freeze-observation' || observation.kind === 'join-requested' || observation.kind === 'teardown-requested'
         || observation.kind === 'supervisor-observed' || observation.kind === 'worktree-observed'
         || observation.kind === 'teardown-observation'
         || observation.kind === 'global-qa-pass'

package/dist/src/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = void 0;
 const prompts_1 = require("@clack/prompts");
 const commander_1 = require("commander");
 const config_1 = require("./utils/config");
@@ -51,9 +52,9 @@ const update_1 = require("./commands/update");
 const agent_targets_1 = require("./core/agent-targets");
 const update_check_1 = require("./core/update-check");
 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)());
-program.hook('postAction', (_command, actionCommand) => {
+exports.program = new commander_1.Command();
+exports.program.name('awm').description('Agentic Workflow Manager').version((0, cli_version_1.cliVersion)());
+exports.program.hook('postAction', (_command, actionCommand) => {
     if (actionCommand.name() === 'preflight')
         return;
     if (actionCommand.parent?.name() === 'plan' && actionCommand.name() === 'validate' && actionCommand.opts().json === true)
@@ -108,7 +109,7 @@ function resolveSelectedArtifacts(selections) {
 // --type skill` como el camino scripteado — una invocacion que siempre fallo con
 // «Bundle "<skill>" not found». Los playbooks se escribieron contra la documentacion, no
 // contra el comportamiento. Un flag que no se lee es peor que uno ausente: promete.
-program.command('add [name]')
+exports.program.command('add [name]')
     .description('Add a bundle (package of skills) interactively, or non-interactively with flags')
     .option('-a, --agent <agent>', `Target agent: ${providers_1.AGENT_TARGETS.join(', ')}`)
     .option('-s, --scope <scope>', 'Scope: local or global')
@@ -117,6 +118,7 @@ program.command('add [name]')
     .option('--all', 'install all artifacts from all packages without prompting')
     .action(async (name, options) => {
     (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Agentic Workflow Manager ')));
+    const reporter = (0, bundles_1.createBundleDiagnosticReporter)((message) => process.stderr.write(`${message}\n`));
     // 1. Sync the registry
     const s = (0, prompts_1.spinner)();
     s.start('Syncing registries...');
@@ -137,7 +139,7 @@ program.command('add [name]')
     }
     // 1b. If `name` matches a bundle, run the bundle-activation flow and exit.
     if (name) {
-        const allBundles = (0, bundles_1.discoverAllBundles)();
+        const allBundles = (0, bundles_1.discoverAllBundles)(undefined, reporter);
         const prefs = (0, config_1.getPreferences)();
         const outcome = (0, add_1.runAddBundleCore)({ name, agent: options.agent, scope: options.scope, method: options.method }, prefs, allBundles);
         if (outcome.code !== 0)
@@ -181,7 +183,7 @@ program.command('add [name]')
         }
         const includeWorkflows = targetAgents.some((a) => (0, providers_1.providerFor)(a).workflow !== null);
         const includeAgents = targetAgents.some((a) => (0, providers_1.providerFor)(a).agent !== null);
-        const allView = (0, registry_view_1.buildPackageView)(skills, includeWorkflows ? workflows : [], includeAgents ? agents : [], (0, bundles_1.discoverAllBundles)());
+        const allView = (0, registry_view_1.buildPackageView)(skills, includeWorkflows ? workflows : [], includeAgents ? agents : [], (0, bundles_1.discoverAllBundles)(undefined, reporter));
         const allDedup = new Map();
         for (const pkg of allView) {
             for (const a of pkg.artifacts) {
@@ -294,7 +296,7 @@ program.command('add [name]')
     // 4. Build the package view, filtered to artifact types the target agent(s) support
     const includeWorkflows = targetAgents.some(a => (0, providers_1.providerFor)(a).workflow !== null);
     const includeAgents = targetAgents.some(a => (0, providers_1.providerFor)(a).agent !== null);
-    const view = (0, registry_view_1.buildPackageView)(skills, includeWorkflows ? workflows : [], includeAgents ? agents : [], (0, bundles_1.discoverAllBundles)());
+    const view = (0, registry_view_1.buildPackageView)(skills, includeWorkflows ? workflows : [], includeAgents ? agents : [], (0, bundles_1.discoverAllBundles)(undefined, reporter));
     if (view.length === 0) {
         (0, prompts_1.outro)(picocolors_1.default.yellow('No artifacts available for the selected agent(s).'));
         process.exit(0);
@@ -417,7 +419,7 @@ program.command('add [name]')
         process.exit(1);
     }
 });
-program.command('update')
+exports.program.command('update')
     .description('Sync all configured registries, reconcile artifacts and re-sync hooks')
     .option('-a, --agent <agent>', `Target agent(s), comma-separated: ${providers_1.AGENT_TARGETS.join(', ')} (defaults to every enabled agent)`)
     .option('-y, --yes', 'Non-interactive: never prompt, and self-update the CLI without asking')
@@ -431,7 +433,7 @@ program.command('update')
     (0, prompts_1.outro)(result.code === 0 ? message : picocolors_1.default.red(message));
     process.exitCode = result.code;
 });
-program.command('sync')
+exports.program.command('sync')
     .description('Rebuild local skill symlinks from .awm/profile.json (e.g. after cloning on a new machine)')
     .option('-a, --agent <agent>', `Target agent(s), comma-separated: ${providers_1.AGENT_TARGETS.join(', ')} (defaults to every enabled agent)`)
     .option('-m, --method <method>', 'Install method: symlink or copy', 'symlink')
@@ -441,11 +443,12 @@ program.command('sync')
     (0, prompts_1.outro)(code === 0 ? 'Done.' : picocolors_1.default.red('Sync failed — see errors above.'));
     process.exitCode = code;
 });
-program.command('list [package]')
+exports.program.command('list [package]')
     .description('List available artifacts. With no argument shows a package summary; pass a package name or --all for detail.')
     .option('-a, --all', 'Expand every package')
     .action(async (packageName, options) => {
     (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Registry Listing ')));
+    const reporter = (0, bundles_1.createBundleDiagnosticReporter)((message) => process.stderr.write(`${message}\n`));
     const s = (0, prompts_1.spinner)();
     s.start('Syncing registries...');
     const listSyncResults = await (0, registries_1.syncRegistries)();
@@ -462,7 +465,7 @@ program.command('list [package]')
         process.exitCode = 1;
         return;
     }
-    const fullView = (0, registry_view_1.buildPackageView)((0, discovery_1.discoverSkills)(), (0, discovery_1.discoverWorkflows)(), (0, discovery_1.discoverAgents)(), (0, bundles_1.discoverAllBundles)());
+    const fullView = (0, registry_view_1.buildPackageView)((0, discovery_1.discoverSkills)(), (0, discovery_1.discoverWorkflows)(), (0, discovery_1.discoverAgents)(), (0, bundles_1.discoverAllBundles)(undefined, reporter));
     const view = options.all ? fullView : fullView.filter((p) => p.visibility !== 'private');
     if (view.length === 0) {
         (0, prompts_1.outro)(picocolors_1.default.yellow('No artifacts found in the registry. Run `awm update` or check your registry content.'));
@@ -516,13 +519,14 @@ program.command('list [package]')
 // prometia y no contra el comportamiento. Ver docs/decisions.md, D-006.
 //
 // El nombre es de BUNDLE, igual que en `add` (D-001).
-program.command('remove [name]')
+exports.program.command('remove [name]')
     .description('Remove an installed bundle interactively, or non-interactively with flags')
     .option('-a, --agent <agent>', `Target agent(s), comma-separated: ${providers_1.AGENT_TARGETS.join(', ')} (defaults to every enabled agent)`)
     .option('-s, --scope <scope>', 'Scope: local or global (skips the prompt)')
     .option('-y, --yes', 'Skip the confirmation prompt (requires a name)')
     .action(async (name, options) => {
     (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Remove Artifact ')));
+    const reporter = (0, bundles_1.createBundleDiagnosticReporter)((message) => process.stderr.write(`${message}\n`));
     const prefs = (0, config_1.getPreferences)();
     // `--yes` sin nombre borraria lo que el usuario nunca eligio: un `rm -rf` silencioso
     // sobre todo lo instalado. Se rechaza antes de tocar nada.
@@ -591,7 +595,8 @@ program.command('remove [name]')
         (0, prompts_1.outro)(picocolors_1.default.yellow('No installed artifacts found for the selected agents/scope.'));
         process.exit(0);
     }
-    const groupedOpts = (0, grouping_1.buildGroupedOptions)(installed, (0, bundles_1.discoverAllBundles)(), (c) => {
+    const bundles = (0, bundles_1.discoverAllBundles)(undefined, reporter);
+    const groupedOpts = (0, grouping_1.buildGroupedOptions)(installed, bundles, (c) => {
         const hasSkill = c.artifacts.some(a => a.type === 'skill');
         const hasWf = c.artifacts.some(a => a.type === 'workflow');
         const hasAgent = c.artifacts.some(a => a.type === 'agent');
@@ -608,14 +613,14 @@ program.command('remove [name]')
         // Los artefactos del bundle pedido que estan REALMENTE instalados en este
         // scope. Se cruza contra `installed`: lo que no esta instalado no se puede
         // remover, y decirlo es mejor que borrar un subconjunto en silencio.
-        const bundle = (0, bundles_1.discoverAllBundles)().find((b) => b.name === name);
+        const bundle = bundles.find((b) => b.name === name);
         if (!bundle) {
             console.error(picocolors_1.default.red(`Bundle "${name}" not found in registry.`));
             console.error(picocolors_1.default.dim('Run `awm list` to see available packages.'));
             process.exit(1);
         }
         const owned = new Set([
-            ...bundle.skills.map((sk) => sk.name),
+            ...bundle.skills,
             ...bundle.workflows,
             ...bundle.agents,
         ]);
@@ -677,7 +682,7 @@ function loadEnvFile(cwd) {
     }
     return env;
 }
-const miroCmd = program.command('miro').description('Miro board integration');
+const miroCmd = exports.program.command('miro').description('Miro board integration');
 miroCmd.command('sync <storyMapPath>')
     .description('Sync a story-map.md file to a Miro board frame')
     .action(async (storyMapPath) => {
@@ -726,29 +731,31 @@ miroCmd.command('sync <storyMapPath>')
         process.exit(1);
     }
 });
-(0, hooks_1.registerHooksCommand)(program);
-(0, sensors_1.registerSensorsCommand)(program);
-(0, ledger_1.registerLedgerCommand)(program);
-(0, context_budget_1.registerContextBudgetCommand)(program);
-(0, preflight_1.registerPreflightCommand)(program);
-(0, plan_1.registerPlanCommand)(program);
-(0, doctor_1.registerDoctorCommand)(program);
-(0, backup_1.registerBackupCommand)(program);
-(0, init_1.registerInitCommand)(program);
-(0, registry_1.registerRegistryCommand)(program);
-(0, pin_1.registerPinCommands)(program);
-(0, export_1.registerExportCommand)(program);
-(0, agent_1.registerAgentCommand)(program);
-(0, job_1.registerJobCommand)(program);
-(0, watch_1.registerWatchCommand)(program);
-(0, track_1.registerTrackCommand)(program);
-(0, evidence_1.registerEvidenceCommand)(program);
-(0, process_1.registerProcessCommand)(program);
-(0, context_1.registerContextCommand)(program);
+(0, hooks_1.registerHooksCommand)(exports.program);
+(0, sensors_1.registerSensorsCommand)(exports.program);
+(0, ledger_1.registerLedgerCommand)(exports.program);
+(0, context_budget_1.registerContextBudgetCommand)(exports.program);
+(0, preflight_1.registerPreflightCommand)(exports.program);
+(0, plan_1.registerPlanCommand)(exports.program);
+(0, doctor_1.registerDoctorCommand)(exports.program);
+(0, backup_1.registerBackupCommand)(exports.program);
+(0, init_1.registerInitCommand)(exports.program);
+(0, registry_1.registerRegistryCommand)(exports.program);
+(0, pin_1.registerPinCommands)(exports.program);
+(0, export_1.registerExportCommand)(exports.program);
+(0, agent_1.registerAgentCommand)(exports.program);
+(0, job_1.registerJobCommand)(exports.program);
+(0, watch_1.registerWatchCommand)(exports.program);
+(0, track_1.registerTrackCommand)(exports.program);
+(0, evidence_1.registerEvidenceCommand)(exports.program);
+(0, process_1.registerProcessCommand)(exports.program);
+(0, context_1.registerContextCommand)(exports.program);
 // Commander only waits for async action handlers through parseAsync().  The CLI has
 // async commands (including `sensors coverage`), so returning its promise keeps the
 // process alive until their JSON/output contract has been completed.
-program.parseAsync().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
-});
+if (require.main === module) {
+    exports.program.parseAsync().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/src/utils/grouping.js

@@ -8,7 +8,7 @@ function buildGroupedOptions(artifacts, bundles, formatLabel) {
         let foundParent = false;
         const baseName = (a.type === 'workflow' || a.type === 'agent') ? a.name.replace(/\.md$/, '') : a.name;
         for (const p of bundles) {
-            const skillNames = p.skills.map((s) => s.name);
+            const skillNames = p.skills;
             if ((a.type === 'skill' && skillNames.includes(baseName)) ||
                 (a.type === 'workflow' && p.workflows.includes(baseName)) ||
                 (a.type === 'agent' && p.agents.includes(baseName))) {

package/dist/src/utils/registry-view.js

@@ -40,7 +40,7 @@ function buildPackageView(skills, workflows, agents, bundles) {
     const packages = [];
     const claimed = new Set();
     for (const b of bundles) {
-        const skillNames = b.skills.map((s) => s.name);
+        const skillNames = b.skills;
         const arts = all.filter((a) => (a.type === 'skill' && skillNames.includes(a.name)) ||
             (a.type === 'workflow' && b.workflows.includes(a.name)) ||
             (a.type === 'agent' && b.agents.includes(a.name)));

package/dist/tests/commands/bundle-diagnostics.test.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+jest.mock('@clack/prompts', () => ({
+    intro: jest.fn(), outro: jest.fn(), spinner: () => ({ start: jest.fn(), stop: jest.fn() }),
+    select: jest.fn(), multiselect: jest.fn(), confirm: jest.fn(), isCancel: jest.fn(() => false),
+}));
+function writeManifest(root, legacy) {
+    fs_1.default.mkdirSync(path_1.default.join(root, 'bundles', 'demo'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'demo-skill'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({ version: 1, bundles: [{ name: 'demo', source: './bundles/demo', version: '1.0.0', scope: 'baseline' }] }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'bundles', 'demo', 'bundle.json'), JSON.stringify({
+        name: 'demo', description: 'Diagnostic fixture', version: '1.0.0', scope: 'baseline', dependsOn: [],
+        skills: legacy ? [{ name: 'demo-skill', onSignal: true }] : ['demo-skill'], workflows: [], agents: [],
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'demo-skill', 'SKILL.md'), '---\nname: demo-skill\nportable: true\ndescription: fixture\n---\n');
+}
+function git(cwd, args) {
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=test@example.test', '-c', 'user.name=Test', ...args], { cwd, stdio: 'pipe' });
+}
+describe('S2 bundle compatibility diagnostic command routes', () => {
+    let home;
+    let work;
+    let priorHome;
+    let priorAwmHome;
+    let stdout;
+    beforeEach(() => {
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bundle-command-home-'));
+        work = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bundle-command-work-'));
+        priorHome = process.env.HOME;
+        priorAwmHome = process.env.AWM_HOME;
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+        stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        jest.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`unexpected process.exit(${code ?? 0})`);
+        }));
+        jest.spyOn(console, 'log').mockImplementation(() => undefined);
+        jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+        jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        jest.resetModules();
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+        fs_1.default.rmSync(work, { recursive: true, force: true });
+        if (priorHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = priorHome;
+        if (priorAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = priorAwmHome;
+    });
+    function configureRegistry(legacy) {
+        fs_1.default.rmSync(path_1.default.join(process.env.AWM_HOME, 'registries'), { recursive: true, force: true });
+        const root = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');
+        writeManifest(root, legacy);
+        fs_1.default.mkdirSync(process.env.AWM_HOME, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: root }]));
+        fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'preferences.json'), JSON.stringify({
+            defaultAgent: 'claude-code', enabledAgents: ['claude-code'], installMethod: 'symlink', defaultScope: 'local',
+        }));
+        return root;
+    }
+    function stdoutText() {
+        return stdout.mock.calls.map((call) => String(call[0])).join('');
+    }
+    async function run(route, legacy) {
+        fs_1.default.rmSync(work, { recursive: true, force: true });
+        fs_1.default.mkdirSync(work, { recursive: true });
+        if (route === 'registry-add')
+            fs_1.default.rmSync(process.env.AWM_HOME, { recursive: true, force: true });
+        const root = route === 'registry-add' ? undefined : configureRegistry(legacy);
+        const warnings = [];
+        const reporter = (warning) => warnings.push(warning);
+        if (route === 'init') {
+            const { runInit } = require('../../src/commands/init');
+            await runInit({ cwd: work, yes: true, json: true, reporter, assertProviderSupported: () => { }, actions: { syncCache: async () => [], installHook: () => ({ status: 'installed' }) } });
+            expect(JSON.parse(stdoutText())).toHaveProperty('result');
+        }
+        else if (route === 'sync') {
+            fs_1.default.mkdirSync(path_1.default.join(work, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(work, 'package.json'), '{}');
+            fs_1.default.writeFileSync(path_1.default.join(work, '.awm', 'profile.json'), JSON.stringify({ extensions: ['demo'] }));
+            const { runSyncCore } = require('../../src/commands/sync');
+            await runSyncCore({ cwd: work, reporter }, {
+                syncRegistries: async () => [], verifyMinCliVersions: () => [], verifyProjectPins: async () => [],
+                syncProfile: () => ({ extensions: ['demo'], installed: [], skipped: [], transactionIds: [] }), reconcileProjectSkillLinks: () => [],
+            });
+        }
+        else if (route === 'update') {
+            const { runUpdateCore } = require('../../src/commands/update');
+            const { planReconciliation } = require('../../src/core/reconciliation');
+            await runUpdateCore({ yes: true, reporter }, {
+                syncRegistries: async () => [{ name: 'baseline', action: 'pulled', version: 'v1.0.0' }], verifyMinCliVersions: () => [],
+                regenerateGlobalContext: () => [], planReconciliation, applyInstallPlan: () => ({ installed: [], skipped: [], transactionId: 'test', modifiedFiles: [] }),
+                resyncInstalledHooks: () => [], offerSelfUpdate: async () => { },
+            });
+        }
+        else if (route === 'doctor') {
+            const { runDoctor } = require('../../src/commands/doctor');
+            runDoctor({ cwd: work, json: true, reporter });
+            expect(JSON.parse(stdoutText())).toHaveProperty('providers');
+        }
+        else if (route === 'export') {
+            const { runExportCommand } = require('../../src/commands/export');
+            runExportCommand('demo', { target: 'claude-ai', out: path_1.default.join(work, 'export') }, { roots: [root], reporter, log: () => { }, zip: () => ({ ok: false, missing: true }) });
+        }
+        else {
+            jest.resetModules();
+            const bundles = require('../../src/core/bundles');
+            const createReporter = bundles.createBundleDiagnosticReporter;
+            jest.spyOn(bundles, 'createBundleDiagnosticReporter').mockImplementation(() => createReporter((warning) => warnings.push(warning)));
+            const { registerRegistryCommand } = require('../../src/commands/registry');
+            const program = new (require('commander').Command)();
+            registerRegistryCommand(program);
+            if (route === 'registry-add') {
+                const source = path_1.default.join(work, 'source');
+                writeManifest(source, legacy);
+                git(source, ['init', '-q']);
+                git(source, ['add', '-A']);
+                git(source, ['commit', '-qm', 'fixture']);
+                await program.parseAsync(['node', 'awm', 'registry', 'add', source, '--name', 'fixture', '--no-install']);
+            }
+            else {
+                await program.parseAsync(['node', 'awm', 'registry', 'list']);
+            }
+        }
+        return { warnings };
+    }
+    it.each(['init', 'sync', 'update', 'doctor', 'export', 'registry-add', 'registry-status'])('%s emits one legacy warning and none for canonical manifests', async (route) => {
+        expect((await run(route, true)).warnings).toHaveLength(1);
+        stdout.mockClear();
+        expect((await run(route, false)).warnings).toEqual([]);
+    });
+});

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

@@ -11,7 +11,7 @@ const okZip = (cwd, zipName) => {
     fs_1.default.writeFileSync(path_1.default.join(cwd, zipName), 'fake-zip');
     return { ok: true, missing: false };
 };
-function makeRoot() {
+function makeRoot(legacy = false) {
     const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cmd-root-'));
     fs_1.default.mkdirSync(path_1.default.join(root, 'bundles/dev'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
@@ -20,7 +20,7 @@ function makeRoot() {
     }));
     fs_1.default.writeFileSync(path_1.default.join(root, 'bundles/dev/bundle.json'), JSON.stringify({
         name: 'dev', version: '1.0.0', scope: 'baseline', dependsOn: [],
-        skills: ['proc-skill', { name: 'mermaid', onSignal: true }], workflows: [], agents: [],
+        skills: legacy ? ['proc-skill', { name: 'mermaid', onSignal: true }] : ['proc-skill', 'mermaid'], workflows: [], agents: [],
     }));
     const mk = (name, fm) => {
         const dir = path_1.default.join(root, 'skills', name);
@@ -61,4 +61,30 @@ describe('runExportCommand (salida al usuario)', () => {
         expect(() => (0, export_1.runExportCommand)('dev', { target: 'nope', out }, { roots: [root], zip: okZip, log }))
             .toThrow(/Valid targets/);
     });
+    it('reports one legacy warning and no canonical warning through the command reporter seam', () => {
+        const legacyWarnings = [];
+        const legacy = makeRoot(true);
+        try {
+            (0, export_1.runExportCommand)('dev', { target: 'claude-ai', out }, {
+                roots: [legacy], zip: okZip, log,
+                reporter: (message) => legacyWarnings.push(message),
+            });
+            expect(legacyWarnings).toHaveLength(1);
+        }
+        finally {
+            fs_1.default.rmSync(legacy, { recursive: true, force: true });
+        }
+        const canonicalWarnings = [];
+        const canonical = makeRoot(false);
+        try {
+            (0, export_1.runExportCommand)('dev', { target: 'claude-ai', out }, {
+                roots: [canonical], zip: okZip, log,
+                reporter: (message) => canonicalWarnings.push(message),
+            });
+            expect(canonicalWarnings).toEqual([]);
+        }
+        finally {
+            fs_1.default.rmSync(canonical, { recursive: true, force: true });
+        }
+    });
 });

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

@@ -60,7 +60,7 @@ describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
     function bundle(over = {}) {
         return {
             name: 'demo', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
-            dependsOn: [], skills: [{ name: 'demo-skill', onSignal: false }], workflows: [], agents: [],
+            dependsOn: [], skills: ['demo-skill'], workflows: [], agents: [],
             ...over,
         };
     }

package/dist/tests/commands/track/verbs.test.js

@@ -103,6 +103,12 @@ describe('awm track — verbos mutantes son request-only (R6.1)', () => {
         expect(git(repo, ['rev-parse', 'HEAD'])).toBe(beforeHead);
         expect(fs_1.default.readFileSync((0, paths_1.statePath)(repo, branch), 'utf8')).toBe(beforeState);
     });
+    test('remove se anuncia como cancelación request-only soportada (TR-REQ-10)', async () => {
+        const out = await runCli(repo, ['track', 'remove', '--help']);
+        expect(out.exitCode).toBe(0);
+        expect(out.out).toContain('cancela la cohorte');
+        expect(out.out).not.toContain('NO IMPLEMENTADO');
+    });
     // `finalize` es PLAN-scoped y sin <trackId>, así que no entra en las matrices de
     // add/join/remove — pero comparte con ellas la propiedad que define a la superficie:
     // emite una request y no toca Git ni state.json.

package/dist/tests/commands/watch/apply.test.js

@@ -126,7 +126,7 @@ describe('aplicacion transaccional de requests', () => {
         expect(Object.keys((0, store_1.readJournal)(repo, 'rama').state.jobs)).toHaveLength(1); // sin duplicados
     });
     test('register-entity CREA task con VerificationPlan y ReviewObligations; cycle-plan y dispatch (R1.4/R1.4b)', () => {
-        (0, requests_1.emitRequest)(repo, 'rama', {
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
             kind: 'register-entity', generationToken: 'g1', idempotencyKey: 'e1',
             payload: {
                 entity: 'task', taskId: 'T1', title: 'implementar',
@@ -513,20 +513,57 @@ describe('aplicacion transaccional de requests', () => {
         expect(out.rejectedInvalid).toBe(1);
         expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
     });
-    test('un kind SIN handler falla cerrado: rechazo visible, no un `applied` que borra el archivo', () => {
-        // `track-teardown-request` es un kind real, emitido por `awm track remove`, que hoy
-        // no tiene handler en el supervisor. Antes de este cambio se contaba como aplicado y
-        // desaparecía sin dejar rastro; ahora queda registrado como problema y el archivo se
-        // conserva con sufijo `.rejected`, que es lo que permite darse cuenta.
-        const r = (0, requests_1.emitRequest)(repo, 'rama', {
-            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-1',
+    test('track-teardown-request persiste intención sin mover fase ni cohorte', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-alpha',
             payload: { trackId: 'alpha' },
         });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tracks[0].teardownRequested).toBe(true);
+        expect(state.tracks[0].phase).toBe('ACTIVE');
+        expect(state.cohortPhase).toBe('JOINING');
+        expect(state.appliedRequests[request.requestId]).toMatchObject({ outcome: 'applied', resultRef: 'alpha' });
+    });
+    test.each([
+        ['ausente', {}],
+        ['vacio', { trackId: '' }],
+        ['malformado', { trackId: 42 }],
+        ['desconocido', { trackId: 'no-existe' }],
+    ])('track-teardown-request %s se rechaza visiblemente sin mutar el track', (_case, payload) => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: `teardown-${_case}`,
+            payload,
+        });
         const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
         expect(out.applied).toBe(0);
         expect(out.rejectedInvalid).toBe(1);
         expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
-        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems.some((p) => p.kind === 'rejected')).toBe(true);
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.tracks).toEqual([{ ...trackRef('alpha'), phase: 'ACTIVE' }, { ...trackRef('beta'), phase: 'ACTIVE' }]);
+        expect(state.cohortPhase).toBe('JOINING');
+    });
+    test('track-teardown-request se rechaza si la cohorte no puede reconciliarse', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        s0.tracks = [{ ...trackRef('alpha'), phase: 'ACTIVE' }];
+        s0.cohortPhase = 'JOINING';
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        const request = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-invalid-cohort',
+            payload: { trackId: 'alpha' },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${request.file}.rejected`)).toBe(true);
+        expect((0, store_1.readJournal)(repo, 'rama').state.tracks[0].teardownRequested).toBeUndefined();
     });
     test('track-finalize-request persiste el autoreporte del controller (qaFinalizeRequested) — puramente declarativo (R7.2)', () => {
         (0, requests_1.emitRequest)(repo, 'rama', {