agentic-workflow-manager 2.1.1 → 3.0.1

package/dist/src/commands/init.js

@@ -50,6 +50,7 @@ const registries_1 = require("../core/registries");
 const orchestrator_1 = require("../core/init/orchestrator");
 const steps_1 = require("../core/init/steps");
 const paths_1 = require("../core/paths");
+const config_1 = require("../utils/config");
 // ---------------------------------------------------------------------------
 // Rendering
 // ---------------------------------------------------------------------------
@@ -91,6 +92,14 @@ function renderInitOutcome(o) {
 async function runInit(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const agent = opts.agent ?? 'claude-code';
+    // #7: make init the source of truth for the default agent. Persist the resolved
+    // agent so later `awm add`/`awm sync` (which read preferences.defaultAgent) target
+    // the right agent instead of stamping the static default. Do NOT clobber an existing
+    // explicit preference on a bare re-init: only write when an agent was passed via -a,
+    // or when no preferences file exists yet.
+    if (opts.agent != null || !(0, config_1.preferencesExist)()) {
+        (0, config_1.savePreferences)({ ...(0, config_1.getPreferences)(), defaultAgent: agent });
+    }
     let outcome;
     try {
         const mergedActions = {

package/dist/src/release/core.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIT_LOG_FORMAT = exports.US = exports.RS = exports.PKG_NAME = void 0;
+exports.parseCommits = parseCommits;
+exports.determineBump = determineBump;
+exports.nextVersion = nextVersion;
+exports.selectFloor = selectFloor;
+exports.renderChangelog = renderChangelog;
+const versioning_1 = require("../core/versioning");
+exports.PKG_NAME = 'agentic-workflow-manager';
+exports.RS = '\x1e';
+exports.US = '\x1f';
+exports.GIT_LOG_FORMAT = `%s${exports.US}%b${exports.RS}`;
+const SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;
+const HEADER_RE = /^(\w+)(?:\(([^)]+)\))?(!)?:\s+(.+)$/;
+function parseOne(record) {
+    const [header, ...rest] = record.split(exports.US);
+    const body = rest.join(exports.US);
+    const m = HEADER_RE.exec(header.trim());
+    if (!m)
+        return null;
+    return {
+        type: m[1],
+        scope: m[2] ?? null,
+        breaking: Boolean(m[3]) || /^BREAKING CHANGE:/m.test(body),
+        subject: m[4].trim(),
+    };
+}
+function parseCommits(raw) {
+    return raw
+        .split(exports.RS)
+        .map((r) => r.trim())
+        .filter(Boolean)
+        .map(parseOne)
+        .filter((c) => c !== null);
+}
+function determineBump(commits) {
+    if (commits.some((c) => c.breaking))
+        return 'major';
+    if (commits.some((c) => c.type === 'feat'))
+        return 'minor';
+    if (commits.some((c) => c.type === 'fix' || c.type === 'perf'))
+        return 'patch';
+    return null;
+}
+function nextVersion(base, bump) {
+    const m = SEMVER_RE.exec((base ?? '').trim());
+    if (!m)
+        throw new Error(`Invalid base version: "${base}"`);
+    const [maj, min, pat] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    if (bump === 'major')
+        return `${maj + 1}.0.0`;
+    if (bump === 'minor')
+        return `${maj}.${min + 1}.0`;
+    return `${maj}.${min}.${pat + 1}`;
+}
+function selectFloor(current, lastTagVersion) {
+    if (!SEMVER_RE.test((current ?? '').trim())) {
+        throw new Error(`Invalid current version: "${current}"`);
+    }
+    const cur = current.trim();
+    if (!lastTagVersion)
+        return cur;
+    return (0, versioning_1.compareSemver)(cur, lastTagVersion) >= 0 ? cur : lastTagVersion;
+}
+function line(c) {
+    return c.scope ? `- **${c.scope}:** ${c.subject}` : `- ${c.subject}`;
+}
+function renderChangelog(version, dateISO, commits) {
+    const sections = [`## v${version} - ${dateISO}`, ''];
+    const groups = [
+        ['Breaking Changes', (c) => c.breaking],
+        ['Features', (c) => !c.breaking && c.type === 'feat'],
+        ['Fixes', (c) => !c.breaking && (c.type === 'fix' || c.type === 'perf')],
+    ];
+    for (const [title, pred] of groups) {
+        const items = commits.filter(pred);
+        if (items.length === 0)
+            continue;
+        sections.push(`### ${title}`, ...items.map(line), '');
+    }
+    return sections.join('\n').trimEnd() + '\n';
+}

package/dist/src/release/index.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 });
+exports.parseArgs = parseArgs;
+exports.main = main;
+// cli/src/release/index.ts
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const orchestrator_1 = require("./orchestrator");
+function parseArgs(argv) {
+    const opts = { dryRun: false, force: null, push: true, branch: 'main', cliDir: '' };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--dry-run')
+            opts.dryRun = true;
+        else if (a === '--no-push')
+            opts.push = false;
+        else if (a === '--branch') {
+            const val = argv[++i];
+            if (val === undefined || val.startsWith('--')) {
+                throw new Error('--branch requiere un valor (ej: --branch main)');
+            }
+            opts.branch = val;
+        }
+        else if (a === '--force') {
+            const lvl = argv[++i];
+            if (lvl !== 'major' && lvl !== 'minor' && lvl !== 'patch') {
+                throw new Error(`--force requiere major|minor|patch, recibió "${lvl}"`);
+            }
+            opts.force = lvl;
+        }
+        else {
+            throw new Error(`Flag desconocida: ${a}`);
+        }
+    }
+    return opts;
+}
+function realIO(repoRoot, cliDir) {
+    const pkgPath = path_1.default.join(cliDir, 'package.json');
+    const changelogPath = path_1.default.join(repoRoot, 'CHANGELOG.md');
+    const npmrcPath = path_1.default.join(cliDir, '.npmrc');
+    return {
+        run(cmd, args, o) {
+            return (0, child_process_1.execFileSync)(cmd, args, { cwd: o?.cwd ?? repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        },
+        readPackageVersion: () => JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8')).version,
+        writePackageVersion: (v) => {
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+            pkg.version = v;
+            fs_1.default.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+        },
+        readChangelog: () => (fs_1.default.existsSync(changelogPath) ? fs_1.default.readFileSync(changelogPath, 'utf8') : ''),
+        writeChangelog: (c) => fs_1.default.writeFileSync(changelogPath, c),
+        writeNpmrc: (token) => fs_1.default.writeFileSync(npmrcPath, `//registry.npmjs.org/:_authToken=${token}\n`),
+        removeNpmrc: () => { if (fs_1.default.existsSync(npmrcPath))
+            fs_1.default.rmSync(npmrcPath); },
+        today: () => new Date().toISOString().slice(0, 10),
+        log: (m) => console.log(m),
+        env: process.env,
+    };
+}
+function main(argv) {
+    let opts;
+    try {
+        opts = parseArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    // __dirname en dist/src/release/ → 4 niveles arriba = repoRoot
+    // dist/src/release → dist/src → dist → cli → repoRoot
+    const repoRoot = path_1.default.resolve(__dirname, '..', '..', '..', '..');
+    const cliDir = path_1.default.resolve(repoRoot, 'cli');
+    opts.cliDir = cliDir;
+    try {
+        const res = (0, orchestrator_1.release)(opts, realIO(repoRoot, cliDir));
+        if (res.released)
+            console.log(`✓ Publicado v${res.version}`);
+        else
+            console.log(`· Sin release: ${res.reason}${res.version ? ` (v${res.version})` : ''}`);
+        return 0;
+    }
+    catch (e) {
+        console.error(`✗ ${e.message}`);
+        return 1;
+    }
+}
+if (require.main === module) {
+    process.exit(main(process.argv.slice(2)));
+}

package/dist/src/release/orchestrator.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = release;
+// cli/src/release/orchestrator.ts
+const core_1 = require("./core");
+const TAG_RE = /^v(\d+)\.(\d+)\.(\d+)$/;
+function highestTag(io) {
+    const raw = io.run('git', ['tag', '--list', 'v*']).trim();
+    const tags = raw.split('\n').map((t) => t.trim()).filter((t) => TAG_RE.test(t));
+    if (tags.length === 0)
+        return null;
+    tags.sort((a, b) => {
+        const [, a1, a2, a3] = TAG_RE.exec(a).map(Number);
+        const [, b1, b2, b3] = TAG_RE.exec(b).map(Number);
+        return a1 - b1 || a2 - b2 || a3 - b3;
+    });
+    return tags[tags.length - 1];
+}
+function release(opts, io) {
+    // --- preflight gates (contrato, antes de cualquier early-exit) ---
+    if (!opts.force) {
+        const branch = io.run('git', ['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+        if (branch !== opts.branch) {
+            throw new Error(`Rama actual "${branch}" != esperada "${opts.branch}" (usá --force para relajar)`);
+        }
+    }
+    if (!opts.dryRun) {
+        const dirty = io.run('git', ['status', '--porcelain']).trim();
+        if (dirty)
+            throw new Error('Working tree con cambios sin commitear — abortando');
+        if (!io.env.NPM_TOKEN && !io.env.NODE_AUTH_TOKEN && !io.env.ACTIONS_ID_TOKEN_REQUEST_URL) {
+            throw new Error('Falta credencial de publicación: configurá NPM_TOKEN, NODE_AUTH_TOKEN, o usa OIDC (id-token: write en GitHub Actions)');
+        }
+    }
+    // baseline
+    const current = io.readPackageVersion();
+    const lastTag = highestTag(io); // "vX.Y.Z" | null
+    const lastTagVersion = lastTag ? lastTag.slice(1) : null;
+    const floor = (0, core_1.selectFloor)(current, lastTagVersion);
+    // rango de commits (solo cli/)
+    const range = lastTag ? [`${lastTag}..HEAD`] : [];
+    const logArgs = ['log', ...range, '--no-merges', `--format=${core_1.GIT_LOG_FORMAT}`, '--', 'cli/'];
+    const commits = (0, core_1.parseCommits)(io.run('git', logArgs));
+    // bump
+    const bump = opts.force ?? (0, core_1.determineBump)(commits);
+    if (!bump)
+        return { released: false, reason: 'nada que publicar (no releasable commits)' };
+    const version = (0, core_1.nextVersion)(floor, bump);
+    // GATE idempotencia
+    if (io.run('git', ['tag', '--list', `v${version}`]).trim()) {
+        throw new Error(`El tag v${version} ya existe — abortando`);
+    }
+    let published = '';
+    try {
+        published = io.run('npm', ['view', `${core_1.PKG_NAME}@${version}`, 'version']).trim();
+    }
+    catch {
+        published = '';
+    }
+    if (published)
+        throw new Error(`${core_1.PKG_NAME}@${version} ya está publicado en npm — abortando`);
+    if (opts.dryRun) {
+        io.log(`[dry-run] publicaría v${version} (bump=${bump}, base=${floor})`);
+        return { released: false, version, reason: 'dry-run' };
+    }
+    // aplicar
+    io.writePackageVersion(version);
+    const section = (0, core_1.renderChangelog)(version, io.today(), commits);
+    io.writeChangelog(section + '\n' + io.readChangelog());
+    io.run('git', ['add', 'cli/package.json', 'CHANGELOG.md']);
+    io.run('git', ['commit', '-m', `chore(release): v${version} [skip ci]`]);
+    io.run('git', ['tag', '-a', `v${version}`, '-m', `v${version}`]);
+    // OIDC mode: GitHub inyecta ACTIONS_ID_TOKEN_REQUEST_URL con id-token:write
+    //            o NODE_AUTH_TOKEN sin NPM_TOKEN (setup-node legacy con OIDC)
+    // Legacy mode (NPM_TOKEN): write .npmrc temporal, cleanup en finally
+    const useOidc = !io.env.NPM_TOKEN &&
+        (!!io.env.ACTIONS_ID_TOKEN_REQUEST_URL || !!io.env.NODE_AUTH_TOKEN);
+    let publishError;
+    if (useOidc) {
+        try {
+            io.run('npm', ['publish', '--provenance'], { cwd: opts.cliDir });
+        }
+        catch (e) {
+            publishError = e;
+        }
+    }
+    else {
+        const token = io.env.NPM_TOKEN;
+        try {
+            io.writeNpmrc(token);
+            io.run('npm', ['publish'], { cwd: opts.cliDir });
+        }
+        catch (e) {
+            publishError = e;
+        }
+        finally {
+            io.removeNpmrc();
+        }
+    }
+    if (publishError) {
+        try {
+            io.run('git', ['tag', '-d', `v${version}`]);
+        }
+        catch { /* best effort */ }
+        try {
+            io.run('git', ['reset', '--hard', 'HEAD~1']);
+        }
+        catch { /* best effort */ }
+        throw publishError;
+    }
+    if (opts.push) {
+        io.run('git', ['push', 'origin', opts.branch]);
+        io.run('git', ['push', 'origin', `v${version}`]);
+    }
+    return { released: true, version };
+}

package/dist/src/utils/config.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferencesExist = preferencesExist;
 exports.getPreferences = getPreferences;
 exports.savePreferences = savePreferences;
 // src/utils/config.ts
@@ -10,13 +11,23 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const paths_1 = require("../core/paths");
 const DEFAULT_PREFS = {
-    defaultAgent: 'antigravity',
+    // claude-code matches `awm init`'s own documented default (see init.ts / `awm init --help`).
+    // Previously 'antigravity', which silently mis-installed bundles in claude-code
+    // environments when `awm add` (the first getPreferences caller) stamped it to disk (#7).
+    defaultAgent: 'claude-code',
     installMethod: 'symlink',
     defaultScope: 'local'
 };
 function prefsDir() {
     return (0, paths_1.awmHome)();
 }
+function prefsFile() {
+    return path_1.default.join(prefsDir(), 'preferences.json');
+}
+/** True if preferences.json is already on disk (no side effect — does NOT create it). */
+function preferencesExist() {
+    return fs_1.default.existsSync(prefsFile());
+}
 function getPreferences() {
     const file = path_1.default.join(prefsDir(), 'preferences.json');
     if (!fs_1.default.existsSync(file)) {

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

@@ -84,4 +84,24 @@ describe('runInit', () => {
         expect(parsed.after.overall).toBe('degraded');
         expect(code).toBe(1);
     });
+    const prefsFile = () => path_1.default.join(process.env.AWM_HOME, 'preferences.json');
+    const readAgent = () => JSON.parse(fs_1.default.readFileSync(prefsFile(), 'utf-8')).defaultAgent;
+    it('#7: first init (no -a) persists claude-code as the default agent', async () => {
+        const { runInit } = require('../../src/commands/init');
+        expect(fs_1.default.existsSync(prefsFile())).toBe(false);
+        await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { } } });
+        expect(readAgent()).toBe('claude-code');
+    });
+    it('#7: init -a opencode persists the explicit agent', async () => {
+        const { runInit } = require('../../src/commands/init');
+        await runInit({ cwd: tmpHome, yes: true, agent: 'opencode', actions: { syncCache: async () => { } } });
+        expect(readAgent()).toBe('opencode');
+    });
+    it('#7: re-init without -a does NOT clobber an existing explicit preference', async () => {
+        const { savePreferences } = require('../../src/utils/config');
+        savePreferences({ defaultAgent: 'opencode', installMethod: 'symlink', defaultScope: 'local' });
+        const { runInit } = require('../../src/commands/init');
+        await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { } } });
+        expect(readAgent()).toBe('opencode');
+    });
 });

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("../../src/release/core");
+const rec = (header, body = '') => `${header}${core_1.US}${body}${core_1.RS}`;
+const mk = (type, breaking = false) => ({ type, scope: null, breaking, subject: 's' });
+describe('parseCommits', () => {
+    it('parsea type, scope, subject', () => {
+        const [c] = (0, core_1.parseCommits)(rec('feat(add): nueva flag'));
+        expect(c).toEqual({ type: 'feat', scope: 'add', breaking: false, subject: 'nueva flag' });
+    });
+    it('scope null cuando no hay paréntesis', () => {
+        expect((0, core_1.parseCommits)(rec('fix: corrige bug'))[0].scope).toBeNull();
+    });
+    it('breaking por bang en el header', () => {
+        expect((0, core_1.parseCommits)(rec('feat!: rompe API'))[0].breaking).toBe(true);
+    });
+    it('breaking por footer BREAKING CHANGE en el body', () => {
+        expect((0, core_1.parseCommits)(rec('feat(x): y', 'cuerpo\nBREAKING CHANGE: cambia todo'))[0].breaking).toBe(true);
+    });
+    it('descarta commits no convencionales sin romper', () => {
+        expect((0, core_1.parseCommits)(rec('merge branch foo') + rec('feat: ok'))).toEqual([
+            { type: 'feat', scope: null, breaking: false, subject: 'ok' },
+        ]);
+    });
+    it('entrada vacía → arreglo vacío', () => {
+        expect((0, core_1.parseCommits)('')).toEqual([]);
+    });
+});
+describe('determineBump', () => {
+    it('breaking → major (gana sobre feat/fix)', () => {
+        expect((0, core_1.determineBump)([mk('fix'), mk('feat', true)])).toBe('major');
+    });
+    it('feat sin breaking → minor', () => {
+        expect((0, core_1.determineBump)([mk('fix'), mk('feat')])).toBe('minor');
+    });
+    it('fix o perf → patch', () => {
+        expect((0, core_1.determineBump)([mk('fix')])).toBe('patch');
+        expect((0, core_1.determineBump)([mk('perf')])).toBe('patch');
+    });
+    it('solo docs/chore/refactor → null (nada releasable)', () => {
+        expect((0, core_1.determineBump)([mk('docs'), mk('chore'), mk('refactor')])).toBeNull();
+    });
+    it('lista vacía → null', () => {
+        expect((0, core_1.determineBump)([])).toBeNull();
+    });
+});
+describe('nextVersion', () => {
+    it('major resetea minor y patch', () => {
+        expect((0, core_1.nextVersion)('2.1.1', 'major')).toBe('3.0.0');
+    });
+    it('minor resetea patch', () => {
+        expect((0, core_1.nextVersion)('2.1.1', 'minor')).toBe('2.2.0');
+    });
+    it('patch incrementa patch', () => {
+        expect((0, core_1.nextVersion)('2.1.1', 'patch')).toBe('2.1.2');
+    });
+    it('tolera espacios alrededor', () => {
+        expect((0, core_1.nextVersion)('  2.1.1  ', 'patch')).toBe('2.1.2');
+    });
+    it.each(['', '.', '..', 'x.y.z', '2.1', '2.1.1.0'])('rechaza base inválida %p', (bad) => {
+        expect(() => (0, core_1.nextVersion)(bad, 'patch')).toThrow(/invalid base version/i);
+    });
+});
+describe('selectFloor', () => {
+    it('sin tag → usa la versión del package.json', () => {
+        expect((0, core_1.selectFloor)('2.1.1', null)).toBe('2.1.1');
+    });
+    it('package.json mayor que el tag → gana package.json (caso drift real)', () => {
+        expect((0, core_1.selectFloor)('2.1.1', '1.0.0')).toBe('2.1.1');
+    });
+    it('tag mayor que package.json → gana el tag', () => {
+        expect((0, core_1.selectFloor)('2.1.1', '2.5.0')).toBe('2.5.0');
+    });
+    it('iguales → ese valor', () => {
+        expect((0, core_1.selectFloor)('2.1.1', '2.1.1')).toBe('2.1.1');
+    });
+    it('rechaza current inválido', () => {
+        expect(() => (0, core_1.selectFloor)('', null)).toThrow(/invalid/i);
+    });
+});
+describe('renderChangelog', () => {
+    const commits = [
+        { type: 'feat', scope: 'add', breaking: false, subject: 'flag --all' },
+        { type: 'fix', scope: null, breaking: false, subject: 'corrige width' },
+        { type: 'chore', scope: null, breaking: true, subject: 'sube node' },
+    ];
+    it('encabeza con versión y fecha', () => {
+        expect((0, core_1.renderChangelog)('2.2.0', '2026-06-25', commits)).toContain('## v2.2.0 - 2026-06-25');
+    });
+    it('agrupa Features, Fixes y Breaking Changes', () => {
+        const md = (0, core_1.renderChangelog)('2.2.0', '2026-06-25', commits);
+        expect(md).toContain('### Features');
+        expect(md).toContain('- **add:** flag --all');
+        expect(md).toContain('### Fixes');
+        expect(md).toContain('- corrige width');
+        expect(md).toContain('### Breaking Changes');
+        expect(md).toContain('- sube node');
+    });
+    it('omite secciones vacías', () => {
+        const md = (0, core_1.renderChangelog)('2.2.1', '2026-06-25', [
+            { type: 'fix', scope: null, breaking: false, subject: 'x' },
+        ]);
+        expect(md).toContain('### Fixes');
+        expect(md).not.toContain('### Features');
+    });
+});

