@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/commands/sdd/execution.js

@@ -1,20 +1,169 @@
 import chalk from 'chalk';
-import { loadProjectSddConfig, resolveSddPaths } from '../../core/sdd/state.js';
+import { loadProjectSddConfig, loadStateSnapshot, 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 { ContextService, CONTEXT_PACK_BUDGET_MODES } 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 { DeepAgentsRunService, } from '../../core/sdd/services/agent-run.service.js';
+import { evaluateReleaseReadiness, formatReleaseReadinessReport } from '../../core/sdd/release-readiness.js';
 import { ensureMandatorySddMigration, parseCsvOption, parseFlowModeOption, resolveRoot } from './shared.js';
+const PREFLIGHT_MUTATING_PLUGIN_FLOW = [
+    'plugin-inspect',
+    'plugin-plan',
+    'plugin-dry-run',
+    'policy-evaluation',
+    'artifact-manifest',
+    'evidence-manifest',
+    'validation-manifest',
+    'rollback-manifest',
+];
+function parseJsonObjectOption(value, optionName = '--input') {
+    if (!value)
+        return {};
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${optionName} must be a JSON object.`);
+    }
+    return parsed;
+}
+function parseGovernedOverrideOption(value) {
+    if (!value)
+        return undefined;
+    return parseJsonObjectOption(value, '--governed-override');
+}
+function buildChangeSafetyFromOptions(options) {
+    return {
+        explicit_modification_intent: {
+            operation: options.intentOperation,
+        },
+        context_lock: {
+            allowed_paths: parseCsvOption(options.allowedPaths ?? options.writeScope),
+            forbidden_paths: parseCsvOption(options.forbiddenPaths),
+            protected_core: parseCsvOption(options.protectedCore),
+        },
+        change_budget: {
+            max_files_changed: parseNonNegativeNumberOption(options.maxFilesChanged, '--max-files-changed'),
+            max_new_files: parseNonNegativeNumberOption(options.maxNewFiles, '--max-new-files'),
+            max_deleted_files: parseNonNegativeNumberOption(options.maxDeletedFiles, '--max-deleted-files'),
+        },
+        governed_override: parseGovernedOverrideOption(options.governedOverride),
+    };
+}
+function resolvePreflightMode(lifecycle) {
+    return lifecycle === 'finalize' ? 'apply-approved' : 'apply-sandbox';
+}
+function buildPreflightRequest(options) {
+    const mode = resolvePreflightMode(options.lifecycle ?? 'custom');
+    return {
+        provider: 'deepagents',
+        mode,
+        objective: options.objective,
+        plugin_execution_path: 'broker',
+        plugin_flow: [...PREFLIGHT_MUTATING_PLUGIN_FLOW, mode],
+        operations: ['read', 'write', 'execute', 'plugin-apply'],
+        write_scope: parseCsvOption(options.writeScope),
+        planned_writes: parseCsvOption(options.plannedWrites),
+        change_safety: buildChangeSafetyFromOptions(options),
+        approval_grants: ['all'],
+    };
+}
+function resolveContextBudgetModeOption(options) {
+    const requested = options?.compact
+        ? 'compact'
+        : options?.full
+            ? 'full'
+            : options?.budget ?? 'standard';
+    if (!CONTEXT_PACK_BUDGET_MODES.includes(requested)) {
+        throw new Error(`Modo de budget invalido: ${requested}. Use compact, standard ou full.`);
+    }
+    return requested;
+}
+function parsePositiveNumberOption(value, name) {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Valor invalido em ${name}. Use um numero positivo.`);
+    }
+    return parsed;
+}
+function parseNonNegativeNumberOption(value, name) {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error(`Valor invalido em ${name}. Use um numero nao negativo.`);
+    }
+    return parsed;
+}
+async function buildPlanStatus(root, stores, options) {
+    const config = await loadProjectSddConfig(root);
+    const paths = resolveSddPaths(root, config);
+    const snapshot = await loadStateSnapshot(paths, config);
+    const next = await new NextService(stores).execute(root, {
+        rank: options?.rank,
+        limit: parsePositiveNumberOption(options?.limit, '--limit'),
+        maxAgents: parsePositiveNumberOption(options?.maxAgents, '--max-agents'),
+    });
+    const active = snapshot.backlog.items
+        .filter((item) => item.status === 'IN_PROGRESS')
+        .map((item) => ({
+        id: item.id,
+        title: item.title,
+        current_stage: item.current_stage,
+        frontend_impact_status: item.frontend_impact_status,
+        next_action: `codesdd sdd finalize --ref ${item.id}`,
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const counts = snapshot.backlog.items.reduce((acc, item) => {
+        acc.total += 1;
+        acc.by_status[item.status] = (acc.by_status[item.status] ?? 0) + 1;
+        return acc;
+    }, { total: 0, by_status: {} });
+    return {
+        schema_version: 1,
+        generated_at: new Date().toISOString(),
+        active,
+        next,
+        counts,
+        recommended_action: active.length > 0
+            ? `Finalize active feature ${active[0].id} before starting more work.`
+            : next.ready.length > 0
+                ? `Run codesdd sdd execute-next to start ${next.ready[0].id}.`
+                : 'No ready feature is available.',
+    };
+}
 export function registerExecutionCommands(sddCmd) {
+    sddCmd
+        .command('release-readiness')
+        .description('Report non-mutating release readiness gates and CI parity commands')
+        .alias('prontidao-release')
+        .option('--strict', 'Return exit code 1 when readiness is blocked')
+        .option('--json', 'JSON output')
+        .action(async (options) => {
+        const root = resolveRoot();
+        await ensureMandatorySddMigration(root);
+        const report = await evaluateReleaseReadiness(root);
+        if (options?.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            const color = report.status === 'ready' ? chalk.green : report.status === 'warning' ? chalk.yellow : chalk.red;
+            console.log(color(formatReleaseReadinessReport(report)));
+        }
+        if (options?.strict && report.status === 'blocked') {
+            process.exitCode = 1;
+        }
+    });
     sddCmd
         .command('mcp-manifest')
-        .description('Render a provider-agnostic MCP manifest for OpenSDD execution tools')
+        .description('Render a provider-agnostic MCP manifest for CodeSDD execution tools')
         .option('--provider <provider>', 'Client profile: codex|claude-code|kimmy-code|kilo-code|open-code|generic')
         .option('--json', 'JSON output')
         .action(async (options) => {
@@ -28,22 +177,46 @@ export function registerExecutionCommands(sddCmd) {
             console.log(JSON.stringify(manifest, null, 2));
             return;
         }
-        console.log(chalk.green(`OpenSDD MCP manifest for ${manifest.provider.label}`));
+        console.log(chalk.green(`CodeSDD 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')
+        .description('Invoke governed CodeSDD MCP tools for DeepAgents')
         .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('--ref <ref>', 'Reference for context/read/query/quality tools')
+        .option('--ref-or-text <value>', 'Reference or free text for codesdd.start intent')
+        .option('--feature-id <id>', 'Feature id for codesdd.finalize_intent or codesdd.frontend_impact')
+        .option('--status <status>', 'Status for codesdd.frontend_impact: unknown|none|required')
+        .option('--reason <text>', 'Reason for codesdd.frontend_impact when applicable')
+        .option('--routes <list>', 'CSV routes for codesdd.frontend_impact')
+        .option('--surfaces <list>', 'CSV surfaces for codesdd.frontend_impact')
+        .option('--manifest-path <path>', 'Plugin manifest path for plugin tools')
+        .option('--feature-ref <ref>', 'Feature ref for plugin plan/apply_sandbox')
+        .option('--capability <name>', 'Plugin capability for plugin plan/apply_sandbox')
+        .option('--skill-ref <ref>', 'Skill reference for plugin plan/apply_sandbox')
+        .option('--input <json>', 'JSON object input for plugin plan/apply_sandbox')
+        .option('--write-scope <list>', 'CSV write scope for plugin plan/apply_sandbox')
+        .option('--approval-grants <list>', 'CSV approvals for plugin plan/apply_sandbox')
+        .option('--planned-writes <list>', 'CSV planned writes for plugin plan/apply_sandbox')
+        .option('--requested-env <list>', 'CSV env vars for plugin plan/apply_sandbox')
+        .option('--network-domains <list>', 'CSV domains for plugin plan/apply_sandbox')
+        .option('--process-spawn-requested', 'Whether plugin plan/apply_sandbox requests process spawn')
+        .option('--strict', 'Strict mode for codesdd.check and codesdd.diagnose')
+        .option('--doc <doc>', 'Workspace doc for codesdd.read: spec|plan|tasks|changelog|quality|all')
+        .option('--query <query>', 'Search expression for codesdd.query')
+        .option('--scope <scope>', 'Search scope for codesdd.query: backlog|discovery|all')
+        .option('--rank <rank>', 'Ranking for codesdd.next: impact|criticality|fifo')
+        .option('--limit <n>', 'Limit for codesdd.next')
+        .option('--max-agents <n>', 'Max agents for codesdd.next wave simulation')
+        .option('--ids <list>', 'CSV skill IDs for codesdd.skill_prompt')
+        .option('--phase <phase>', 'Phase for codesdd.skill_prompt')
+        .option('--domains <list>', 'CSV domains for codesdd.skill_prompt')
+        .option('--bundles <list>', 'CSV bundles for codesdd.skill_prompt')
+        .option('--max <n>', 'Max suggested skills for codesdd.skill_prompt')
+        .option('--objective <text>', 'Objective text for codesdd.skill_prompt')
         .option('--json', 'JSON output')
         .action(async (tool, options) => {
         const root = resolveRoot();
@@ -57,30 +230,185 @@ export function registerExecutionCommands(sddCmd) {
             tool: tool,
             args: {
                 ref: options?.ref,
+                refOrText: options?.refOrText,
+                featureId: options?.featureId,
+                status: options?.status,
+                reason: options?.reason,
+                routes: parseCsvOption(options?.routes),
+                surfaces: parseCsvOption(options?.surfaces),
+                manifestPath: options?.manifestPath,
+                featureRef: options?.featureRef,
+                capability: options?.capability,
+                skillRef: options?.skillRef,
+                inputs: parseJsonObjectOption(options?.input),
+                writeScope: parseCsvOption(options?.writeScope),
+                approvalGrants: parseCsvOption(options?.approvalGrants),
+                plannedWrites: parseCsvOption(options?.plannedWrites),
+                requestedEnv: parseCsvOption(options?.requestedEnv),
+                networkDomains: parseCsvOption(options?.networkDomains),
+                processSpawnRequested: options?.processSpawnRequested,
+                strict: options?.strict,
+                doc: options?.doc,
+                query: options?.query,
+                scope: options?.scope,
                 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(),
+                ids: parseCsvOption(options?.ids),
+                phase: options?.phase,
+                domains: parseCsvOption(options?.domains),
+                bundles: parseCsvOption(options?.bundles),
+                max: options?.max ? Number.parseInt(options.max, 10) : undefined,
+                objective: options?.objective,
             },
         });
         if (options?.json) {
             console.log(JSON.stringify(response, null, 2));
             return;
         }
-        console.log(chalk.green(`OpenSDD MCP call completed: ${response.tool}`));
+        console.log(chalk.green(`CodeSDD 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('preflight <featureId>')
+        .description('Run governed mutation preflight without invoking an agent runtime')
+        .option('--objective <text>', 'Natural-language objective for semantic intent checks')
+        .option('--intent-operation <operation>', 'Explicit modification intent: add|modify|remove|replace|refactor|optimize')
+        .option('--write-scope <list>', 'CSV project-relative write scopes allowed for the runtime')
+        .option('--planned-writes <list>', 'CSV project-relative files the runtime plans to write')
+        .option('--allowed-paths <list>', 'CSV context-lock allowed project paths')
+        .option('--forbidden-paths <list>', 'CSV context-lock forbidden project paths')
+        .option('--protected-core <list>', 'CSV protected project paths requiring explicit override')
+        .option('--max-files-changed <count>', 'Change budget limit for changed paths')
+        .option('--max-new-files <count>', 'Change budget limit for new files')
+        .option('--max-deleted-files <count>', 'Change budget limit for deleted files')
+        .option('--governed-override <json>', 'JSON governed override contract for protected or replacement changes')
+        .option('--lifecycle <name>', 'Lifecycle context: start|finalize|execute-next|custom', 'custom')
+        .option('--json', 'JSON output')
+        .action(async (featureId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        if (options.lifecycle && !['start', 'finalize', 'execute-next', 'custom'].includes(options.lifecycle)) {
+            throw new Error('Valor invalido em --lifecycle. Use start, finalize, execute-next ou custom.');
+        }
+        const result = await new DeepAgentsRunService().execute(featureId, buildPreflightRequest(options), { projectRoot: root, stores, skipRuntime: true });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            if (result.status === 'blocked') {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        if (result.status === 'allowed') {
+            console.log(chalk.green(`CodeSDD preflight: ${result.status}`));
+        }
+        else {
+            console.log(chalk.red(`CodeSDD preflight: ${result.status}`));
+        }
+        console.log(`Feature: ${result.feature_id}`);
+        console.log(`Mode: ${result.mode}`);
+        console.log(`Runtime skipped: ${result.evidence.runtime_skipped ? 'yes' : 'no'}`);
+        console.log(`Evidence run id: ${result.evidence.run_id}`);
+        if (result.reasons.length > 0) {
+            console.log(`Reasons: ${result.reasons.join(' | ')}`);
+        }
+        if (result.status === 'blocked') {
+            process.exitCode = 1;
+        }
+    });
+    const agentCmd = sddCmd
+        .command('agent')
+        .description('Governed agent execution commands for external providers');
+    agentCmd
+        .command('run <featureId>')
+        .description('Run DeepAgents mode policy gate with fail-closed enforcement')
+        .requiredOption('--provider <provider>', 'Execution provider (FEAT-0243 accepts only deepagents)')
+        .option('--mode <mode>', 'Execution mode: read-only|plan|validate|apply-sandbox|apply-approved')
+        .option('--objective <text>', 'Natural-language objective for semantic intent checks')
+        .option('--plugin-execution-path <path>', 'Plugin execution path: broker|direct', 'broker')
+        .option('--plugin-flow <list>', 'CSV plugin broker/evidence checkpoints for mutation modes')
+        .option('--operations <list>', 'CSV runtime operations requested by this run: read|write|execute|network|plugin-apply|finalize|dependency-change|process-spawn')
+        .option('--write-scope <list>', 'CSV project-relative write scopes allowed for the runtime')
+        .option('--planned-writes <list>', 'CSV project-relative files the runtime plans to write')
+        .option('--intent-operation <operation>', 'Explicit modification intent: add|modify|remove|replace|refactor|optimize')
+        .option('--allowed-paths <list>', 'CSV context-lock allowed project paths')
+        .option('--forbidden-paths <list>', 'CSV context-lock forbidden project paths')
+        .option('--protected-core <list>', 'CSV protected project paths requiring explicit override')
+        .option('--max-files-changed <count>', 'Change budget limit for changed paths')
+        .option('--max-new-files <count>', 'Change budget limit for new files')
+        .option('--max-deleted-files <count>', 'Change budget limit for deleted files')
+        .option('--governed-override <json>', 'JSON governed override contract for protected or replacement changes')
+        .option('--requested-env <list>', 'CSV environment variables requested for runtime passthrough')
+        .option('--network-domains <list>', 'CSV network domains requested by this run')
+        .option('--approval-grants <list>', 'CSV HITL approval grants: operation names or all')
+        .option('--json', 'JSON output')
+        .action(async (featureId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        void stores;
+        await ensureMandatorySddMigration(root);
+        const command = new DeepAgentsRunService();
+        const result = await command.execute(featureId, {
+            provider: options.provider,
+            mode: options.mode,
+            objective: options.objective,
+            plugin_execution_path: options.pluginExecutionPath,
+            plugin_flow: parseCsvOption(options.pluginFlow),
+            operations: parseCsvOption(options.operations),
+            write_scope: parseCsvOption(options.writeScope),
+            planned_writes: parseCsvOption(options.plannedWrites),
+            change_safety: buildChangeSafetyFromOptions(options),
+            requested_env: parseCsvOption(options.requestedEnv),
+            network_domains: parseCsvOption(options.networkDomains),
+            approval_grants: parseCsvOption(options.approvalGrants),
+        }, { projectRoot: root, stores });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            if (result.status === 'blocked') {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        if (result.status === 'allowed') {
+            console.log(chalk.green(`DeepAgents run policy: ${result.status}`));
+        }
+        else {
+            console.log(chalk.red(`DeepAgents run policy: ${result.status}`));
+        }
+        console.log(`Feature: ${result.feature_id}`);
+        console.log(`Provider: ${result.provider}`);
+        console.log(`Mode: ${result.mode}`);
+        console.log(`Fail-closed: ${result.fail_closed ? 'yes' : 'no'}`);
+        console.log(`Direct .sdd/state writes: ${result.evidence.direct_state_write_allowed ? 'allowed' : 'blocked'}`);
+        console.log(`Plugin execution path: ${result.evidence.plugin_execution.requested_path}`);
+        if (result.evidence.runtime) {
+            console.log(`Runtime: ${result.evidence.runtime.adapter.runtime}`);
+            console.log(`Runtime status: ${result.evidence.runtime.adapter.status}`);
+        }
+        if (result.evidence.plugin_execution.missing_flow.length > 0) {
+            console.log(`Missing plugin flow: ${result.evidence.plugin_execution.missing_flow.join(', ')}`);
+        }
+        console.log(`Evidence run id: ${result.evidence.run_id}`);
+        if (result.reasons.length > 0) {
+            console.log(`Reasons: ${result.reasons.join(' | ')}`);
+        }
+        if (result.status === 'blocked') {
+            process.exitCode = 1;
+        }
+    });
     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('--schema <schema>', 'Schema para criar change de compatibilidade em legacy-spec/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')
@@ -192,6 +520,12 @@ export function registerExecutionCommands(sddCmd) {
         }
         console.log(`Liberadas: ${result.unblocked.join(', ') || '-'}`);
         console.log(`Pendentes na fila: ${result.pending}`);
+        if (result.post_finalize_replan?.ready?.length) {
+            console.log(`Proximas FEATs: ${result.post_finalize_replan.ready
+                .slice(0, 5)
+                .map((entry) => entry.id)
+                .join(', ')}`);
+        }
         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'}`);
@@ -211,6 +545,9 @@ export function registerExecutionCommands(sddCmd) {
         .command('context <ref>')
         .description('Gera contexto objetivo para FEAT/EPIC/FGAP/TD (RAD legado ainda aceito)')
         .alias('contexto')
+        .option('--budget <mode>', 'Modo de orcamento do pacote de contexto: compact, standard ou full', 'standard')
+        .option('--compact', 'Atalho para --budget compact')
+        .option('--full', 'Atalho para --budget full')
         .option('--json', 'Saida em JSON')
         .action(async (ref, options) => {
         const root = resolveRoot();
@@ -219,28 +556,47 @@ export function registerExecutionCommands(sddCmd) {
         const stores = createSddStores(__paths);
         await ensureMandatorySddMigration(root);
         const command = new ContextService(stores);
-        const context = await command.execute(root, ref);
+        const budgetMode = resolveContextBudgetModeOption(options);
+        const context = await command.execute(root, ref, { budgetMode });
         if (options?.json) {
             console.log(JSON.stringify(context, null, 2));
             return;
         }
+        const contextRecord = context;
         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(`Budget: ${context.context_budget.mode} (${context.context_budget.estimated_chars_after_budget} chars)`);
+        if (context.context_budget.deduped_fields?.length) {
+            const removed = context.context_budget.deduped_fields.reduce((sum, field) => sum + field.removed, 0);
+            console.log(`Dedupe: ${removed} entradas removidas`);
+        }
+        if (contextRecord.progressive_disclosure) {
+            const disclosure = contextRecord.progressive_disclosure;
+            const omitted = disclosure.omitted_fields
+                .map((field) => `${field.field}:${field.omitted_count}`)
+                .join(', ');
+            console.log(`Disclosure: ${omitted || '-'} | ${disclosure.reveal_command}`);
+        }
+        if (contextRecord.context_cache) {
+            const cache = contextRecord.context_cache;
+            console.log(`Cache: ${cache.hit ? 'hit' : 'miss'} (${cache.key})`);
+        }
+        const coreDocs = Array.isArray(contextRecord.core_docs) ? contextRecord.core_docs : [];
+        console.log(`Core docs: ${coreDocs.join(', ')}`);
+        if (contextRecord.origin) {
+            const origin = contextRecord.origin;
             console.log(`Origem: ${origin.type}${origin.ref ? ` (${origin.ref})` : ''}`);
         }
-        if (context.related_features) {
-            const refs = context.related_features;
+        if (contextRecord.related_features) {
+            const refs = contextRecord.related_features;
             console.log(`Features relacionadas: ${refs.join(', ') || '-'}`);
         }
-        if (context.recommended_skills) {
-            const skills = context.recommended_skills;
+        if (contextRecord.recommended_skills) {
+            const skills = contextRecord.recommended_skills;
             console.log(`Skills sugeridas: ${skills.join(', ') || '-'}`);
         }
-        if (context.skill_execution_contract) {
-            const skillContract = context.skill_execution_contract;
+        if (contextRecord.skill_execution_contract) {
+            const skillContract = contextRecord.skill_execution_contract;
             if (skillContract.required) {
                 console.log(`Evidencia de skill: ${skillContract.required_skill_ids.join(', ')} -> ${skillContract.verification_location}`);
             }
@@ -262,6 +618,9 @@ export function registerExecutionCommands(sddCmd) {
         .option('--compact', 'Retorna payload resumido')
         .option('--full', 'Retorna payload completo em JSON (desativa modo compacto automatico)')
         .action(async (target = 'system', options) => {
+        if (options?.compact && options?.full) {
+            throw new Error("Options '--compact' and '--full' are mutually exclusive. Choose one.");
+        }
         const root = resolveRoot();
         const __config = await loadProjectSddConfig(root);
         const __paths = resolveSddPaths(root, __config);
@@ -373,6 +732,108 @@ export function registerExecutionCommands(sddCmd) {
             }
         }
     });
+    sddCmd
+        .command('plan-status [path]')
+        .description('Mostra status operacional do plano CodeSDD e a proxima acao recomendada')
+        .alias('status-plano')
+        .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 result = await buildPlanStatus(root, stores, options);
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green('Status do plano CodeSDD'));
+        console.log(`Ativas: ${result.active.length}`);
+        for (const item of result.active) {
+            console.log(`- ${item.id}: ${item.title} | etapa=${item.current_stage} | frontend=${item.frontend_impact_status}`);
+        }
+        console.log(`Prontas: ${result.next.ready.length}`);
+        if (result.next.ready[0]) {
+            const first = result.next.ready[0];
+            console.log(`Proxima recomendada: ${first.id}: ${first.title}`);
+        }
+        console.log(`Bloqueadas: ${result.next.blocked.length}`);
+        console.log(`Conflitos de lock: ${result.next.conflicts.length}`);
+        console.log(`Acao recomendada: ${result.recommended_action}`);
+    });
+    sddCmd
+        .command('execute-next [path]')
+        .description('Inicia a proxima FEAT pronta pelo ranking CodeSDD')
+        .alias('executar-proxima')
+        .option('--rank <mode>', 'Ranking: impact|criticality|fifo (padrao: impact)')
+        .option('--limit <n>', 'Limite de itens prontos avaliados (padrao: 10)')
+        .option('--max-agents <n>', 'Limite de itens por onda (padrao: sem limite)')
+        .option('--dry-run', 'Mostra qual FEAT seria iniciada sem alterar estado')
+        .option('--force', 'Bypass de bloqueios e conflitos de lock no start')
+        .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', 'Saida em JSON')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .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 next = await new NextService(stores).execute(root, {
+            rank: options?.rank,
+            limit: parsePositiveNumberOption(options?.limit, '--limit'),
+            maxAgents: parsePositiveNumberOption(options?.maxAgents, '--max-agents'),
+        });
+        const selected = next.ready[0];
+        if (!selected) {
+            const result = { schema_version: 1, started: false, dry_run: !!options?.dryRun, selected: null, next };
+            if (options?.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log('Nenhuma FEAT pronta para iniciar.');
+            }
+            return;
+        }
+        if (options?.dryRun) {
+            const result = { schema_version: 1, started: false, dry_run: true, selected, next };
+            if (options?.json) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(`Proxima FEAT: ${selected.id}: ${selected.title}`);
+            console.log(`Comando: codesdd sdd start ${selected.id}`);
+            return;
+        }
+        const flow = parseFlowModeOption(options?.flowMode || options?.fluxo);
+        const startResult = await new StartService(stores).execute(root, selected.id, {
+            force: options?.force,
+            forceTransition: options?.forceTransition,
+            flowMode: flow,
+            render: options?.render,
+        });
+        const result = { schema_version: 1, started: true, dry_run: false, selected, start: startResult, next };
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(`Proxima FEAT iniciada: ${startResult.featureId}`));
+        console.log(`Titulo: ${selected.title}`);
+        console.log(`Workspace ativo: ${startResult.active_path}`);
+        console.log(`Proximo passo: codesdd sdd context ${startResult.featureId} --compact`);
+    });
     sddCmd
         .command('audit [path]')
         .description('Audita a saude de meta-evolucao do SDD (placeholders, deliberacao, ADR e forced transition)')

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

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