agentic-workflow-manager 9.6.1 → 9.7.1

package/dist/tests/commands/watch/track-remove-request.test.js

@@ -0,0 +1,165 @@
+"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 git_fixture_1 = require("../../helpers/git-fixture");
+const tracks_1 = require("../../../src/commands/watch/tracks");
+const apply_1 = require("../../../src/commands/watch/apply");
+const emit_1 = require("../../../src/commands/track/emit");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const BRANCH = 'main';
+describe('awm track remove -> fallback teardown', () => {
+    let planRoot;
+    let baseSha;
+    beforeEach(() => {
+        planRoot = (0, git_fixture_1.initRepo)();
+        (0, git_fixture_1.commitFile)(planRoot, '.gitignore', '.awm/\n');
+        baseSha = (0, git_fixture_1.commitFile)(planRoot, 'seed.txt', 'seed');
+        (0, store_1.initJournal)(planRoot, BRANCH);
+    });
+    afterEach(() => fs_1.default.rmSync(planRoot, { recursive: true, force: true }));
+    function declareCohort(cohortPhase = 'ACTIVE') {
+        const state = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        state.cohortPhase = cohortPhase;
+        state.cohortBaseSha = baseSha;
+        state.tracks = ['a', 'b'].map((trackId) => ({
+            trackId, worktreePath: path_1.default.join(planRoot, `../nope-${trackId}`), branch: `awm-track/${trackId}`,
+            ownership: [], sharedResources: [], dependsOn: [], fencingToken: `fence-${trackId}`.padEnd(32, '0'),
+            phase: 'ACTIVE', readinessNonce: `ready-${trackId}`.padEnd(32, '0'),
+        }));
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        return (0, store_1.readJournal)(planRoot, BRANCH).state;
+    }
+    function inertRuntime() {
+        const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+        return { ...real,
+            addWorktree: () => { throw new Error('no external mutation expected'); },
+            initTrackJournal: () => { throw new Error('no external mutation expected'); },
+            spawnSupervisor: () => { throw new Error('no external mutation expected'); },
+            stopOwnSupervisor: () => { throw new Error('no external mutation expected'); },
+            removeOwnedWorktree: () => { throw new Error('no external mutation expected'); },
+            removeOwnedBranch: () => { throw new Error('no external mutation expected'); },
+        };
+    }
+    function events() {
+        if (!fs_1.default.existsSync((0, paths_1.eventsPath)(planRoot, BRANCH)))
+            return [];
+        return fs_1.default.readFileSync((0, paths_1.eventsPath)(planRoot, BRANCH), 'utf8').trim().split('\n').filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    it('consume el marker antes que join y persiste fallback cohort-wide (TR-REQ-03, TR-REQ-04)', async () => {
+        const state = declareCohort();
+        state.tracks[0].joinRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'b');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        // Consumir el marcador es su propia frontera durable: el teardown
+        // empieza recién en la siguiente llamada.
+        expect(out.effectExecuted).toBeNull();
+        expect(out.state.cohortFallbackReason).toBe('controller-requested:b');
+        expect(out.state.tracks?.find((track) => track.trackId === 'b')?.teardownRequested)
+            .toBeUndefined();
+        expect(events().some((event) => event.kind === 'track-teardown-observed' && event.trackId === 'b'))
+            .toBe(true);
+    });
+    it('un marker sobreviviente a restart converge por el mismo reducer (TR-REQ-07)', async () => {
+        const state = declareCohort();
+        state.tracks[0].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(out.state.tracks[0].teardownRequested).toBeUndefined();
+    });
+    it.each(['SERIAL', 'COMPLETE'])('consume remove tardío como moot en %s (TR-REQ-09)', async (phase) => {
+        const state = declareCohort(phase);
+        for (const track of state.tracks) {
+            track.phase = phase === 'SERIAL' ? 'REMOVED' : 'JOINED';
+            track.frozenHeadSha = phase === 'COMPLETE' ? baseSha : undefined;
+        }
+        state.tracks[0].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.state.cohortPhase).toBe(phase);
+        expect(out.state.tracks[0].teardownRequested).toBeUndefined();
+        expect(events()).toContainEqual(expect.objectContaining({ kind: 'track-teardown-moot', trackId: 'a', phase }));
+    });
+    it('una request en cohorte BLOCKED es moot y no reabre fallback', async () => {
+        const state = declareCohort('BLOCKED');
+        state.tracks[0].phase = 'BLOCKED';
+        state.tracks[1].phase = 'REMOVED';
+        state.tracks[1].teardownRequested = true;
+        (0, store_1.writeJournal)(planRoot, BRANCH, state);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(out.effectExecuted).toBeNull();
+        expect(out.state.cohortPhase).toBe('BLOCKED');
+        expect(out.state.tracks[1].teardownRequested).toBeUndefined();
+        expect(events()).toContainEqual(expect.objectContaining({ kind: 'track-teardown-moot', trackId: 'b', phase: 'BLOCKED' }));
+    });
+    it('consume exactamente un marcador de teardown por reconcile antes de begin-teardown (issue #93)', async () => {
+        const s = declareCohort('ACTIVE');
+        s.tracks.forEach((track) => { track.teardownRequested = true; });
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        const first = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(first.effectExecuted).toBeNull();
+        expect(first.state.tracks?.find((track) => track.trackId === 'a')?.teardownRequested).toBeUndefined();
+        expect(first.state.tracks?.find((track) => track.trackId === 'b')?.teardownRequested).toBe(true);
+        const second = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, first.state, inertRuntime(), 2);
+        expect(second.effectExecuted).toBeNull();
+        expect(second.state.tracks?.every((track) => track.teardownRequested === undefined)).toBe(true);
+    });
+    it('una request repetida durante teardown no rebobina fases ni ejecuta trabajo destructivo (issue #93)', async () => {
+        declareCohort('ACTIVE');
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        const afterFirst = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g2', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g2');
+        const repeated = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(afterFirst.state.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('TEARDOWN_REQUESTED');
+        expect(repeated.effectExecuted).toBeNull();
+        expect(repeated.state.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('TEARDOWN_REQUESTED');
+        expect(repeated.state.cohortPhase).toBe('FALLBACK_PENDING');
+    });
+    it('request durante FINAL_INTERLOCK persiste fallback sin evidencia final stale (issue #93)', async () => {
+        const s = declareCohort('FINAL_INTERLOCK');
+        for (const track of s.tracks)
+            track.phase = 'MERGED_UNVERIFIED';
+        for (const track of s.tracks)
+            track.frozenHeadSha = `${track.trackId}-head`;
+        s.globalQaHeadSha = 'qa-head';
+        s.finalIntegrationJobId = 'integration-job';
+        s.qaFinalizeRequested = { headSha: 'qa-head', at: new Date().toISOString() };
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        let releases = 0;
+        const runtime = { ...inertRuntime(), releaseIntegrationLockIfHeld: () => { releases += 1; } };
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, runtime, 2);
+        const durable = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(out.state.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(durable.globalQaHeadSha).toBeUndefined();
+        expect(durable.finalIntegrationJobId).toBeUndefined();
+        expect(durable.qaFinalizeRequested).toBeUndefined();
+        expect(durable.tracks?.every((track) => track.phase === 'TEARDOWN_REQUESTED')).toBe(true);
+        expect(releases).toBe(1);
+    });
+    it('un probe de branch indemostrable detiene teardown sin serializar (issue #93)', async () => {
+        const s = declareCohort('FALLBACK_PENDING');
+        s.tracks[0].phase = 'WORKTREE_REMOVED';
+        s.tracks[1].phase = 'REMOVED';
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        const gitDir = path_1.default.join(planRoot, '.git');
+        fs_1.default.renameSync(gitDir, `${gitDir}.unavailable`);
+        await expect((0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH), 2)).rejects.toThrow(/indemostrable/);
+        fs_1.default.renameSync(`${gitDir}.unavailable`, gitDir);
+        const durable = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(durable.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(durable.tracks?.find((track) => track.trackId === 'a')?.phase).toBe('WORKTREE_REMOVED');
+    });
+});