package/dist/tests/release/orchestrator.test.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/release/orchestrator.test.ts
+const orchestrator_1 = require("../../src/release/orchestrator");
+const core_1 = require("../../src/release/core");
+function makeIO(over = {}) {
+    const calls = [];
+    let pkgVersion = '2.1.1';
+    const io = {
+        run(cmd, args) {
+            const full = `${cmd} ${args.join(' ')}`;
+            calls.push(full);
+            if (cmd === 'git' && args[0] === 'rev-parse' && args.includes('--abbrev-ref'))
+                return 'main';
+            if (cmd === 'git' && args[0] === 'status')
+                return '';
+            if (cmd === 'git' && args[0] === 'tag' && args[1] === '--list' && args[2] === 'v*')
+                return over.tags ?? '';
+            if (cmd === 'git' && args[0] === 'tag' && args[1] === '--list')
+                return ''; // gate: tag puntual no existe
+            if (cmd === 'git' && args[0] === 'log')
+                return over.commits ?? `feat: nueva${core_1.US}${core_1.RS}`;
+            if (cmd === 'npm' && args[0] === 'view')
+                return over.npmView ?? '';
+            return '';
+        },
+        readPackageVersion: () => pkgVersion,
+        writePackageVersion: (v) => { pkgVersion = v; calls.push(`WRITE_PKG ${v}`); },
+        readChangelog: () => '',
+        writeChangelog: (c) => calls.push(`WRITE_CHANGELOG ${c.split('\n')[0]}`),
+        writeNpmrc: () => calls.push('WRITE_NPMRC'),
+        removeNpmrc: () => calls.push('REMOVE_NPMRC'),
+        today: () => '2026-06-25',
+        log: () => { },
+        env: { NPM_TOKEN: 'tok' },
+        ...over,
+    };
+    return { io, calls };
+}
+const opts = (o = {}) => ({ dryRun: false, force: null, push: true, branch: 'main', cliDir: '/cli', ...o });
+describe('release — happy path', () => {
+    it('feat → minor: escribe versión, commitea, taggea, publica y pushea en orden', () => {
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        const res = (0, orchestrator_1.release)(opts(), io);
+        expect(res).toEqual({ released: true, version: '2.2.0' });
+        expect(calls).toContain('WRITE_PKG 2.2.0');
+        const joined = calls.join('\n');
+        expect(joined).toMatch(/git commit .*chore\(release\): v2.2.0/);
+        expect(joined).toMatch(/git tag -a v2.2.0/);
+        expect(joined).toMatch(/npm publish/);
+        expect(joined).toMatch(/git push origin main/);
+        expect(joined).toMatch(/git push origin v2.2.0/);
+        // npmrc creado y SIEMPRE removido
+        expect(calls).toContain('WRITE_NPMRC');
+        expect(calls).toContain('REMOVE_NPMRC');
+    });
+    it('sin commits releasables → no publica (exit 0 lógico)', () => {
+        const { io, calls } = makeIO({ commits: `docs: solo docs${core_1.US}${core_1.RS}` });
+        const res = (0, orchestrator_1.release)(opts(), io);
+        expect(res.released).toBe(false);
+        expect(res.reason).toMatch(/nada que publicar|no releasable/i);
+        expect(calls).not.toContain('WRITE_PKG 2.1.2');
+        expect(calls.join('\n')).not.toMatch(/npm publish/);
+    });
+    it('--force patch publica aunque no haya commits releasables', () => {
+        const { io } = makeIO({ commits: `docs: x${core_1.US}${core_1.RS}` });
+        expect((0, orchestrator_1.release)(opts({ force: 'patch' }), io)).toEqual({ released: true, version: '2.1.2' });
+    });
+    it('--dry-run calcula la versión pero NO escribe ni publica', () => {
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        const res = (0, orchestrator_1.release)(opts({ dryRun: true }), io);
+        expect(res).toEqual({ released: false, version: '2.2.0', reason: 'dry-run' });
+        expect(calls.join('\n')).not.toMatch(/npm publish|WRITE_PKG|git commit/);
+    });
+    it('OIDC via ACTIONS_ID_TOKEN_REQUEST_URL: usa --provenance y omite .npmrc', () => {
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        io.env = { ACTIONS_ID_TOKEN_REQUEST_URL: 'https://token.actions.githubusercontent.com/...' };
+        const res = (0, orchestrator_1.release)(opts(), io);
+        expect(res).toEqual({ released: true, version: '2.2.0' });
+        expect(calls.join('\n')).toMatch(/npm publish --provenance/);
+        expect(calls).not.toContain('WRITE_NPMRC');
+        expect(calls).not.toContain('REMOVE_NPMRC');
+    });
+    it('OIDC via NODE_AUTH_TOKEN sin NPM_TOKEN: usa --provenance y omite .npmrc', () => {
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        io.env = { NODE_AUTH_TOKEN: 'oidc-tok' };
+        const res = (0, orchestrator_1.release)(opts(), io);
+        expect(res).toEqual({ released: true, version: '2.2.0' });
+        expect(calls.join('\n')).toMatch(/npm publish --provenance/);
+        expect(calls).not.toContain('WRITE_NPMRC');
+    });
+    it('--no-push omite los push', () => {
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        (0, orchestrator_1.release)(opts({ push: false }), io);
+        expect(calls.join('\n')).not.toMatch(/git push/);
+    });
+});
+describe('release — gates de preflight', () => {
+    it('aborta si la rama no es la esperada', () => {
+        const fake = makeIO().io;
+        const origRun = fake.run;
+        fake.run = (cmd, args, o) => cmd === 'git' && args[0] === 'rev-parse' ? 'feature/x' : origRun(cmd, args, o);
+        expect(() => (0, orchestrator_1.release)(opts(), fake)).toThrow(/rama|branch/i);
+    });
+    it('--force relaja el gate de rama', () => {
+        const fake = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` }).io;
+        const origRun = fake.run;
+        fake.run = (cmd, args, o) => cmd === 'git' && args[0] === 'rev-parse' ? 'feature/x' : origRun(cmd, args, o);
+        expect(() => (0, orchestrator_1.release)(opts({ force: 'patch' }), fake)).not.toThrow();
+    });
+    it('aborta si el working tree está sucio', () => {
+        const fake = makeIO().io;
+        const origRun = fake.run;
+        fake.run = (cmd, args, o) => cmd === 'git' && args[0] === 'status' ? ' M cli/src/x.ts' : origRun(cmd, args, o);
+        expect(() => (0, orchestrator_1.release)(opts(), fake)).toThrow(/working tree|sin commitear|dirty/i);
+    });
+    it('aborta si no hay credencial de publicación', () => {
+        const fake = makeIO().io;
+        fake.env = {};
+        expect(() => (0, orchestrator_1.release)(opts(), fake)).toThrow(/NPM_TOKEN|NODE_AUTH_TOKEN|OIDC/i);
+    });
+    it('el gate de credencial corre ANTES del early-exit de "nada que publicar"', () => {
+        const fake = makeIO({ commits: `docs: x${core_1.US}${core_1.RS}` }).io; // sin commits releasables
+        fake.env = {};
+        expect(() => (0, orchestrator_1.release)(opts(), fake)).toThrow(/NPM_TOKEN|NODE_AUTH_TOKEN|OIDC/i); // no devuelve {released:false}
+    });
+    it('--dry-run no exige NPM_TOKEN ni working tree limpio', () => {
+        const fake = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` }).io;
+        fake.env = {};
+        const origRun = fake.run;
+        fake.run = (cmd, args, o) => cmd === 'git' && args[0] === 'status' ? ' M x' : origRun(cmd, args, o);
+        expect((0, orchestrator_1.release)(opts({ dryRun: true }), fake).version).toBe('2.2.0');
+    });
+});
+describe('release — rollback', () => {
+    it('si npm publish falla, hace rollback del commit y del tag', () => {
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        const origRun = io.run;
+        io.run = (cmd, args, o) => {
+            if (cmd === 'npm' && args[0] === 'publish')
+                throw new Error('network error');
+            return origRun(cmd, args, o);
+        };
+        expect(() => (0, orchestrator_1.release)(opts(), io)).toThrow(/network error/i);
+        const joined = calls.join('\n');
+        expect(joined).toMatch(/git tag -d v2.2.0/);
+        expect(joined).toMatch(/git reset --hard HEAD~1/);
+        expect(calls).toContain('REMOVE_NPMRC'); // .npmrc siempre se limpia
+    });
+});
+describe('release — gates de idempotencia', () => {
+    it('aborta si el tag v2.2.0 ya existe en git', () => {
+        const { io } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        const origRun = io.run;
+        io.run = (cmd, args, o) => {
+            if (cmd === 'git' && args[0] === 'tag' && args[1] === '--list' && args[2] === 'v2.2.0')
+                return 'v2.2.0';
+            return origRun(cmd, args, o);
+        };
+        expect(() => (0, orchestrator_1.release)(opts(), io)).toThrow(/ya existe|v2\.2\.0/i);
+    });
+    it('aborta si agentic-workflow-manager@2.2.0 ya está publicado en npm', () => {
+        const { io } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        const origRun = io.run;
+        io.run = (cmd, args, o) => {
+            if (cmd === 'npm' && args[0] === 'view' && args[1] === 'agentic-workflow-manager@2.2.0')
+                return '2.2.0';
+            return origRun(cmd, args, o);
+        };
+        expect(() => (0, orchestrator_1.release)(opts(), io)).toThrow(/ya está publicado|2\.2\.0/i);
+    });
+});
+const index_1 = require("../../src/release/index");
+describe('parseArgs', () => {
+    it('defaults', () => {
+        expect((0, index_1.parseArgs)([])).toMatchObject({ dryRun: false, force: null, push: true, branch: 'main' });
+    });
+    it('--dry-run, --no-push, --force minor, --branch release', () => {
+        expect((0, index_1.parseArgs)(['--dry-run', '--no-push', '--force', 'minor', '--branch', 'release']))
+            .toMatchObject({ dryRun: true, push: false, force: 'minor', branch: 'release' });
+    });
+    it('rechaza --force con nivel inválido', () => {
+        expect(() => (0, index_1.parseArgs)(['--force', 'huge'])).toThrow(/force/i);
+    });
+    it('--branch sin valor lanza error', () => {
+        expect(() => (0, index_1.parseArgs)(['--branch'])).toThrow(/--branch requiere/i);
+    });
+});

