@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/commands/sdd/execution.js

@@ -1,27 +1,168 @@
 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 { PlanningExecutionCoherenceService } from '../../core/sdd/services/planning-execution-coherence.service.js';
+import { HistoricalQualityRegressionService } from '../../core/sdd/services/historical-quality-regression.service.js';
 import { McpRuntimeService } from '../../core/sdd/services/mcp-runtime.service.js';
-import { DeepAgentsRunService } from '../../core/sdd/services/agent-run.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';
-function parseJsonObjectOption(value) {
+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('--input must be a JSON object.');
+        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 handoff sections 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 CodeSDD execution tools')
@@ -132,6 +273,56 @@ export function registerExecutionCommands(sddCmd) {
         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');
@@ -140,11 +331,20 @@ export function registerExecutionCommands(sddCmd) {
         .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')
@@ -160,11 +360,13 @@ export function registerExecutionCommands(sddCmd) {
         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),
@@ -320,6 +522,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'}`);
@@ -339,6 +547,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();
@@ -347,28 +558,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}`);
             }
@@ -504,10 +734,157 @@ 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('historical-quality-regression [path]')
+        .description('Escaneia regressao historica de qualidade em modo CI (janela recente) ou revisao completa')
+        .alias('qualidade-regressao-historica')
+        .option('--mode <mode>', 'Modo: recent-window|full-history (padrao: recent-window)', 'recent-window')
+        .option('--window <n>', 'Quantidade de FEATs mais recentes no modo recent-window (padrao: 25)')
+        .option('--grandfather-max-feat <n>', 'Limite numerico de grandfathering (padrao: FEAT-0451)')
+        .option('--strict', 'Retorna exit code 1 quando regressao e detectada')
+        .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?.mode && !['recent-window', 'full-history'].includes(options.mode)) {
+            throw new Error('Valor invalido em --mode. Use recent-window ou full-history.');
+        }
+        const command = new HistoricalQualityRegressionService();
+        const report = await command.execute(root, {
+            mode: options?.mode,
+            recentWindowSize: parsePositiveNumberOption(options?.window, '--window'),
+            grandfatherMaxFeat: parseNonNegativeNumberOption(options?.grandfatherMaxFeat, '--grandfather-max-feat'),
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(chalk.green('Scanner historico de regressao de qualidade'));
+            console.log(`Modo: ${report.mode}`);
+            console.log(`Escopo: scanned=${report.scanned} considered=${report.considered} analyzed=${report.analyzed}`);
+            console.log(`Grandfathering: <= FEAT-${String(report.grandfathering.max_feat_id).padStart(4, '0')} (skipped=${report.grandfathered})`);
+            console.log(`Regressoes: ${report.issue_count}`);
+            if (report.issues.length > 0) {
+                for (const issue of report.issues) {
+                    console.log(`- ${issue.feature_id} [${issue.code}] ${issue.message}`);
+                }
+            }
+        }
+        if (options?.strict && report.issue_count > 0) {
+            process.exitCode = 1;
+        }
+    });
     sddCmd
         .command('audit [path]')
         .description('Audita a saude de meta-evolucao do SDD (placeholders, deliberacao, ADR e forced transition)')
         .alias('auditar')
+        .option('--feature <featId>', 'Executa auditoria de coerencia planejamento-execucao para uma FEAT')
+        .option('--strict', 'Retorna exit code 1 quando a auditoria de coerencia encontra erro')
         .option('--json', 'Saida em JSON')
         .action(async (targetPath = '.', options) => {
         const root = resolveRoot(targetPath);
@@ -517,8 +894,14 @@ export function registerExecutionCommands(sddCmd) {
         await ensureMandatorySddMigration(root);
         const command = new AuditService(stores);
         const result = await command.execute(root);
+        const coherence = options?.feature
+            ? await new PlanningExecutionCoherenceService().execute(root, options.feature)
+            : null;
         if (options?.json) {
-            console.log(JSON.stringify(result, null, 2));
+            console.log(JSON.stringify({ ...result, planning_execution_coherence: coherence }, null, 2));
+            if (options?.strict && coherence && !coherence.healthy) {
+                process.exitCode = 1;
+            }
             return;
         }
         console.log(chalk.green('Auditoria SDD concluida.'));
@@ -534,7 +917,16 @@ export function registerExecutionCommands(sddCmd) {
         if (result.metrics.forced_transitions.feature_refs.length > 0) {
             console.log(`Features com evidencias: ${result.metrics.forced_transitions.feature_refs.join(', ')}`);
         }
+        if (coherence) {
+            console.log(`Coerencia planejamento-execucao (${coherence.feature_id}): ${coherence.healthy ? 'OK' : 'ALERTA'}`);
+            if (coherence.issues.length > 0) {
+                console.log(`Issues: ${coherence.issues.map((issue) => `${issue.code}:${issue.severity}`).join(', ')}`);
+            }
+        }
         console.log(result.recommendation);
+        if (options?.strict && coherence && !coherence.healthy) {
+            process.exitCode = 1;
+        }
     });
 }
 //# sourceMappingURL=execution.js.map

package/dist/commands/sdd/plugin.js

@@ -32,6 +32,7 @@ export function registerPluginCommands(sddCmd) {
         .option('--env <list>', 'Comma-separated requested environment variables')
         .option('--network-domains <list>', 'Comma-separated requested network domains')
         .option('--process-spawn', 'Declare that the operation requests process spawning')
+        .option('--project-root <path>', 'Project root used for standalone storage-boundary validation')
         .option('--language <language>', 'Technology language constraint')
         .option('--framework <framework>', 'Technology framework constraint')
         .option('--json', 'Return invocation plan as JSON')
@@ -50,6 +51,7 @@ export function registerPluginCommands(sddCmd) {
             requested_env: parseCsvOption(options.env),
             network_domains: parseCsvOption(options.networkDomains),
             process_spawn_requested: options.processSpawn ?? false,
+            project_root: options.projectRoot,
             technology: resolveTechnologyConstraint(options),
         });
         if (options.json) {
@@ -124,6 +126,9 @@ function printPlanResult(result) {
     console.log(chalk.green(`Plugin plan: ${plan.status}`));
     console.log(`Manifest: ${result.manifest_path}`);
     console.log(`Policy: ${plan.policy?.decision ?? 'not-evaluated'}`);
+    console.log(`Standalone runner: ${result.workcell_runner.standalone.status}`);
+    console.log(`Package governance: ${result.workcell_runner.standalone.package_governance.status}`);
+    console.log(`Storage boundary: ${result.workcell_runner.standalone.storage_boundary.status}`);
     if (plan.envelope) {
         console.log(`Operation: ${plan.envelope.operation_id}`);
         console.log(`Plugin: ${plan.envelope.plugin_ref.id}@${plan.envelope.plugin_ref.version}`);

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

@@ -2,6 +2,7 @@ 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 resolveInitRoot(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;

package/dist/commands/sdd/shared.js

@@ -1,4 +1,5 @@
 import { promises as fs } from 'node:fs';
+import path from 'node:path';
 import { resolveProjectRoot } from '../../core/sdd/resolve-project-root.js';
 import { loadProjectSddConfig, resolveSddPaths, } from '../../core/sdd/state.js';
 import { assessSddMigration } from '../../core/sdd/migrate.js';
@@ -13,6 +14,15 @@ export function parseCsvOption(value) {
 export function resolveRoot(targetPath = '.') {
     return resolveProjectRoot(targetPath === '.' ? undefined : targetPath);
 }
+export function resolveInitRoot(targetPath = '.') {
+    const absoluteTarget = path.resolve(targetPath);
+    const segments = absoluteTarget.split(path.sep);
+    const sddIndex = segments.lastIndexOf('.sdd');
+    if (sddIndex >= 0) {
+        return segments.slice(0, sddIndex).join(path.sep) || path.parse(absoluteTarget).root;
+    }
+    return absoluteTarget;
+}
 export function parseLangOption(value) {
     if (!value)
         return undefined;