@devtrack-solution/codesdd 1.2.3 → 1.2.4-rc3

package/dist/commands/sdd/execution.js

@@ -1,27 +1,166 @@
 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 { 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 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 CodeSDD execution tools')
@@ -132,6 +271,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 +329,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 +358,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 +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'}`);
@@ -339,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();
@@ -347,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}`);
             }
@@ -504,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.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;

package/dist/commands/sdd.js

@@ -23,8 +23,9 @@ import { SddRebuildService, formatSddRebuildReport } from "../core/sdd/services/
 import { SddMetricsService, formatSddMetricsReport } from "../core/sdd/services/metrics.service.js";
 import { FeatureLintService, formatFeatureLintReport } from "../core/sdd/services/feature-lint.service.js";
 import { SddDedupApplyService, formatSddDedupApplyReport } from "../core/sdd/services/dedup-apply.service.js";
+import { evaluateSddIntentGuard } from '../core/sdd/intent-guard.js';
 import { captureFingerprintsForChange, writeMeta } from '../core/sdd/fingerprint.js';
-import { ensureMandatorySddMigration, parseCsvOption, parseFlowModeOption, parseLangOption, parseLayoutOption, resolveRoot, } from './sdd/shared.js';
+import { ensureMandatorySddMigration, parseCsvOption, parseFlowModeOption, parseLangOption, parseLayoutOption, resolveInitRoot, resolveRoot, } from './sdd/shared.js';
 import { registerExecutionCommands } from './sdd/execution.js';
 import { registerPluginCommands } from './sdd/plugin.js';
 import { registerSkillsCommands } from './sdd/skills.js';
@@ -32,6 +33,40 @@ import { registerBacklogCommands } from './sdd/backlog.js';
 import { displayLegacySpecPath, resolveLegacySpecSubpath, } from '../core/sdd/services/legacy-capability.service.js';
 export function registerSddCommand(program) {
     const sddCmd = program.command('sdd').description('SDD memory operations');
+    sddCmd
+        .command('intent-guard')
+        .description('Classifica uma solicitacao e informa quando o fluxo CodeSDD e obrigatorio')
+        .alias('guarda-intencao')
+        .requiredOption('--request <text>', 'Texto da solicitacao do usuario/agente')
+        .option('--feat <FEAT-ID>', 'FEAT ja selecionada para o contexto CodeSDD')
+        .option('--strict', 'Retorna exit code 2 quando a solicitacao exige CodeSDD e nenhuma FEAT foi informada')
+        .option('--json', 'Saida em JSON')
+        .action((options) => {
+        const result = evaluateSddIntentGuard({
+            request: options?.request ?? '',
+            featureRef: options?.feat,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Classificacao: ${result.classification}`);
+            console.log(`Requer CodeSDD: ${result.requires_codesdd_planning ? 'sim' : 'nao'}`);
+            console.log(`Motivo: ${result.reason}`);
+            if (result.required_commands.length > 0) {
+                console.log('Comandos obrigatorios:');
+                for (const command of result.required_commands) {
+                    console.log(`- ${command}`);
+                }
+            }
+            for (const warning of result.warnings) {
+                console.log(chalk.yellow(`Aviso: ${warning}`));
+            }
+        }
+        if (options?.strict && result.requires_codesdd_planning && !result.feature_ref) {
+            process.exitCode = 2;
+        }
+    });
     sddCmd
         .command('init [path]')
         .description('Initializes the .sdd structure and base state files')