package/dist/tests/utils/config.test.js

@@ -18,9 +18,14 @@ describe('Preferences Manager', () => {
         delete process.env.AWM_HOME;
         fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
     });
-    it('creates default preferences if none exist', () => {
+    it('creates default preferences if none exist (default agent is claude-code)', () => {
         const prefs = (0, config_1.getPreferences)();
-        expect(prefs.defaultAgent).toBe('antigravity');
+        expect(prefs.defaultAgent).toBe('claude-code');
+    });
+    it('preferencesExist reflects whether the file is on disk', () => {
+        expect((0, config_1.preferencesExist)()).toBe(false);
+        (0, config_1.getPreferences)(); // side-effect: persists defaults
+        expect((0, config_1.preferencesExist)()).toBe(true);
     });
     it('saves and loads preferences correctly', () => {
         (0, config_1.savePreferences)({ defaultAgent: 'opencode', installMethod: 'copy', defaultScope: 'local' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "2.1.1",
+  "version": "3.0.1",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"
@@ -20,6 +20,8 @@
     "build": "tsc && chmod +x dist/src/index.js",
     "test": "jest --runInBand",
     "start": "ts-node src/index.ts",
+    "prerelease": "npm run build",
+    "release": "node dist/src/release/index.js",
     "prepack": "npm run build",
     "prepublishOnly": "npm run build"
   },

package/dist/tests/core/registry-versioned-sync.test.js

@@ -1,113 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// cli/tests/core/registry-versioned-sync.test.ts
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const child_process_1 = require("child_process");
-const GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t -c tag.gpgSign=false ${cmd}`, { cwd, stdio: 'pipe' });
-function makeTaggedRepo(base, name, versions) {
-    const dir = path_1.default.join(base, name);
-    fs_1.default.mkdirSync(dir, { recursive: true });
-    GIT(dir, 'init -q -b main');
-    fs_1.default.writeFileSync(path_1.default.join(dir, 'VERSION'), 'init');
-    GIT(dir, 'add -A');
-    GIT(dir, 'commit -qm init');
-    for (const v of versions) {
-        fs_1.default.writeFileSync(path_1.default.join(dir, 'VERSION'), v);
-        GIT(dir, 'add -A');
-        GIT(dir, `commit -qm ${v}`);
-        GIT(dir, `tag v${v}`);
-    }
-    return dir;
-}
-function addRelease(source, version) {
-    fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), version);
-    GIT(source, 'add -A');
-    GIT(source, `commit -qm ${version}`);
-    GIT(source, `tag v${version}`);
-}
-describe('syncRegistry versionado (fixtures git locales)', () => {
-    let tmpHome;
-    let tmpWork;
-    let originalHome;
-    let originalAwmHome;
-    beforeEach(() => {
-        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regver-home-'));
-        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regver-work-'));
-        originalHome = process.env.HOME;
-        originalAwmHome = process.env.AWM_HOME;
-        process.env.HOME = tmpHome;
-        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
-        jest.resetModules();
-    });
-    afterEach(() => {
-        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
-        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
-        if (originalHome === undefined)
-            delete process.env.HOME;
-        else
-            process.env.HOME = originalHome;
-        if (originalAwmHome === undefined)
-            delete process.env.AWM_HOME;
-        else
-            process.env.AWM_HOME = originalAwmHome;
-    });
-    const registryVersionFile = () => path_1.default.join(process.env.AWM_HOME, 'cli-source/VERSION');
-    it('clone fresco queda checkouteado en el último tag (no en HEAD)', async () => {
-        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
-        // commit post-tag: HEAD del remote va más allá del último release
-        fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), 'unreleased');
-        GIT(source, 'add -A');
-        GIT(source, 'commit -qm unreleased');
-        const { syncRegistry } = require('../../src/core/registry');
-        const resolved = await syncRegistry(source, { channel: 'stable' });
-        expect(resolved).toEqual({ kind: 'tag', ref: 'v1.0.0', version: '1.0.0' });
-        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.0.0');
-    });
-    it('clone existente transiciona al tag nuevo tras un release en el remote', async () => {
-        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
-        const { syncRegistry } = require('../../src/core/registry');
-        await syncRegistry(source, { channel: 'stable' });
-        addRelease(source, '1.1.0');
-        const resolved = await syncRegistry(source, { channel: 'stable' });
-        expect(resolved).toEqual({ kind: 'tag', ref: 'v1.1.0', version: '1.1.0' });
-        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.1.0');
-    });
-    it('rollback: pin a un tag anterior vuelve el contenido a esa versión', async () => {
-        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0', '1.1.0']);
-        const { syncRegistry } = require('../../src/core/registry');
-        await syncRegistry(source, { channel: 'stable' });
-        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.1.0');
-        const resolved = await syncRegistry(source, { pin: '1.0.0', channel: 'stable' });
-        expect(resolved).toEqual({ kind: 'tag', ref: 'v1.0.0', version: '1.0.0' });
-        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('1.0.0');
-    });
-    it('canal dev sigue HEAD del branch y recibe commits nuevos', async () => {
-        const source = makeTaggedRepo(tmpWork, 'src', ['1.0.0']);
-        const { syncRegistry } = require('../../src/core/registry');
-        const first = await syncRegistry(source, { channel: 'dev' });
-        expect(first).toEqual({ kind: 'head', ref: 'main' });
-        fs_1.default.writeFileSync(path_1.default.join(source, 'VERSION'), 'head-2');
-        GIT(source, 'add -A');
-        GIT(source, 'commit -qm head-2');
-        await syncRegistry(source, { channel: 'dev' });
-        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('head-2');
-    });
-    it('repo sin tags en canal stable → head-fallback y sigue HEAD', async () => {
-        const source = makeTaggedRepo(tmpWork, 'src', []);
-        const { syncRegistry } = require('../../src/core/registry');
-        const resolved = await syncRegistry(source, { channel: 'stable' });
-        expect(resolved).toEqual({ kind: 'head-fallback', ref: 'main' });
-        expect(fs_1.default.readFileSync(registryVersionFile(), 'utf-8')).toBe('init');
-    });
-    it('sin opts (callers legacy) → comportamiento stable por default', async () => {
-        const source = makeTaggedRepo(tmpWork, 'src', ['2.0.0']);
-        const { syncRegistry } = require('../../src/core/registry');
-        const resolved = await syncRegistry(source);
-        expect(resolved).toEqual({ kind: 'tag', ref: 'v2.0.0', version: '2.0.0' });
-    });
-});

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

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-jest.mock('child_process');
-const mockSpawnSync = child_process_1.spawnSync;
-describe('buildCli', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('returns success when npm run build exits 0', () => {
-        mockSpawnSync.mockReturnValue({ status: 0, stderr: Buffer.from(''), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
-        const { buildCli } = require('../../src/core/registry');
-        const result = buildCli('/fake/cli');
-        expect(result).toEqual({ success: true });
-        expect(mockSpawnSync).toHaveBeenCalledWith('npm', ['run', 'build'], expect.objectContaining({ cwd: '/fake/cli', shell: true }));
-    });
-    it('returns failure with error message when build exits non-zero', () => {
-        mockSpawnSync.mockReturnValue({ status: 1, stderr: Buffer.from('tsc error: Type mismatch'), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
-        const { buildCli } = require('../../src/core/registry');
-        const result = buildCli('/fake/cli');
-        expect(result.success).toBe(false);
-        expect(result.error).toContain('tsc error');
-    });
-    it('returns failure with stdout message when tsc writes errors to stdout', () => {
-        mockSpawnSync.mockReturnValue({ status: 2, stderr: Buffer.from(''), stdout: Buffer.from('error TS2322: Type mismatch'), pid: 1, output: [], signal: null });
-        const { buildCli } = require('../../src/core/registry');
-        const result = buildCli('/fake/cli');
-        expect(result.success).toBe(false);
-        expect(result.error).toContain('TS2322');
-    });
-    it('returns failure when spawnSync throws unexpectedly', () => {
-        mockSpawnSync.mockImplementation(() => { throw new Error('unexpected error'); });
-        const { buildCli } = require('../../src/core/registry');
-        const result = buildCli('/fake/cli');
-        expect(result.success).toBe(false);
-        expect(result.error).toBe('unexpected error');
-    });
-    it('returns failure when npm is not found (shell returns status 127)', () => {
-        mockSpawnSync.mockReturnValue({ status: 127, stderr: Buffer.from('/bin/sh: npm: not found'), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
-        const { buildCli } = require('../../src/core/registry');
-        const result = buildCli('/fake/cli');
-        expect(result.success).toBe(false);
-        expect(result.error).toContain('not found');
-    });
-    it('uses REGISTRY_DIR/cli as default cwd', () => {
-        mockSpawnSync.mockReturnValue({ status: 0, stderr: Buffer.from(''), stdout: Buffer.from(''), pid: 1, output: [], signal: null });
-        const { buildCli, REGISTRY_DIR } = require('../../src/core/registry');
-        buildCli();
-        expect(mockSpawnSync).toHaveBeenCalledWith('npm', ['run', 'build'], expect.objectContaining({ cwd: `${REGISTRY_DIR}/cli` }));
-    });
-});

package/dist/tests/registry/b3-ledger-wiring.test.js

@@ -1,74 +0,0 @@
-"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 REG = path_1.default.join(__dirname, '../../../registry/skills');
-const read = (p) => fs_1.default.readFileSync(path_1.default.join(REG, p), 'utf-8');
-describe('B-3 harness-retro is ledger-driven', () => {
-    const skill = read('harness-retro/SKILL.md');
-    test('reads the ledger via awm ledger list + recurring', () => {
-        expect(skill).toMatch(/awm ledger list/);
-        expect(skill).toMatch(/awm ledger recurring/);
-    });
-    test('archives the ledger when done', () => {
-        expect(skill).toMatch(/awm ledger archive/);
-    });
-    test('no longer relies on the human "where did this fail before?" memory step', () => {
-        expect(skill).not.toMatch(/Where did this pattern fail before\?/);
-    });
-    test('cures into AGENTS.md (agnostic) for agent-style lessons + wins, not CLAUDE.md', () => {
-        expect(skill).toMatch(/AGENTS\.md/);
-    });
-    test('writes the awm-retro-complete marker', () => {
-        expect(skill).toMatch(/awm-retro-complete/);
-    });
-    test('treats recurrence as a signal, not a hard >=2 gate (interactive decision)', () => {
-        expect(skill).toMatch(/se(ñ|n)al|signal/i);
-    });
-});
-describe('B-3 capture wiring — phases append to the ledger', () => {
-    test('SDD spec reviewer emits findings AND wins to the ledger', () => {
-        const p = read('subagent-driven-development/spec-reviewer-prompt.md');
-        expect(p).toMatch(/awm ledger add/);
-        expect(p).toMatch(/--polarity finding/);
-        expect(p).toMatch(/--polarity win/);
-    });
-    test('SDD code-quality reviewer emits findings AND wins to the ledger', () => {
-        const p = read('subagent-driven-development/code-quality-reviewer-prompt.md');
-        expect(p).toMatch(/awm ledger add/);
-        expect(p).toMatch(/--polarity win/);
-    });
-    test('post-qa deep-review emits findings AND wins to the ledger', () => {
-        const p = read('post-implementation-qa/deep-review-prompt.md');
-        expect(p).toMatch(/awm ledger add/);
-        expect(p).toMatch(/--polarity win/);
-    });
-    test('verification-before-completion logs recurring sensor failures', () => {
-        const p = read('verification-before-completion/SKILL.md');
-        expect(p).toMatch(/awm ledger add/);
-    });
-    test('systematic-debugging logs the confirmed root cause', () => {
-        const p = read('systematic-debugging/SKILL.md');
-        expect(p).toMatch(/awm ledger add/);
-    });
-});
-describe('B-3 development-process routes harness-retro as a terminal phase', () => {
-    const skill = read('development-process/SKILL.md');
-    test('harness-retro appears as a pipeline phase between QA and finishing', () => {
-        const qaIdx = skill.indexOf('post-implementation-qa');
-        const retroIdx = skill.indexOf('harness-retro');
-        const finishIdx = skill.indexOf('finishing-a-development-branch');
-        expect(retroIdx).toBeGreaterThan(-1);
-        expect(qaIdx).toBeLessThan(retroIdx);
-        expect(retroIdx).toBeLessThan(finishIdx);
-        // Also assert the routing edge exists (not just node declarations)
-        expect(skill).toMatch(/post-implementation-qa.*harness-retro|harness-retro.*post-implementation-qa/s);
-        expect(skill).toMatch(/harness-retro.*finishing-a-development-branch|finishing-a-development-branch.*harness-retro/s);
-    });
-    test('routing keys on the awm-retro-complete marker', () => {
-        expect(skill).toMatch(/awm-retro-complete/);
-    });
-});

package/dist/tests/registry/catalog-consistency.test.js

@@ -1,47 +0,0 @@
-"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 CONTENT = path_1.default.join(__dirname, '../../../registry');
-function readJson(p) { return JSON.parse(fs_1.default.readFileSync(p, 'utf-8')); }
-describe('catalog/bundle consistency', () => {
-    const catalog = readJson(path_1.default.join(CONTENT, 'catalog.json'));
-    it('declares exactly the 4 bundles', () => {
-        expect(catalog.bundles.map((b) => b.name).sort())
-            .toEqual(['authoring', 'dev', 'docs', 'frontend']);
-    });
-    it('every catalog entry has a matching bundle.json whose mirrored fields agree', () => {
-        for (const entry of catalog.bundles) {
-            const manifest = readJson(path_1.default.join(CONTENT, entry.source, 'bundle.json'));
-            expect(manifest.name).toBe(entry.name);
-            expect(manifest.scope).toBe(entry.scope);
-            expect(manifest.version).toBe(entry.version);
-            expect(manifest.visibility ?? 'public').toBe(entry.visibility ?? 'public');
-        }
-    });
-    it('every referenced skill exists in registry/skills', () => {
-        for (const entry of catalog.bundles) {
-            const manifest = readJson(path_1.default.join(CONTENT, entry.source, 'bundle.json'));
-            for (const s of manifest.skills) {
-                const name = typeof s === 'string' ? s : s.name;
-                expect(fs_1.default.existsSync(path_1.default.join(CONTENT, 'skills', name, 'SKILL.md'))).toBe(true);
-            }
-        }
-    });
-    it('bundle skills partition the 41 skills with no overlap', () => {
-        const all = [];
-        for (const entry of catalog.bundles) {
-            const manifest = readJson(path_1.default.join(CONTENT, entry.source, 'bundle.json'));
-            for (const s of manifest.skills)
-                all.push(typeof s === 'string' ? s : s.name);
-        }
-        expect(all.length).toBe(41);
-        expect(new Set(all).size).toBe(41);
-    });
-    it('processes.json has been removed', () => {
-        expect(fs_1.default.existsSync(path_1.default.join(CONTENT, 'processes.json'))).toBe(false);
-    });
-});

package/dist/tests/registry/design-skills.test.js

@@ -1,146 +0,0 @@
-"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 REGISTRY = path_1.default.join(__dirname, '..', '..', '..', 'registry');
-const SKILLS = path_1.default.join(REGISTRY, 'skills');
-const LOCK_FILE = path_1.default.join(__dirname, '..', '..', '..', 'skills-lock.json');
-function frontmatter(skill) {
-    const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, skill, 'SKILL.md'), 'utf-8');
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    expect(match).not.toBeNull();
-    return match[1];
-}
-describe('frontend-craft skill', () => {
-    it('exists with valid frontmatter', () => {
-        const fm = frontmatter('frontend-craft');
-        expect(fm).toMatch(/^name:\s*frontend-craft\s*$/m);
-        expect(fm).toMatch(/^description:\s*.+$/m);
-    });
-    it('bundles emil and taste as internal references', () => {
-        const ref = path_1.default.join(SKILLS, 'frontend-craft', 'reference');
-        expect(fs_1.default.existsSync(path_1.default.join(ref, 'emil-design-eng.md'))).toBe(true);
-        expect(fs_1.default.existsSync(path_1.default.join(ref, 'design-taste-frontend.md'))).toBe(true);
-    });
-    it('SKILL.md points to its reference files', () => {
-        const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, 'frontend-craft', 'SKILL.md'), 'utf-8');
-        expect(content).toMatch(/reference\/emil-design-eng\.md/);
-        expect(content).toMatch(/reference\/design-taste-frontend\.md/);
-    });
-});
-describe('impeccable skill (non-live scope)', () => {
-    const base = path_1.default.join(SKILLS, 'impeccable');
-    it('exists with valid frontmatter', () => {
-        expect(fs_1.default.existsSync(path_1.default.join(base, 'SKILL.md'))).toBe(true);
-    });
-    it('has no literal .agents/skills/impeccable paths in markdown', () => {
-        const mdFiles = [
-            path_1.default.join(base, 'SKILL.md'),
-            ...fs_1.default.readdirSync(path_1.default.join(base, 'reference')).map((f) => path_1.default.join(base, 'reference', f)),
-        ];
-        for (const f of mdFiles) {
-            const content = fs_1.default.readFileSync(f, 'utf-8');
-            expect(content).not.toMatch(/\.agents\/skills\/impeccable/);
-        }
-    });
-    it('dropped the live/Codex layer', () => {
-        expect(fs_1.default.existsSync(path_1.default.join(base, 'agents'))).toBe(false);
-        expect(fs_1.default.existsSync(path_1.default.join(base, 'reference', 'live.md'))).toBe(false);
-        expect(fs_1.default.existsSync(path_1.default.join(base, 'reference', 'codex.md'))).toBe(false);
-        const liveScripts = fs_1.default.readdirSync(path_1.default.join(base, 'scripts')).filter((f) => /^live-/.test(f) || f === 'modern-screenshot.umd.js');
-        expect(liveScripts).toEqual([]);
-    });
-    it('kept the static detector and non-live support scripts', () => {
-        const scripts = path_1.default.join(base, 'scripts');
-        for (const keep of ['detect.mjs', 'context.mjs', 'critique-storage.mjs', 'impeccable-paths.mjs']) {
-            expect(fs_1.default.existsSync(path_1.default.join(scripts, keep))).toBe(true);
-        }
-        expect(fs_1.default.existsSync(path_1.default.join(scripts, 'detector'))).toBe(true);
-    });
-    it('removed the live row from the commands table', () => {
-        const content = fs_1.default.readFileSync(path_1.default.join(base, 'SKILL.md'), 'utf-8');
-        expect(content).not.toMatch(/\|\s*`live`\s*\|/);
-    });
-});
-describe('google stitch skills', () => {
-    for (const s of ['extract-design-md', 'code-to-design', 'react-components']) {
-        it(`${s} exists with SKILL.md`, () => {
-            expect(fs_1.default.existsSync(path_1.default.join(SKILLS, s, 'SKILL.md'))).toBe(true);
-        });
-    }
-});
-describe('catalog/bundles (replaces processes.json)', () => {
-    const catalog = JSON.parse(fs_1.default.readFileSync(path_1.default.join(REGISTRY, 'catalog.json'), 'utf-8'));
-    function readBundle(source) {
-        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(REGISTRY, source, 'bundle.json'), 'utf-8'));
-    }
-    function skillNames(bundle) {
-        return bundle.skills.map((s) => (typeof s === 'string' ? s : s.name));
-    }
-    it('frontend bundle includes the heavy design skills', () => {
-        const entry = catalog.bundles.find((b) => b.name === 'frontend');
-        expect(entry).toBeDefined();
-        const bundle = readBundle(entry.source);
-        const names = skillNames(bundle);
-        for (const s of ['impeccable', 'ui-design', 'extract-design-md', 'code-to-design', 'react-components']) {
-            expect(names).toContain(s);
-        }
-    });
-    it('frontend bundle includes frontend-craft', () => {
-        const entry = catalog.bundles.find((b) => b.name === 'frontend');
-        expect(entry).toBeDefined();
-        const bundle = readBundle(entry.source);
-        expect(skillNames(bundle)).toContain('frontend-craft');
-    });
-    it('every skill referenced by any bundle exists on disk', () => {
-        for (const entry of catalog.bundles) {
-            const bundle = readBundle(entry.source);
-            for (const s of skillNames(bundle)) {
-                expect(fs_1.default.existsSync(path_1.default.join(SKILLS, s, 'SKILL.md'))).toBe(true);
-            }
-        }
-    });
-});
-describe('skills-lock.json', () => {
-    const lock = JSON.parse(fs_1.default.readFileSync(LOCK_FILE, 'utf-8'));
-    it('records provenance for the new external skills', () => {
-        for (const s of ['emil-design-eng', 'design-taste-frontend', 'impeccable', 'extract-design-md', 'code-to-design', 'react-components']) {
-            expect(lock.skills[s]).toBeDefined();
-            expect(lock.skills[s].source).toMatch(/.+\/.+/);
-            expect(lock.skills[s].sourceType).toBe('github');
-        }
-    });
-});
-describe('post-implementation-qa skill', () => {
-    const base = path_1.default.join(SKILLS, 'post-implementation-qa');
-    it('exists with valid frontmatter', () => {
-        const content = fs_1.default.readFileSync(path_1.default.join(base, 'SKILL.md'), 'utf-8');
-        const match = content.match(/^---\n([\s\S]*?)\n---/);
-        expect(match).not.toBeNull();
-        const fm = match[1];
-        expect(fm).toMatch(/^name:\s*post-implementation-qa\s*$/m);
-        expect(fm).toMatch(/^description:\s*.+$/m);
-    });
-    it('includes deep-review-prompt.md', () => {
-        expect(fs_1.default.existsSync(path_1.default.join(base, 'deep-review-prompt.md'))).toBe(true);
-    });
-    it('SKILL.md contains the awm-qa-complete marker instruction', () => {
-        const content = fs_1.default.readFileSync(path_1.default.join(base, 'SKILL.md'), 'utf-8');
-        expect(content).toMatch(/awm-qa-complete/);
-    });
-});
-describe('development-process QA integration', () => {
-    it('SKILL.md references post-implementation-qa at least 6 times', () => {
-        const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, 'development-process', 'SKILL.md'), 'utf-8');
-        const matches = content.match(/post-implementation-qa/g) || [];
-        expect(matches.length).toBeGreaterThanOrEqual(6);
-    });
-    it('SKILL.md references awm-qa-complete at least 2 times', () => {
-        const content = fs_1.default.readFileSync(path_1.default.join(SKILLS, 'development-process', 'SKILL.md'), 'utf-8');
-        const matches = content.match(/awm-qa-complete/g) || [];
-        expect(matches.length).toBeGreaterThanOrEqual(2);
-    });
-});

package/dist/tests/registry/prose-agnostic.test.js

@@ -1,18 +0,0 @@
-"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 REPO_ROOT = path_1.default.resolve(__dirname, '../../..');
-describe('skill prose stays agent-agnostic (#5)', () => {
-    const files = ['writing-skills/SKILL.md', 'project-constitution/SKILL.md'];
-    for (const f of files) {
-        it(`${f} does not push the model to the ~/.claude/skills path`, () => {
-            const txt = fs_1.default.readFileSync(path_1.default.join(REPO_ROOT, 'registry/skills', f), 'utf-8');
-            expect(txt).not.toMatch(/~\/\.claude\/skills/);
-            expect(txt).not.toMatch(/\.claude\/settings\.json/);
-        });
-    }
-});

package/dist/tests/registry/sensor-packs.test.js

@@ -1,45 +0,0 @@
-"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 REGISTRY_ROOT = path_1.default.join(__dirname, '..', '..', '..', 'registry');
-const PACKS_DIR = path_1.default.join(REGISTRY_ROOT, 'sensor-packs');
-describe('sensor-packs registry', () => {
-    it('sensor-packs directory exists in registry', () => {
-        expect(fs_1.default.existsSync(PACKS_DIR)).toBe(true);
-    });
-    for (const packName of ['js-ts', 'generic']) {
-        describe(`pack: ${packName}`, () => {
-            const packDir = path_1.default.join(PACKS_DIR, packName);
-            it('directory exists', () => {
-                expect(fs_1.default.existsSync(packDir)).toBe(true);
-            });
-            it('has valid pack.json', () => {
-                const packJson = path_1.default.join(packDir, 'pack.json');
-                expect(fs_1.default.existsSync(packJson)).toBe(true);
-                const parsed = JSON.parse(fs_1.default.readFileSync(packJson, 'utf-8'));
-                expect(parsed.name).toBe(packName);
-                expect(typeof parsed.description).toBe('string');
-                expect(typeof parsed.sensors).toBe('object');
-            });
-            it('pack.json name matches directory name', () => {
-                const parsed = JSON.parse(fs_1.default.readFileSync(path_1.default.join(packDir, 'pack.json'), 'utf-8'));
-                expect(parsed.name).toBe(packName);
-            });
-        });
-    }
-    it('js-ts pack has required sensor config files', () => {
-        const jstsDir = path_1.default.join(PACKS_DIR, 'js-ts');
-        expect(fs_1.default.existsSync(path_1.default.join(jstsDir, 'tsconfig.awm.json'))).toBe(true);
-        expect(fs_1.default.existsSync(path_1.default.join(jstsDir, 'eslint.config.awm.mjs'))).toBe(true);
-        expect(fs_1.default.existsSync(path_1.default.join(jstsDir, '.semgrep.awm.yml'))).toBe(true);
-    });
-    it('tsconfig.awm.json extends ./tsconfig.json', () => {
-        const tsconfig = JSON.parse(fs_1.default.readFileSync(path_1.default.join(PACKS_DIR, 'js-ts', 'tsconfig.awm.json'), 'utf-8'));
-        expect(tsconfig.extends).toBe('./tsconfig.json');
-        expect(tsconfig.compilerOptions?.strict).toBe(true);
-    });
-});

package/dist/tests/registry/skill-versions.test.js

@@ -1,26 +0,0 @@
-"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 SKILLS_DIR = path_1.default.join(__dirname, '../../../registry/skills');
-function frontmatter(file) {
-    const raw = fs_1.default.readFileSync(file, 'utf-8');
-    const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    return m ? m[1] : '';
-}
-describe('skill frontmatter version', () => {
-    const dirs = fs_1.default.readdirSync(SKILLS_DIR, { withFileTypes: true })
-        .filter((e) => e.isDirectory())
-        .filter((e) => fs_1.default.existsSync(path_1.default.join(SKILLS_DIR, e.name, 'SKILL.md')))
-        .map((e) => e.name);
-    it('finds the 41 skills', () => {
-        expect(dirs.length).toBe(41);
-    });
-    it.each(dirs)('skill "%s" declares a semver version', (name) => {
-        const fm = frontmatter(path_1.default.join(SKILLS_DIR, name, 'SKILL.md'));
-        expect(fm).toMatch(/^version:\s*["']?\d+\.\d+\.\d+["']?\s*$/m);
-    });
-});

package/dist/tests/registry/using-awm.test.js

@@ -1,39 +0,0 @@
-"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"));
-describe('using-awm skill', () => {
-    const skillPath = path_1.default.join(__dirname, '../../../registry/skills/using-awm/SKILL.md');
-    it('exists at the expected path', () => {
-        expect(fs_1.default.existsSync(skillPath)).toBe(true);
-    });
-    it('has a valid frontmatter with required fields', () => {
-        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
-        const match = content.match(/^---\n([\s\S]*?)\n---/);
-        expect(match).not.toBeNull();
-        const frontmatter = match[1];
-        expect(frontmatter).toMatch(/^name:\s*using-awm\s*$/m);
-        expect(frontmatter).toMatch(/^description:\s*.+$/m);
-    });
-    it('does NOT contain a model: field (aligned with canon)', () => {
-        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
-        expect(content).not.toMatch(/^model:\s*/m);
-    });
-    it('uses tiered triggering (no blanket 1% mandate)', () => {
-        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
-        expect(content).not.toMatch(/1%/);
-        expect(content).toMatch(/always|siempre/i);
-        expect(content).toMatch(/signal|señal/i);
-    });
-    it('contains SUBAGENT-STOP block (prevents recursion)', () => {
-        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
-        expect(content).toMatch(/<SUBAGENT-STOP>/);
-    });
-    it('points to development-process as default orchestrator', () => {
-        const content = fs_1.default.readFileSync(skillPath, 'utf-8');
-        expect(content).toMatch(/development-process/);
-    });
-});