package/dist/tests/commands/watch/track-teardown-crash.test.js

@@ -23,6 +23,8 @@ const child_process_1 = require("child_process");
 const git_fixture_1 = require("../../helpers/git-fixture");
 const tracks_1 = require("../../../src/commands/watch/tracks");
 const store_1 = require("../../../src/core/journal/store");
+const apply_1 = require("../../../src/commands/watch/apply");
+const emit_1 = require("../../../src/commands/track/emit");
 const git_1 = require("../../../src/core/tracks/git");
 const descriptor_1 = require("../../../src/core/tracks/descriptor");
 const BRANCH = 'main';
@@ -263,6 +265,31 @@ describe('reconcileTracks — crash/restart de teardown con git real (Task 13, R
         expect(fs_1.default.existsSync(path_1.default.join(root, 'track-a'))).toBe(false);
         expect(branchListed(planRoot, 'awm-track/a')).toBe(false);
     });
+    test('request bridge sobrevive crash tras el marcador y converge a SERIAL sin repetir remociones (issue #93)', async () => {
+        let s = declareCohort(planRoot, root, baseSha);
+        materializeTrackA(s);
+        s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        s.cohortPhase = 'PREPARING';
+        s.tracks = s.tracks.map((track) => track.trackId === 'a'
+            ? { ...track, phase: 'WORKTREE_CREATED', supervisorProcessRef: deadRef() }
+            : track);
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-teardown-request', 'a');
+        expect((0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1').applied).toBe(1);
+        // Crash immediately after the request marker becomes the durable
+        // protocol observation: no teardown effect has run yet.
+        s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, buildRuntime(planRoot, []), 2)).state;
+        expect(trackA(s).phase).toBe('TEARDOWN_REQUESTED');
+        const effects = [];
+        const restarted = buildRuntime(planRoot, effects);
+        for (let i = 0; i < 20 && s.cohortPhase !== 'SERIAL'; i++) {
+            s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, restarted, 2)).state;
+        }
+        expect(s.cohortPhase).toBe('SERIAL');
+        expect(trackA(s).phase).toBe('REMOVED');
+        expect(effects.filter((effect) => effect === 'worktree-effect:a')).toHaveLength(1);
+        expect(effects.filter((effect) => effect === 'branch-effect:awm-track/a')).toHaveLength(1);
+    });
     // R4.6/R4.10/C9: un worktree cuyo ownership es indemostrable (descriptor
     // ausente/corrupto, o simplemente no es el que `teardownIntent` espera)
     // NUNCA se adopta ni se borra — el track se bloquea, y el contenido