@@ -41,7 +76,7 @@ export function registerSddCommand(program) {
         .option('--layout <layout>', 'Folder layout: en-US|legacy|pt-BR')
         .option('--no-render', 'Does not generate Markdown views after initialization')
         .action(async (targetPath = '.', options) => {
-        const root = resolveRoot(targetPath);
+        const root = resolveInitRoot(targetPath);
         const __config = await loadProjectSddConfig(root);
         const __paths = resolveSddPaths(root, __config);
         const stores = createSddStores(__paths);
@@ -378,7 +413,7 @@ export function registerSddCommand(program) {
             console.log(`Registros de discovery: ${report.summary.discovery}`);
             console.log(`Itens de backlog: ${report.summary.backlog}`);
             console.log(`Itens de divida tecnica: ${report.summary.techDebt}`);
-            console.log(`Itens na fila de finalize: ${report.summary.finalizeQueue}`);
+            console.log(`Registros de finalize: ${report.summary.finalizeQueue} (pendentes: ${report.summary.finalizeQueuePending}; concluidos: ${report.summary.finalizeQueueDone})`);
             console.log(`Frontend ativado: ${report.summary.frontendEnabled ? 'sim' : 'nao'}`);
             console.log(`Progresso global: ${report.summary.progress_global.percent}% (${report.summary.progress_global.done}/${report.summary.progress_global.total})`);
             console.log(`Prontas para paralelo: ${report.summary.ready_for_parallel}`);

package/dist/core/cli/command-matrix.js

@@ -46,12 +46,17 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'config:reset', strategy: 'contract', rationale: 'Reset behavior is deterministic once prompts are bypassed in tests.' },
     { commandPath: 'config:edit', strategy: 'exception', rationale: 'This command delegates to an external editor process and only needs focused environment-sensitive coverage.' },
     { commandPath: 'config:profile', strategy: 'contract', rationale: 'Profile inspection is scriptable and deterministic.' },
+    { commandPath: 'config:redis:status', strategy: 'contract', rationale: 'Redis status reports the governed runtime backend without exposing secrets.' },
+    { commandPath: 'config:redis:ping', strategy: 'contract', rationale: 'Redis ping is a deterministic readiness contract with mocked and unavailable paths.' },
+    { commandPath: 'config:redis:bench', strategy: 'contract', rationale: 'Redis benchmark output is bounded, redacted, and suitable for direct contract assertions.' },
+    { commandPath: 'config:redis:flush-namespace', strategy: 'contract', rationale: 'Redis namespace cleanup is explicitly scoped and guarded by confirmation.' },
     { commandPath: 'schema:which', strategy: 'contract', rationale: 'Schema resolution is deterministic with fixture directories.' },
     { commandPath: 'schema:validate', strategy: 'contract', rationale: 'Schema validation produces deterministic reports from fixture inputs.' },
     { commandPath: 'schema:fork', strategy: 'contract', rationale: 'Schema fork output is a filesystem contract that can be asserted directly.' },
     { commandPath: 'schema:init', strategy: 'contract', rationale: 'Schema initialization is deterministic over temporary workspaces.' },
     { commandPath: 'sdd:init', strategy: 'spawned-e2e', rationale: 'SDD init seeds canonical state and generated views, so it should keep lifecycle smoke coverage.' },
     { commandPath: 'sdd:init-context', strategy: 'spawned-e2e', rationale: 'Context bootstrap reads repository structure and writes canonical state, which benefits from spawned smoke coverage.' },
+    { commandPath: 'sdd:intent-guard', strategy: 'contract', rationale: 'Intent guard classification is deterministic and should stay covered with direct contract tests.' },
     { commandPath: 'sdd:fingerprint', strategy: 'contract', rationale: 'Fingerprint backfill is a deterministic batch operation over change fixtures.' },
     { commandPath: 'sdd:insight', strategy: 'spawned-e2e', rationale: 'Insight creation is the first discovery lifecycle write and should stay covered in spawned flow tests.' },
     { commandPath: 'sdd:ingest-deposito', strategy: 'spawned-e2e', rationale: 'Ingestion coordinates discovery inputs, indexing, and trail generation across filesystem boundaries.' },
@@ -60,7 +65,9 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'sdd:breakdown', strategy: 'spawned-e2e', rationale: 'Breakdown materializes executable FEAT workspaces and needs lifecycle smoke coverage.' },
     { commandPath: 'sdd:mcp-manifest', strategy: 'contract', rationale: 'Manifest rendering is deterministic and provider-profile driven.' },
     { commandPath: 'sdd:mcp-call', strategy: 'contract', rationale: 'The MCP bridge reuses canonical services and is best guarded with direct contract assertions.' },
+    { commandPath: 'sdd:preflight', strategy: 'contract', rationale: 'Preflight reuses deterministic mutation guardrails without invoking agent runtime.' },
     { commandPath: 'sdd:agent:run', strategy: 'contract', rationale: 'DeepAgents run gating is a deterministic fail-closed policy contract with no direct state writes.' },
+    { commandPath: 'sdd:release-readiness', strategy: 'contract', rationale: 'Release readiness aggregates static gates and CI parity commands without publishing or mutating release state.' },
     { commandPath: 'sdd:start', strategy: 'spawned-e2e', rationale: 'Start transitions planned work into active execution and is a core lifecycle boundary.' },
     { commandPath: 'sdd:frontend-impact', strategy: 'spawned-e2e', rationale: 'Frontend impact is a required lifecycle declaration that should remain part of spawned finalize-path smoke.' },
     { commandPath: 'sdd:finalize', strategy: 'spawned-e2e', rationale: 'Finalize is the highest-risk lifecycle transition and must keep spawned smoke coverage.' },
@@ -68,6 +75,8 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'sdd:onboard', strategy: 'contract', rationale: 'Onboard is a read-oriented guidance surface with deterministic ranking output.' },
     { commandPath: 'sdd:aprovar', strategy: 'contract', rationale: 'Approval transitions are deterministic and fit fixture-driven lifecycle assertions.' },
     { commandPath: 'sdd:next', strategy: 'contract', rationale: 'Next is ranking logic over canonical state and is naturally contract-testable.' },
+    { commandPath: 'sdd:plan-status', strategy: 'contract', rationale: 'Plan status aggregates active and ready work without mutating state.' },
+    { commandPath: 'sdd:execute-next', strategy: 'spawned-e2e', rationale: 'Execute next bridges ranking into start and must preserve lifecycle guardrails.' },
     { commandPath: 'sdd:audit', strategy: 'contract', rationale: 'Audit is a deterministic report over canonical state.' },
     { commandPath: 'sdd:plugin:inspect', strategy: 'contract', rationale: 'Plugin inspect is a read-only manifest parser surface.' },
     { commandPath: 'sdd:plugin:plan', strategy: 'contract', rationale: 'Plugin plan builds a non-executing runtime envelope from a manifest fixture.' },

package/dist/core/cli-command-quality.js

@@ -43,6 +43,7 @@ export const CLI_COMMAND_QUALITY_MATRIX = [
         'sdd aprovar',
         'sdd start',
         'sdd context',
+        'sdd execute-next',
         'sdd frontend-impact',
         'sdd finalize',
         'sdd init-context',
@@ -69,6 +70,10 @@ export const CLI_COMMAND_QUALITY_MATRIX = [
         'config init',
         'config list',
         'config path',
+        'config redis bench',
+        'config redis flush-namespace',
+        'config redis ping',
+        'config redis status',
         'config reset',
         'config set',
         'config unset',
@@ -107,6 +112,10 @@ export const CLI_COMMAND_QUALITY_MATRIX = [
         'sdd migrate-workspace',
         'sdd next',
         'sdd onboard',
+        'sdd plan-status',
+        'sdd preflight',
+        'sdd release-readiness',
+        'sdd intent-guard',
         'sdd backlog project',
         'sdd plugin devtrack-api scaffold-dry-run',
         'sdd plugin inspect',