@devtrack-solution/codesdd 1.2.2

package/dist/commands/sdd/execution.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerExecutionCommands(sddCmd: Command): void;
+//# sourceMappingURL=execution.d.ts.map

package/dist/commands/sdd/execution.js

@@ -0,0 +1,409 @@
+import chalk from 'chalk';
+import { loadProjectSddConfig, resolveSddPaths } from '../../core/sdd/state.js';
+import { createSddStores } from '../../core/sdd/store/sdd-stores.js';
+import { StartService } from '../../core/sdd/services/start.service.js';
+import { FrontendImpactService } from '../../core/sdd/services/frontend-impact.service.js';
+import { FinalizeService } from '../../core/sdd/services/finalize.service.js';
+import { ContextService } from '../../core/sdd/services/context.service.js';
+import { OnboardService } from '../../core/sdd/services/onboard.service.js';
+import { ApproveService } from '../../core/sdd/services/approve.service.js';
+import { NextService } from '../../core/sdd/services/next.service.js';
+import { AuditService } from '../../core/sdd/services/audit.service.js';
+import { McpRuntimeService } from '../../core/sdd/services/mcp-runtime.service.js';
+import { ensureMandatorySddMigration, parseCsvOption, parseFlowModeOption, resolveRoot } from './shared.js';
+export function registerExecutionCommands(sddCmd) {
+    sddCmd
+        .command('mcp-manifest')
+        .description('Render a provider-agnostic MCP manifest for OpenSDD execution tools')
+        .option('--provider <provider>', 'Client profile: codex|claude-code|kimmy-code|kilo-code|open-code|generic')
+        .option('--json', 'JSON output')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const manifest = new McpRuntimeService(stores).manifest(options?.provider);
+        if (options?.json) {
+            console.log(JSON.stringify(manifest, null, 2));
+            return;
+        }
+        console.log(chalk.green(`OpenSDD MCP manifest for ${manifest.provider.label}`));
+        console.log(`Protocol: ${manifest.protocol}`);
+        console.log(`Transport: ${manifest.provider.transport}`);
+        console.log(`Tools: ${manifest.tools.map((tool) => tool.name).join(', ')}`);
+    });
+    sddCmd
+        .command('mcp-call <tool>')
+        .description('Invoke the provider-agnostic MCP bridge for next/context/finalize')
+        .option('--provider <provider>', 'Client profile: codex|claude-code|kimmy-code|kilo-code|open-code|generic')
+        .option('--ref <ref>', 'Reference for opensdd.context or opensdd.finalize')
+        .option('--rank <rank>', 'Ranking for opensdd.next: impact|criticality|fifo')
+        .option('--limit <n>', 'Limit for opensdd.next')
+        .option('--max-agents <n>', 'Max agents for opensdd.next wave simulation')
+        .option('--all-ready', 'Apply to all ready items for opensdd.finalize')
+        .option('--force-frontend', 'Force frontend finalize guardrail bypass')
+        .option('--force-transition', 'Force transition guardrail bypass')
+        .option('--json', 'JSON output')
+        .action(async (tool, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const runtime = new McpRuntimeService(stores);
+        const response = await runtime.invoke(root, {
+            provider: options?.provider,
+            tool: tool,
+            args: {
+                ref: options?.ref,
+                rank: options?.rank,
+                limit: options?.limit ? Number.parseInt(options.limit, 10) : undefined,
+                maxAgents: options?.maxAgents ? Number.parseInt(options.maxAgents, 10) : undefined,
+                allReady: options?.allReady,
+                forceFrontend: options?.forceFrontend,
+                forceTransition: options?.forceTransition,
+                cwd: process.cwd(),
+            },
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        console.log(chalk.green(`OpenSDD MCP call completed: ${response.tool}`));
+        console.log(`Provider: ${response.provider}`);
+        console.log(`Invoked at: ${response.invoked_at}`);
+        console.log(JSON.stringify(response.result, null, 2));
+    });
+    sddCmd
+        .command('start <refOrText>')
+        .description('Starts FEAT/EPIC/FGAP/TD execution or creates a direct FEAT')
+        .alias('iniciar-execucao')
+        .option('--scale <scale>', 'Escala QUICK|STANDARD|LARGE')
+        .option('--schema <schema>', 'Schema para criar change em openspec/changes')
+        .option('--force', 'Bypass de bloqueios e conflitos de lock')
+        .option('--force-transition', 'Bypass das restrições e violações das lentes estruturais')
+        .option('--flow-mode <flowMode>', 'Flow: direct|standard|rigorous')
+        .option('--fluxo <flowMode>', 'Legacy Portuguese alias for --flow-mode')
+        .option('--json', 'JSON output')
+        .option('--no-render', 'Does not generate views after updating state')
+        .action(async (refOrText, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const flow = parseFlowModeOption(options?.flowMode || options?.fluxo);
+        const command = new StartService(stores);
+        const result = await command.execute(root, refOrText, {
+            scale: options?.scale,
+            schema: options?.schema,
+            force: options?.force,
+            forceTransition: options?.forceTransition,
+            flowMode: flow,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(`Execucao iniciada para ${result.featureId}`));
+        console.log(`Change: ${result.changeName}`);
+        console.log(`Status: ${result.status}`);
+        console.log(`Guardrails: blocked=${result.start_guardrails.blocked_check.ok ? 'ok' : 'fail'} | lock=${result.start_guardrails.lock_check.ok ? 'ok' : 'fail'} | forced=${result.start_guardrails.forced ? 'sim' : 'nao'}`);
+        console.log(`Workspace ativo: ${result.active_path}`);
+        console.log(`Docs gerados: ${result.generated_docs.join(', ')}`);
+        console.log(`Fluxo: ${result.flow_mode}`);
+        console.log(`Bundles sugeridos: ${result.recommended_bundles.join(', ') || '-'}`);
+    });
+    sddCmd
+        .command('frontend-impact <featureId>')
+        .description('Declara impacto de frontend para uma FEAT')
+        .alias('impacto-frontend')
+        .option('--status <status>', 'Status: unknown|none|required')
+        .option('--reason <texto>', 'Justificativa obrigatoria para status=none')
+        .option('--routes <list>', 'Rotas separadas por virgula')
+        .option('--surfaces <list>', 'Superficies de UI separadas por virgula')
+        .option('--json', 'Saida em JSON')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (featureId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const status = options?.status;
+        if (!status || !['unknown', 'none', 'required'].includes(status)) {
+            throw new Error('Valor invalido em --status. Use unknown, none ou required.');
+        }
+        const command = new FrontendImpactService(stores);
+        const result = await command.execute(root, featureId, {
+            status,
+            reason: options?.reason,
+            routes: parseCsvOption(options?.routes),
+            surfaces: parseCsvOption(options?.surfaces),
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(`Impacto frontend atualizado para ${result.feature_id}`));
+        console.log(`Status: ${result.frontend_impact_status}`);
+        console.log(`Declarado em: ${result.frontend_impact_declared_at || '-'}`);
+        console.log(`Superficies: ${result.frontend_surface_tokens.join(', ') || '-'}`);
+    });
+    sddCmd
+        .command('finalize')
+        .description('Consolida memoria e marca FEAT como DONE')
+        .alias('consolidar')
+        .option('--ref <featId>', 'Finaliza feature especifica (ex: FEAT-0001)')
+        .option('--all-ready', 'Finaliza todas as features prontas na fila')
+        .option('--no-adr', 'Nao gera ADR automatico nesta execucao')
+        .option('--force-frontend', 'Bypass dos guardrails de frontend com auditoria explicita')
+        .option('--force-transition', 'Bypass de bloqueios estruturais por lentes no finalize')
+        .option('--json', 'Saida em JSON')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new FinalizeService(stores);
+        const result = await command.execute(root, {
+            ref: options?.ref,
+            allReady: options?.allReady,
+            noAdr: options?.noAdr,
+            forceFrontend: options?.forceFrontend,
+            forceTransition: options?.forceTransition,
+            cwd: process.cwd(),
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.finalized.length === 0) {
+            console.log('Nenhuma feature finalizada nesta execucao.');
+        }
+        else {
+            console.log(chalk.green(`Finalizadas: ${result.finalized.join(', ')}`));
+        }
+        console.log(`Liberadas: ${result.unblocked.join(', ') || '-'}`);
+        console.log(`Pendentes na fila: ${result.pending}`);
+        console.log(`Docs core atualizados: ${result.updated_core_docs?.join(', ') || '-'}`);
+        console.log(`README sincronizado: ${result.updated_readme ? 'sim' : 'nao'}`);
+        console.log(`Guia do agente sincronizado: ${result.updated_agent_guide ? 'sim' : 'nao'}`);
+        if (result.auto_frontend_gaps?.length) {
+            console.log(`FGAPs automáticos criados: ${result.auto_frontend_gaps.join(', ')}`);
+        }
+        if (result.frontend_guardrails?.length) {
+            const blocked = result.frontend_guardrails.filter((entry) => entry.blocked).length;
+            const forced = result.frontend_guardrails.filter((entry) => entry.forced).length;
+            console.log(`Guardrails frontend: avaliados=${result.frontend_guardrails.length} bloqueadas=${blocked} forced=${forced}`);
+        }
+        if (result.doc_warnings?.length) {
+            console.log(`Avisos de docs: ${result.doc_warnings.join(' | ')}`);
+        }
+    });
+    sddCmd
+        .command('context <ref>')
+        .description('Gera contexto objetivo para FEAT/EPIC/FGAP/TD (RAD legado ainda aceito)')
+        .alias('contexto')
+        .option('--json', 'Saida em JSON')
+        .action(async (ref, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new ContextService(stores);
+        const context = await command.execute(root, ref);
+        if (options?.json) {
+            console.log(JSON.stringify(context, null, 2));
+            return;
+        }
+        console.log(`Contexto de ${context.target_id} (${context.target_type})`);
+        console.log(`Resumo: ${context.summary}`);
+        console.log(`Core docs: ${context.core_docs.join(', ')}`);
+        if (context.origin) {
+            const origin = context.origin;
+            console.log(`Origem: ${origin.type}${origin.ref ? ` (${origin.ref})` : ''}`);
+        }
+        if (context.related_features) {
+            const refs = context.related_features;
+            console.log(`Features relacionadas: ${refs.join(', ') || '-'}`);
+        }
+        if (context.recommended_skills) {
+            const skills = context.recommended_skills;
+            console.log(`Skills sugeridas: ${skills.join(', ') || '-'}`);
+        }
+        if (context.skill_execution_contract) {
+            const skillContract = context.skill_execution_contract;
+            if (skillContract.required) {
+                console.log(`Evidencia de skill: ${skillContract.required_skill_ids.join(', ')} -> ${skillContract.verification_location}`);
+            }
+        }
+        if (context.read_order) {
+            const readOrder = context.read_order;
+            console.log(`Ordem de leitura: ${readOrder.join(' -> ')}`);
+        }
+        if (context.frontend_impact_status) {
+            console.log(`Impacto frontend: ${String(context.frontend_impact_status || 'unknown')}`);
+        }
+    });
+    sddCmd
+        .command('onboard [target]')
+        .description('Gera onboarding estruturado para system, EPIC-#### ou FEAT-####')
+        .alias('integrar')
+        .alias('orientar')
+        .option('--json', 'Saida em JSON')
+        .option('--compact', 'Retorna payload resumido')
+        .option('--full', 'Retorna payload completo em JSON (desativa modo compacto automatico)')
+        .action(async (target = 'system', options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new OnboardService(stores);
+        const compact = options?.full ? false : (options?.compact ?? Boolean(options?.json));
+        const result = await command.execute(root, target, { compact });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const view = result;
+        console.log(`Onboarding: ${String(view.target || target)}`);
+        console.log(`Resumo: ${String(view.summary || '-')}`);
+        if (Array.isArray(view.read_order)) {
+            console.log(`Ordem de leitura: ${view.read_order.join(' -> ')}`);
+        }
+        if (Array.isArray(view.proximos_passos)) {
+            console.log(`Proximos passos: ${view.proximos_passos.join(', ')}`);
+        }
+    });
+    sddCmd
+        .command('aprovar <featId>')
+        .description('Aprova etapa de proposta, planejamento ou tarefas de uma FEAT')
+        .requiredOption('--etapa <etapa>', 'Etapa: proposta|planejamento|tarefas')
+        .option('--por <nome>', 'Quem aprovou')
+        .option('--observacao <texto>', 'Observacao da aprovacao')
+        .option('--json', 'Saida em JSON')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (featId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const etapa = options?.etapa;
+        if (!etapa || !['proposta', 'planejamento', 'tarefas'].includes(etapa)) {
+            throw new Error('Valor invalido em --etapa. Use proposta, planejamento ou tarefas.');
+        }
+        const command = new ApproveService(stores);
+        const result = await command.execute(root, featId, etapa, {
+            by: options?.por,
+            note: options?.observacao,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(`Etapa ${result.stage} aprovada para ${result.feature_id}`));
+        console.log(`Status do gate: ${result.status}`);
+        console.log(`Etapa atual da feature: ${result.current_stage}`);
+    });
+    sddCmd
+        .command('next [path]')
+        .description('Mostra FEATs prontas para iniciar em paralelo')
+        .alias('proximo')
+        .option('--rank <mode>', 'Ranking: impact|criticality|fifo (padrao: impact)')
+        .option('--limit <n>', 'Limite de itens prontos (padrao: 10)')
+        .option('--max-agents <n>', 'Limite de itens por onda (padrao: sem limite)')
+        .option('--json', 'Saida em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        if (options?.rank && !['impact', 'criticality', 'fifo'].includes(options.rank)) {
+            throw new Error('Valor invalido em --rank. Use impact, criticality ou fifo.');
+        }
+        const command = new NextService(stores);
+        const result = await command.execute(root, {
+            rank: options?.rank,
+            limit: options?.limit ? Number(options.limit) : undefined,
+            maxAgents: options?.maxAgents ? Number(options.maxAgents) : undefined,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Ranking: ${result.rank}`);
+        console.log(`Prontas: ${result.ready.length}`);
+        for (const item of result.ready) {
+            const skills = item.recommended_skills.length > 0 ? item.recommended_skills.join(', ') : '-';
+            console.log(`- ${item.id}: ${item.title} | score=${item.score} | skills: ${skills}`);
+            console.log(`  motivos: ${item.reasons.join('; ')}`);
+        }
+        console.log(`Bloqueadas: ${result.blocked.length}`);
+        for (const item of result.blocked) {
+            const deps = item.blocked_by.length > 0 ? item.blocked_by.join(', ') : '-';
+            console.log(`- ${item.id}: ${item.title} | blocked_by: ${deps}`);
+        }
+        console.log(`Conflitos de lock: ${result.conflicts.length}`);
+        for (const item of result.conflicts) {
+            const locks = item.lock_domains.length > 0 ? item.lock_domains.join(', ') : '-';
+            console.log(`- ${item.id}: ${item.title} | locks: ${locks}`);
+        }
+        if (result.waves?.length) {
+            console.log(`Ondas: ${result.waves.length}`);
+            result.waves.forEach((wave, index) => {
+                console.log(`  Onda ${index + 1}: ${wave.length > 0 ? wave.join(', ') : '-'}`);
+            });
+        }
+        if (result.deferred?.length) {
+            console.log(`Adiados: ${result.deferred.length}`);
+            for (const item of result.deferred) {
+                console.log(`- ${item.id}: ${item.reasons.join('; ')}`);
+            }
+        }
+    });
+    sddCmd
+        .command('audit [path]')
+        .description('Audita a saude de meta-evolucao do SDD (placeholders, deliberacao, ADR e forced transition)')
+        .alias('auditar')
+        .option('--json', 'Saida em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new AuditService(stores);
+        const result = await command.execute(root);
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green('Auditoria SDD concluida.'));
+        console.log(`Gerado em: ${result.generated_at}`);
+        console.log(`Score: ${result.score}% (limiar: ${result.meta_evolution.health_alert_threshold}%)`);
+        console.log(`Saude: ${result.healthy ? 'OK' : 'ALERTA'}`);
+        console.log(`Historico: ${result.audit_history.path} (${result.audit_history.total_runs} execucoes)`);
+        console.log(`Artefatos sem placeholder: ${result.metrics.artifacts_without_placeholder.ok}/${result.metrics.artifacts_without_placeholder.total} (${result.metrics.artifacts_without_placeholder.percent}%)`);
+        console.log(`Debates com deliberacao real: ${result.metrics.debates_with_real_deliberation.ok}/${result.metrics.debates_with_real_deliberation.total} (${result.metrics.debates_with_real_deliberation.percent}%)`);
+        console.log(`ADRs gerados vs esperados: ${result.metrics.adrs_generated_vs_expected.ok}/${result.metrics.adrs_generated_vs_expected.total} (${result.metrics.adrs_generated_vs_expected.percent}%)`);
+        console.log(`Quality contracts ready: ${result.metrics.quality_contracts_ready.ok}/${result.metrics.quality_contracts_ready.total} (${result.metrics.quality_contracts_ready.percent}%)`);
+        console.log(`Forced transitions detectadas: ${result.metrics.forced_transitions.total}`);
+        if (result.metrics.forced_transitions.feature_refs.length > 0) {
+            console.log(`Features com evidencias: ${result.metrics.forced_transitions.feature_refs.join(', ')}`);
+        }
+        console.log(result.recommendation);
+    });
+}
+//# sourceMappingURL=execution.js.map

package/dist/commands/sdd/shared.d.ts

@@ -0,0 +1,9 @@
+import { type SddLanguage, type SddLayout } from '../../core/sdd/state.js';
+import type { FlowMode } from '../../core/sdd/types.js';
+export declare function parseCsvOption(value?: string): string[];
+export declare function resolveRoot(targetPath?: string): string;
+export declare function parseLangOption(value?: string): SddLanguage | undefined;
+export declare function parseLayoutOption(value?: string): SddLayout | undefined;
+export declare function parseFlowModeOption(value?: string): FlowMode | undefined;
+export declare function ensureMandatorySddMigration(targetPath: string): Promise<void>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/sdd/shared.js

@@ -0,0 +1,84 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { resolveProjectRoot } from '../../core/sdd/resolve-project-root.js';
+import { loadProjectSddConfig, resolveSddPaths, } from '../../core/sdd/state.js';
+import { assessSddMigration, SddMigrateCommand } from '../../core/sdd/migrate.js';
+import { withStateLock } from '../../core/sdd/state-lock.js';
+import { isInteractive } from '../../utils/interactive.js';
+export function parseCsvOption(value) {
+    if (!value)
+        return [];
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+export function resolveRoot(targetPath = '.') {
+    return resolveProjectRoot(targetPath === '.' ? undefined : targetPath);
+}
+export function parseLangOption(value) {
+    if (!value)
+        return undefined;
+    if (value === 'pt-BR' || value === 'en-US')
+        return value;
+    throw new Error('Invalid --lang value. Use pt-BR or en-US.');
+}
+export function parseLayoutOption(value) {
+    if (!value)
+        return undefined;
+    if (value === 'legacy' || value === 'pt-BR' || value === 'en-US')
+        return value;
+    throw new Error('Invalid --layout value. Use legacy, pt-BR, or en-US.');
+}
+export function parseFlowModeOption(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'direct' || normalized === 'direto')
+        return 'direto';
+    if (normalized === 'standard' || normalized === 'padrao' || normalized === 'padrão')
+        return 'padrao';
+    if (normalized === 'rigorous' || normalized === 'rigoroso')
+        return 'rigoroso';
+    throw new Error('Invalid --flow-mode/--fluxo value. Use direct, standard, or rigorous.');
+}
+export async function ensureMandatorySddMigration(targetPath) {
+    const resolved = resolveRoot(targetPath);
+    const config = await loadProjectSddConfig(resolved);
+    const paths = resolveSddPaths(resolved, config);
+    try {
+        await Promise.all([
+            fs.access(paths.configFile),
+            fs.access(paths.stateFiles.discoveryIndex),
+            fs.access(paths.stateFiles.backlog),
+        ]);
+    }
+    catch {
+        return;
+    }
+    const assessment = await assessSddMigration(resolved);
+    if (!assessment.needsMigration) {
+        return;
+    }
+    const summary = assessment.reasons.join(' | ');
+    if (isInteractive()) {
+        const { confirm } = await import('@inquirer/prompts');
+        const approved = await confirm({
+            message: `Migracao SDD obrigatoria detectada. Deseja aplicar agora para continuar? ${summary}`,
+            default: true,
+        });
+        if (!approved) {
+            throw new Error('Operacao interrompida: aplique a migracao SDD mandatória com `openspec sdd migrate`.');
+        }
+    }
+    const stateDir = path.dirname(paths.stateFiles.discoveryIndex);
+    const result = await withStateLock(stateDir, async () => {
+        const command = new SddMigrateCommand();
+        return command.execute(resolved, { radToEpic: true });
+    });
+    for (const message of result.messages) {
+        console.log(chalk.yellow(`[sdd:migrate] ${message}`));
+    }
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/sdd/skills.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerSkillsCommands(sddCmd: Command): void;
+//# sourceMappingURL=skills.d.ts.map

package/dist/commands/sdd/skills.js

@@ -0,0 +1,154 @@
+import chalk from 'chalk';
+import { loadProjectSddConfig, loadSkillCatalogState, resolveSddPaths } from '../../core/sdd/state.js';
+import { listBundles, suggestSkills } from '../../core/sdd/skills.js';
+import { createSddStores } from '../../core/sdd/store/sdd-stores.js';
+import { SkillsSyncService } from '../../core/sdd/services/skills-sync.service.js';
+import { SkillsInvokeService } from '../../core/sdd/services/skills-invoke.service.js';
+import { ensureMandatorySddMigration, parseCsvOption, resolveRoot } from './shared.js';
+export function registerSkillsCommands(sddCmd) {
+    const skillsCmd = sddCmd
+        .command('skills')
+        .description('Operacoes de curadoria e sugestao de skills');
+    skillsCmd.alias('habilidades');
+    skillsCmd
+        .command('bundles [path]')
+        .description('Lista os bundles disponiveis no catalogo de skills')
+        .alias('pacotes')
+        .option('--json', 'Retorna resultado em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        void stores;
+        await ensureMandatorySddMigration(root);
+        const config = await loadProjectSddConfig(root);
+        const paths = resolveSddPaths(root, config);
+        const catalog = await loadSkillCatalogState(paths);
+        const bundles = listBundles(catalog);
+        if (options?.json) {
+            console.log(JSON.stringify(bundles, null, 2));
+            return;
+        }
+        console.log(`Bundles disponiveis: ${bundles.length}`);
+        for (const bundle of bundles) {
+            console.log(`- ${bundle.id} (${bundle.skill_ids.length} skills)`);
+        }
+    });
+    skillsCmd
+        .command('sync [path]')
+        .description('Sincroniza skills curadas do catalogo para ferramentas configuradas')
+        .alias('sincronizar')
+        .option('--bundle <id>', 'Filtra por bundle especifico (pode repetir via CSV com virgula)')
+        .option('--all', 'Sincroniza todas as skills do catalogo')
+        .option('--tools <list>', 'Ferramentas alvo separadas por virgula (ex: codex,cursor,claude)')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new SkillsSyncService(stores);
+        const bundles = parseCsvOption(options?.bundle);
+        const tools = parseCsvOption(options?.tools);
+        const result = await command.execute(root, {
+            bundles,
+            all: options?.all,
+            tools,
+        });
+        const config = await loadProjectSddConfig(root);
+        const paths = resolveSddPaths(root, config);
+        const localSkillsPath = `${paths.memoryRoot.replace(/\\/g, '/')}/${config.folders.skills}/${paths.skillsCuratedFolderName}`;
+        console.log(chalk.green(`Skills sincronizadas: ${result.synced}`));
+        console.log(`Skills locais (${localSkillsPath}): ${result.local_synced}`);
+        console.log(`Ferramentas atualizadas: ${result.tools.length > 0 ? result.tools.join(', ') : 'nenhuma'}`);
+    });
+    skillsCmd
+        .command('suggest [path]')
+        .description('Sugere skills por contexto (fase, dominio e bundle)')
+        .alias('sugerir')
+        .option('--phase <phase>', 'Fase da tarefa: discover|plan|execute|verify|finalize')
+        .option('--domains <list>', 'Dominios separados por virgula (ex: backend,security,api)')
+        .option('--bundles <list>', 'Bundles separados por virgula')
+        .option('--max <n>', 'Quantidade maxima de sugestoes (padrao: 5)')
+        .option('--json', 'Retorna resultado em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        void stores;
+        await ensureMandatorySddMigration(root);
+        const config = await loadProjectSddConfig(root);
+        const paths = resolveSddPaths(root, config);
+        const catalog = await loadSkillCatalogState(paths);
+        const ranked = suggestSkills(catalog, {
+            phase: options?.phase,
+            domains: parseCsvOption(options?.domains),
+            bundles: parseCsvOption(options?.bundles),
+            max: options?.max ? Number(options.max) : undefined,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(ranked.map((entry) => ({
+                id: entry.skill.id,
+                title: entry.skill.title,
+                score: entry.score,
+                reasons: entry.reasons,
+                bundles: entry.skill.bundle_ids,
+                domains: entry.skill.domains,
+                phases: entry.skill.phases,
+            })), null, 2));
+            return;
+        }
+        if (ranked.length === 0) {
+            console.log('Nenhuma skill encontrada para os filtros informados.');
+            return;
+        }
+        console.log(`Sugestoes de skills (${ranked.length}):`);
+        for (const entry of ranked) {
+            const reasons = entry.reasons.length > 0 ? ` | criterios: ${entry.reasons.join('; ')}` : '';
+            console.log(`- ${entry.skill.id} (${entry.score})${reasons}`);
+        }
+    });
+    skillsCmd
+        .command('usar [path]')
+        .description('Monta um prompt pronto para invocar skills no agente')
+        .alias('invocar')
+        .option('--ids <list>', 'IDs de skills separados por virgula')
+        .option('--phase <phase>', 'Fase para sugestao: discover|plan|execute|verify|finalize')
+        .option('--domains <list>', 'Dominios separados por virgula')
+        .option('--bundles <list>', 'Bundles separados por virgula')
+        .option('--max <n>', 'Quantidade maxima quando usar sugestao (padrao: 5)')
+        .option('--objetivo <texto>', 'Objetivo em linguagem natural para o prompt')
+        .option('--ref <id>', 'Referencia de contexto (ex: FEAT-0001, EPIC-0001)')
+        .option('--json', 'Retorna payload em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new SkillsInvokeService(stores);
+        const result = await command.execute(root, {
+            ids: parseCsvOption(options?.ids),
+            phase: options?.phase,
+            domains: parseCsvOption(options?.domains),
+            bundles: parseCsvOption(options?.bundles),
+            max: options?.max ? Number(options.max) : undefined,
+            objective: options?.objetivo,
+            ref: options?.ref,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(`Skills selecionadas: ${result.selected_skills.length}`));
+        for (const skill of result.selected_skills) {
+            console.log(`- ${skill.id} (${skill.title})`);
+            console.log(`  path: ${skill.path}`);
+        }
+        console.log('\nPrompt pronto para usar no agente:\n');
+        console.log(result.prompt);
+    });
+}
+//# sourceMappingURL=skills.js.map