package/dist/tests/core/bundle-install.test.js

@@ -41,6 +41,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const bundles_1 = require("../../src/core/bundles");
 const bundle_install_1 = require("../../src/core/bundle-install");
+const providers_1 = require("../../src/providers");
 const profile_1 = require("../../src/core/profile");
 const executor_1 = require("../../src/core/executor");
 const executor = __importStar(require("../../src/core/executor"));
@@ -139,6 +140,41 @@ function makeFixture() {
     return { content, projectRoot, bundles: (0, bundles_1.discoverBundles)(content) };
 }
 describe('installBundle', () => {
+    it('expands canonical and legacy manifests into byte-identical artifacts for every agent target', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-binstall-compat-'));
+        const content = path_1.default.join(root, 'registry');
+        const writeManifests = (legacy) => {
+            const skills = (names) => legacy
+                ? names.map((name, index) => ({ name, onSignal: index % 2 === 0 }))
+                : names;
+            fs_1.default.writeFileSync(path_1.default.join(content, 'bundles/base/bundle.json'), JSON.stringify({
+                name: 'base', scope: 'project', dependsOn: [],
+                skills: skills(['shared', 'base-only']), workflows: [], agents: [],
+            }));
+            fs_1.default.writeFileSync(path_1.default.join(content, 'bundles/extension/bundle.json'), JSON.stringify({
+                name: 'extension', scope: 'project', dependsOn: ['base'],
+                skills: skills(['shared', 'extension-only']), workflows: [], agents: [],
+            }));
+        };
+        for (const bundle of ['base', 'extension'])
+            fs_1.default.mkdirSync(path_1.default.join(content, 'bundles', bundle), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({ bundles: [{ name: 'base', source: './bundles/base' }, { name: 'extension', source: './bundles/extension' }] }));
+        writeManifests(false);
+        const canonicalWarnings = [];
+        const legacyWarnings = [];
+        const canonicalReporter = (0, bundles_1.createBundleDiagnosticReporter)((message) => canonicalWarnings.push(message));
+        const legacyReporter = (0, bundles_1.createBundleDiagnosticReporter)((message) => legacyWarnings.push(message));
+        const canonicalBundles = (0, bundles_1.discoverBundles)(content, canonicalReporter);
+        writeManifests(true);
+        const legacyBundles = (0, bundles_1.discoverBundles)(content, legacyReporter);
+        for (const agent of providers_1.AGENT_TARGETS) {
+            const canonicalArtifacts = (0, bundle_install_1.expandBundleArtifacts)({ bundleName: 'extension', bundles: canonicalBundles, agents: [agent], method: 'copy', projectRoot: root, contentDir: content });
+            const legacyArtifacts = (0, bundle_install_1.expandBundleArtifacts)({ bundleName: 'extension', bundles: legacyBundles, agents: [agent], method: 'copy', projectRoot: root, contentDir: content });
+            expect(Buffer.from(JSON.stringify(canonicalArtifacts))).toEqual(Buffer.from(JSON.stringify(legacyArtifacts)));
+        }
+        expect(canonicalWarnings).toEqual([]);
+        expect(legacyWarnings).toHaveLength(2);
+    });
     it('materializes the bundle closure as local symlinks (deps + own skills)', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const result = (0, bundle_install_1.installBundle)({

package/dist/tests/core/bundles-multiroot.test.js

@@ -8,9 +8,10 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 function writeBundleRoot(root, bundleName, skillName) {
+    const canonicalSkillName = typeof skillName === 'string' ? skillName : skillName.name;
     fs_1.default.mkdirSync(path_1.default.join(root, 'bundles', bundleName), { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', skillName), { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', skillName, 'SKILL.md'), `---\nname: ${skillName}\ndescription: d\n---\n`);
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', canonicalSkillName), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', canonicalSkillName, 'SKILL.md'), `---\nname: ${canonicalSkillName}\ndescription: d\n---\n`);
     fs_1.default.writeFileSync(path_1.default.join(root, 'bundles', bundleName, 'bundle.json'), JSON.stringify({ name: bundleName, version: '1.0.0', scope: 'ambient', skills: [skillName] }));
     fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
         version: 1,
@@ -38,6 +39,27 @@ describe('bundles multi-root', () => {
         expect(all.map((b) => b.name).sort()).toEqual(['dev-x', 'personal-x']);
         expect(all.find((b) => b.name === 'personal-x').contentRoot).toBe(rootB);
     });
+    it('composes one legacy migration diagnostic for each affected manifest', () => {
+        writeBundleRoot(rootA, 'dev-x', { name: 'sx', onSignal: true });
+        writeBundleRoot(rootB, 'personal-x', { name: 'px', onSignal: false });
+        const { inspectAllBundles } = require('../../src/core/bundles');
+        const result = inspectAllBundles([rootA, rootB]);
+        expect(result.bundles.map((b) => b.skills)).toEqual([['sx'], ['px']]);
+        expect(result.diagnostics).toHaveLength(2);
+        expect(new Set(result.diagnostics).size).toBe(2);
+    });
+    it('keeps diagnostics distinct when manifest identities share a truncated prefix', () => {
+        const sharedPrefix = path_1.default.join(tmp, ...Array.from({ length: 30 }, () => 'shared-prefix'));
+        const longRootA = path_1.default.join(sharedPrefix, 'registry-a');
+        const longRootB = path_1.default.join(sharedPrefix, 'registry-b');
+        writeBundleRoot(longRootA, 'legacy-a', { name: 'sa', onSignal: true });
+        writeBundleRoot(longRootB, 'legacy-b', { name: 'sb', onSignal: false });
+        const { inspectAllBundles } = require('../../src/core/bundles');
+        const result = inspectAllBundles([longRootA, longRootB]);
+        expect(result.diagnostics).toHaveLength(2);
+        expect(result.diagnostics.every((diagnostic) => diagnostic.length <= 512)).toBe(true);
+        expect(result.diagnostics[0]).not.toBe(result.diagnostics[1]);
+    });
     it('discoverAllBundles throws naming both sources on bundle name collision', () => {
         writeBundleRoot(rootA, 'dup', 's1');
         writeBundleRoot(rootB, 'dup', 's2');

package/dist/tests/core/bundles-overrides.test.js

@@ -7,9 +7,10 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 function writeBundleRoot(root, bundleName, skillName) {
+    const canonicalSkillName = typeof skillName === 'string' ? skillName : skillName.name;
     fs_1.default.mkdirSync(path_1.default.join(root, 'bundles', bundleName), { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', skillName), { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', skillName, 'SKILL.md'), `---\nname: ${skillName}\ndescription: d\n---\n`);
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', canonicalSkillName), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', canonicalSkillName, 'SKILL.md'), `---\nname: ${canonicalSkillName}\ndescription: d\n---\n`);
     fs_1.default.writeFileSync(path_1.default.join(root, 'bundles', bundleName, 'bundle.json'), JSON.stringify({ name: bundleName, version: '1.0.0', scope: 'ambient', skills: [skillName] }));
     fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
         version: 1,
@@ -33,11 +34,13 @@ describe('bundle override resolution', () => {
         writeBundleRoot(rootA, 'pack', 's1');
         writeBundleRoot(rootB, 'pack', 's2');
         fs_1.default.writeFileSync(path_1.default.join(rootB, 'awm-registry.json'), JSON.stringify({ overrides: ['pack'] }));
-        const { discoverAllBundles } = require('../../src/core/bundles');
-        const out = discoverAllBundles([rootA, rootB]);
-        expect(out).toHaveLength(1);
-        expect(out[0].contentRoot).toBe(rootB);
-        expect(out[0].overrode).toBe(rootA);
+        const { inspectAllBundles } = require('../../src/core/bundles');
+        const result = inspectAllBundles([rootA, rootB]);
+        expect(result.bundles).toHaveLength(1);
+        expect(result.bundles[0].contentRoot).toBe(rootB);
+        expect(result.bundles[0].overrode).toBe(rootA);
+        expect(result.bundles[0].skills).toEqual(['s2']);
+        expect(result.diagnostics).toHaveLength(0);
     });
     it('undeclared collision still throws naming both sources', () => {
         writeBundleRoot(rootA, 'dup', 's1');

package/dist/tests/core/bundles.test.js

@@ -21,7 +21,7 @@ function makeFixture() {
     }));
     fs_1.default.writeFileSync(path_1.default.join(content, 'bundles', 'dev', 'bundle.json'), JSON.stringify({
         name: 'dev', version: '1.0.0', description: 'Dev core', scope: 'baseline', dependsOn: [],
-        skills: ['brainstorming', { name: 'architecture-advisor', onSignal: true }],
+        skills: ['brainstorming', 'architecture-advisor'],
         workflows: ['development-process'], agents: ['development-process'],
     }));
     fs_1.default.writeFileSync(path_1.default.join(content, 'bundles', 'frontend', 'bundle.json'), JSON.stringify({
@@ -47,17 +47,86 @@ describe('readCatalog', () => {
     });
 });
 describe('discoverBundles', () => {
-    it('loads each bundle and normalizes skill refs (string | object)', () => {
+    it('loads each bundle with canonical skill names', () => {
         const content = makeFixture();
         const bundles = (0, bundles_1.discoverBundles)(content);
         const dev = bundles.find((b) => b.name === 'dev');
-        expect(dev.skills).toEqual([
-            { name: 'brainstorming', onSignal: false },
-            { name: 'architecture-advisor', onSignal: true },
-        ]);
+        expect(dev.skills).toEqual(['brainstorming', 'architecture-advisor']);
         expect(dev.scope).toBe('baseline');
         expect(dev.dependsOn).toEqual([]);
     });
+    it('canonicalizes legacy skill objects and reports one bounded migration diagnostic per manifest', () => {
+        const content = makeFixture();
+        const manifest = path_1.default.join(content, 'bundles', 'dev', 'bundle.json');
+        fs_1.default.writeFileSync(manifest, JSON.stringify({
+            name: 'dev', version: '1.0.0', scope: 'baseline',
+            skills: [
+                { name: 'brainstorming', onSignal: true },
+                { name: 'architecture-advisor', onSignal: false },
+            ],
+        }));
+        const { inspectBundles } = require('../../src/core/bundles');
+        const result = inspectBundles(content);
+        expect(result.bundles[0].skills).toEqual(['brainstorming', 'architecture-advisor']);
+        expect(result.diagnostics).toHaveLength(1);
+        expect(result.diagnostics[0]).toContain('bundle.json');
+        expect(result.diagnostics[0]).toContain('skills: ["skill-name"]');
+        expect(result.diagnostics[0]).toMatch(/v10/i);
+        expect(result.diagnostics[0]).not.toMatch(/[\x00-\x1f\x7f-\x9f]/);
+        expect(result.diagnostics[0]).not.toContain('{"name"');
+        expect(result.diagnostics[0].length).toBeLessThanOrEqual(512);
+    });
+    it('forwards one deduplicated legacy diagnostic to an injected reporter', () => {
+        const content = makeFixture();
+        const manifest = path_1.default.join(content, 'bundles', 'dev', 'bundle.json');
+        fs_1.default.writeFileSync(manifest, JSON.stringify({
+            name: 'dev', version: '1.0.0', scope: 'baseline',
+            skills: [{ name: 'brainstorming', onSignal: true }, { name: 'architecture-advisor', onSignal: false }],
+        }));
+        const diagnostics = [];
+        const bundles = (0, bundles_1.discoverBundles)(content, (diagnostic) => diagnostics.push(diagnostic));
+        expect(bundles[0].skills).toEqual(['brainstorming', 'architecture-advisor']);
+        expect(diagnostics).toHaveLength(1);
+    });
+    it('creates a command-scoped warning reporter that suppresses repeated diagnostics', () => {
+        const warnings = [];
+        const report = (0, bundles_1.createBundleDiagnosticReporter)((warning) => warnings.push(warning));
+        report('legacy warning');
+        report('legacy warning');
+        expect(warnings).toEqual(['warning: legacy warning']);
+    });
+    it('sanitizes, bounds, and then deduplicates caller-provided diagnostics', () => {
+        const warnings = [];
+        const report = (0, bundles_1.createBundleDiagnosticReporter)((warning) => warnings.push(warning));
+        const payload = `legacy\x1b\n${'x'.repeat(600)}`;
+        report(payload);
+        report(`legacy ${'x'.repeat(600)}`);
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toMatch(/^warning: legacy /);
+        expect(warnings[0]).not.toMatch(/[\x00-\x1f\x7f-\x9f]/);
+        expect(warnings[0].length).toBeLessThanOrEqual('warning: '.length + 512);
+    });
+    it.each([
+        ['missing skills', undefined, /skills/],
+        ['a non-array skills value', 'brainstorming', /skills/],
+        ['an empty string skill', [''], /skills\[0\]/],
+        ['an array skill', [['brainstorming']], /skills\[0\]/],
+        ['a null skill', [null], /skills\[0\]/],
+        ['an object missing name', [{ onSignal: true }], /skills\[0\]/],
+        ['an object with an empty name', [{ name: '', onSignal: true }], /skills\[0\]/],
+        ['an object with a non-string name', [{ name: 1, onSignal: true }], /skills\[0\]/],
+        ['an object with a non-boolean onSignal', [{ name: 'brainstorming', onSignal: 'true' }], /skills\[0\]/],
+        ['an object with an unknown key', [{ name: 'brainstorming', extra: true }], /skills\[0\]/],
+    ])('rejects %s with a safe manifest identity', (_case, skills, location) => {
+        const content = makeFixture();
+        const manifest = path_1.default.join(content, 'bundles', 'dev', 'bundle.json');
+        const bundle = { name: 'dev', version: '1.0.0', scope: 'baseline' };
+        if (skills !== undefined)
+            bundle.skills = skills;
+        fs_1.default.writeFileSync(manifest, JSON.stringify(bundle));
+        expect(() => (0, bundles_1.discoverBundles)(content)).toThrow(/bundle\.json/);
+        expect(() => (0, bundles_1.discoverBundles)(content)).toThrow(location);
+    });
     it('returns [] when catalog is missing', () => {
         const empty = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-'));
         expect((0, bundles_1.discoverBundles)(empty)).toEqual([]);

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

@@ -9,7 +9,7 @@ const path_1 = __importDefault(require("path"));
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
-        dependsOn: [], skills: skills.map((s) => ({ name: s, onSignal: false })),
+        dependsOn: [], skills,
         workflows: [], agents: [],
     };
 }
@@ -86,7 +86,7 @@ describe('gatherContext', () => {
     it('machine: devCore surfaces a missing per-agent artifact even when the shared skill link is already present', () => {
         const bundleWithAgent = () => ({
             name: 'dev-core', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
-            dependsOn: [], skills: [{ name: 'development-process', onSignal: false }],
+            dependsOn: [], skills: ['development-process'],
             workflows: [], agents: ['development-process'],
         });
         // Simulate OpenCode having already linked the shared ~/.agents/skills dir.

package/dist/tests/core/export/engine.test.js

@@ -21,7 +21,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 }, { name: 'ported', onSignal: true }],
+        skills: ['proc-skill', 'mermaid', 'ported'],
         workflows: [], agents: [],
     }));
     const mk = (name, fm) => {

package/dist/tests/core/export/resolve.test.js

@@ -17,7 +17,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 }, { name: 'ported', onSignal: true }],
+        skills: ['proc-skill', 'mermaid', 'ported'],
         workflows: [], agents: [],
     }));
     const mk = (name, fm) => {

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

@@ -23,7 +23,7 @@ const tmp_1 = require("../../support/tmp");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
-        dependsOn: [], skills: skills.map((s) => ({ name: s, onSignal: false })),
+        dependsOn: [], skills,
         workflows: [], agents: [],
     };
 }

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

@@ -31,7 +31,7 @@ function seedRegistry(contentRoot) {
     fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'bundles', 'dev'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'bundles', 'dev', 'bundle.json'), JSON.stringify({
         name: 'dev', version: '1.0.0', scope: 'baseline', dependsOn: [],
-        skills: [{ name: 'brainstorming' }, { name: 'using-awm' }], workflows: [], agents: [],
+        skills: ['brainstorming', 'using-awm'], workflows: [], agents: [],
     }));
     // Seed .git in the content root so gatherMachine.registryCache.present is true.
     fs_1.default.mkdirSync(path_1.default.join(contentRoot, '.git'), { recursive: true });

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

@@ -12,7 +12,7 @@ const context_1 = require("../../../src/core/diagnostics/context");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
-        dependsOn: [], skills: skills.map((s) => ({ name: s, onSignal: false })),
+        dependsOn: [], skills,
         workflows: [], agents: [],
     };
 }

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

@@ -148,6 +148,17 @@ describe('journal types', () => {
         state.tracks[0].supervisorIntent.nonce = '';
         expect((0, types_1.isWellFormedState)(state)).toBe(false);
     });
+    test('TrackRef acepta teardownRequested booleano y rechaza otro runtime shape', () => {
+        const state = (0, types_1.emptyState)('main');
+        state.tracks = [{
+                trackId: 'cli', worktreePath: '/tmp/wt', branch: 'awm-track/cli', ownership: ['cli/'],
+                sharedResources: [], dependsOn: [], fencingToken: 'f'.repeat(32), phase: 'ACTIVE',
+                readinessNonce: 'r'.repeat(32), teardownRequested: true,
+            }];
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.tracks[0].teardownRequested = 'true';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
     test('trackContext, cohortPhase y trackIntegration validan shape cuando presentes (R9.1, R9.3)', () => {
         const state = (0, types_1.emptyState)('main');
         state.trackContext = { trackId: 'cli', taskIds: ['t1'], planDigest: 'd', baseSha: 'abc', planJournalId: 'j-plan' };

package/dist/tests/core/reconciliation.test.js

@@ -17,7 +17,7 @@ function writeBundle(contentRoot, name, scope, skills, dependsOn = []) {
     fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'bundles', name), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'bundles', name, 'bundle.json'), JSON.stringify({
         name, version: '1.0.0', scope, dependsOn,
-        skills: skills.map((s) => ({ name: s })), workflows: [], agents: [],
+        skills, workflows: [], agents: [],
     }));
     for (const skill of skills) {
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', skill), { recursive: true });

package/dist/tests/core/sync-profile-atomicity.test.js

@@ -27,7 +27,7 @@ const bundle_install_1 = require("../../src/core/bundle-install");
 function bundle(name, skills, contentRoot) {
     return {
         name, description: '', version: '1.0.0', scope: 'project', visibility: 'public',
-        dependsOn: [], skills: skills.map(n => ({ name: n })), workflows: [], agents: [],
+        dependsOn: [], skills, workflows: [], agents: [],
         source: `bundles/${name}`, contentRoot,
     };
 }

package/dist/tests/core/tracks/git.test.js

@@ -128,5 +128,12 @@ describe('git adapter', () => {
             (0, child_process_1.execFileSync)('git', ['branch', 'awm-track/x'], { cwd: repo });
             expect((0, git_1.branchExists)(repo, 'awm-track/x')).toBe(true);
         });
+        test('branchExists falla cerrado cuando git no puede probar la ausencia', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            const gitDir = path_1.default.join(repo, '.git');
+            fs_1.default.renameSync(gitDir, `${gitDir}.unavailable`);
+            expect(() => (0, git_1.branchExists)(repo, 'awm-track/nope')).toThrow(/indemostrable/);
+        });
     });
 });