@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/commands/sdd.js

@@ -23,8 +23,10 @@ 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 { REVERSA_AUTHORIZATION_SCOPES, REVERSA_BACKEND_CONTRACT_MODES, REVERSA_COMMANDS, REVERSA_MODES, REVERSA_PRESERVATION_CHOICES, REVERSA_TARGET_STACKS, REVERSA_URL_MODES, REVERSA_VOLUME_PRESETS, buildReversaCommandPlan, } from '../core/sdd/reversa-command-policy.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 +34,135 @@ 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('reversa <command> [target]')
+        .description('Planeja a superficie Reversa com politica governada e fail-closed')
+        .option('--mode <mode>', `Modo Reversa: ${REVERSA_MODES.join('|')} (padrao: read-only); para url aceita tambem ${REVERSA_URL_MODES.join('|')}`)
+        .option('--execution-mode <mode>', `Modo de execucao Reversa: ${REVERSA_MODES.join('|')}`)
+        .option('--url-mode <mode>', `Modo URL: ${REVERSA_URL_MODES.join('|')}`)
+        .option('--feature <FEAT-ID>', 'FEAT que recebera evidencias Reversa')
+        .option('--source <path>', 'Fonte legada ou diretorio alvo a inspecionar')
+        .option('--approval <list>', 'Aprovacoes separadas por virgula para modos apply')
+        .option('--accept-legal-terms', 'Aceita os termos legais obrigatorios para Reversa URL')
+        .option('--authorization-scope <scope>', `Escopo de autorizacao URL: ${REVERSA_AUTHORIZATION_SCOPES.join('|')}`)
+        .option('--authorization-note <note>', 'Referencia auditavel de autorizacao, contrato, ticket ou ordem')
+        .option('--volume-preset <preset>', `Preset de volumetria URL: ${REVERSA_VOLUME_PRESETS.join('|')}`)
+        .option('--volume-budget <file>', 'Arquivo de budget customizado para volumetria URL')
+        .option('--approve-volume-budget', 'Confirma que o budget customizado foi validado por schema e aprovado por humano')
+        .option('--target-stack <stack>', `Stack alvo URL: ${REVERSA_TARGET_STACKS.join('|')}`)
+        .option('--preserve-brand <decision>', `Decisao de marca: ${REVERSA_PRESERVATION_CHOICES.join('|')}`)
+        .option('--preserve-logo <decision>', `Decisao de logo: ${REVERSA_PRESERVATION_CHOICES.join('|')}`)
+        .option('--preserve-content <decision>', `Decisao de conteudo: ${REVERSA_PRESERVATION_CHOICES.join('|')}`)
+        .option('--preserve-assets <decision>', `Decisao de assets: ${REVERSA_PRESERVATION_CHOICES.join('|')}`)
+        .option('--preserve-unique-traits <text>', 'Caracteristicas unicas a preservar ou transformar')
+        .option('--backend-contracts <mode>', `Contratos backend observados: ${REVERSA_BACKEND_CONTRACT_MODES.join('|')}`)
+        .option('--backend-redaction-policy <policy>', 'Politica/arquivo de redacao para inventario de contratos backend')
+        .option('--brand-transform <text>', 'Instrucoes de transformacao de marca para derivacao autorizada')
+        .option('--intake <file>', 'Arquivo de intake guiado para execucao nao interativa')
+        .option('--intake-schema-validated', 'Confirma que o arquivo de intake foi validado por schema')
+        .option('--ack-frontend-only', 'Reconhece que a saida Reversa URL e somente frontend renderizado')
+        .option('--json', 'Saida em JSON')
+        .action((command, target, options) => {
+        const plan = buildReversaCommandPlan({
+            command,
+            mode: options?.mode,
+            executionMode: options?.executionMode,
+            target,
+            featureRef: options?.feature,
+            sourcePath: options?.source,
+            approvals: parseCsvOption(options?.approval),
+            urlMode: options?.urlMode,
+            acceptLegalTerms: options?.acceptLegalTerms,
+            authorizationScope: options?.authorizationScope,
+            authorizationNote: options?.authorizationNote,
+            volumePreset: options?.volumePreset,
+            volumeBudgetPath: options?.volumeBudget,
+            volumeBudgetApproved: options?.approveVolumeBudget,
+            targetStack: options?.targetStack,
+            preserveBrand: options?.preserveBrand,
+            preserveLogo: options?.preserveLogo,
+            preserveContent: options?.preserveContent,
+            preserveAssets: options?.preserveAssets,
+            preserveUniqueTraits: options?.preserveUniqueTraits,
+            backendContracts: options?.backendContracts,
+            backendRedactionPolicy: options?.backendRedactionPolicy,
+            brandTransform: options?.brandTransform,
+            intakePath: options?.intake,
+            intakeSchemaValidated: options?.intakeSchemaValidated,
+            acknowledgeFrontendOnly: options?.ackFrontendOnly,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(plan, null, 2));
+        }
+        else {
+            console.log(`Reversa command: ${plan.command}`);
+            console.log(`Mode: ${plan.mode}`);
+            console.log(`Status: ${plan.status}`);
+            console.log(`Evidence: ${plan.evidence_path}`);
+            console.log(`Supported commands: ${REVERSA_COMMANDS.join(', ')}`);
+            if (plan.url_policy) {
+                console.log(`URL mode: ${plan.url_policy.url_mode}`);
+                console.log(`Frontend-only: ${plan.url_policy.frontend_only_boundary ? 'yes' : 'no'}`);
+                console.log(`Backend copied: ${plan.url_policy.backend_implementation_copied ? 'yes' : 'no'}`);
+                console.log(`Volume preset: ${plan.url_policy.volume_preset}`);
+                if (plan.url_policy.required_questions.length > 0) {
+                    console.log('Required guided questions:');
+                    for (const question of plan.url_policy.required_questions) {
+                        console.log(`- ${question}`);
+                    }
+                }
+            }
+            if (plan.required_contracts.length > 0) {
+                console.log('Required contracts:');
+                for (const contract of plan.required_contracts) {
+                    console.log(`- ${contract}`);
+                }
+            }
+            if (plan.warnings.length > 0) {
+                console.log('Warnings:');
+                for (const warning of plan.warnings) {
+                    console.log(chalk.yellow(`- ${warning}`));
+                }
+            }
+        }
+        if (plan.status === 'blocked') {
+            process.exitCode = 2;
+        }
+    });
     sddCmd
         .command('init [path]')
         .description('Initializes the .sdd structure and base state files')
@@ -41,7 +172,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 +509,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}`);
@@ -413,9 +544,28 @@ export function registerSddCommand(program) {
                 }
             }
             if (report.summary.frontendEnabled) {
-                console.log(`Gaps de frontend: ${report.summary.frontendGaps}`);
+                const frontendGapsSummary = report.summary.frontendGapsSummary ?? {
+                    total: report.summary.frontendGaps,
+                    open: report.summary.frontendGaps,
+                    planned: 0,
+                    in_progress: 0,
+                    resolved: 0,
+                    superseded: 0,
+                    unresolved: report.summary.frontendGaps,
+                };
+                console.log(`Gaps de frontend abertos: ${frontendGapsSummary.open}`);
+                console.log(`Gaps de frontend em planejamento/execucao: ${frontendGapsSummary.planned + frontendGapsSummary.in_progress}`);
+                console.log(`Gaps de frontend resolvidos/historicos: ${frontendGapsSummary.resolved + frontendGapsSummary.superseded}`);
+                console.log(`Gaps de frontend total historico: ${frontendGapsSummary.total}`);
                 console.log(`Rotas de frontend: ${report.summary.frontendRoutes}`);
             }
+            if (report.summary.lock_domain_health) {
+                console.log(`Lock domains compartilhados ativos: ${report.summary.lock_domain_health.active_conflicts}`);
+                if (report.summary.lock_domain_health.historical > 0 ||
+                    report.summary.lock_domain_health.mixed_history > 0) {
+                    console.log(`Lock domains compartilhados historicos/mistos: ${report.summary.lock_domain_health.historical + report.summary.lock_domain_health.mixed_history}`);
+                }
+            }
             if (report.warnings.length > 0) {
                 console.log(chalk.yellow('\nAvisos:'));
                 for (const warning of report.warnings) {
@@ -684,14 +834,14 @@ export function registerSddCommand(program) {
     });
     registerSkillsCommands(sddCmd);
     sddCmd
-        .command('diagnose')
+        .command('diagnose [path]')
         .alias('diagnosticar')
         .description('Executa o motor de diagnostico estrutural')
         .option('--strict', 'Falha se houver inconsistencias criticas')
         .option('--json', 'Saida em formato JSON')
         .option('--output <path>', 'Caminho para salvar o relatorio JSON')
-        .action(async (options) => {
-        const root = resolveRoot();
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
         const command = new SddDiagnoseCommand();
         const result = await command.execute(root, {
             strict: options.strict,

package/dist/core/cli/command-matrix.d.ts

@@ -1,5 +1,8 @@
 import type { Command } from 'commander';
 export type CliCoverageStrategy = 'contract' | 'spawned-e2e' | 'exception';
+export type CliPublicCommandClass = 'canonical-lifecycle' | 'bootstrap-repair' | 'compatibility-workflow' | 'migration-tool' | 'diagnostics-governance' | 'experimental-internal';
+export type CliCommandBoundary = 'codesdd-native' | 'compatibility-window' | 'migration-only' | 'internal-hidden';
+export type CliLlmPolicy = 'teach-first' | 'advanced' | 'compatibility-only' | 'migration-only' | 'internal-only';
 export interface CliLeafCommand {
     commandPath: string;
     description: string;
@@ -11,13 +14,28 @@ export interface CliCommandMatrixEntry {
     strategy: CliCoverageStrategy;
     rationale: string;
 }
+export interface CliCommandTaxonomyEntry {
+    commandPath: string;
+    publicClass: CliPublicCommandClass;
+    boundary: CliCommandBoundary;
+    llmPolicy: CliLlmPolicy;
+    rationale: string;
+}
 export interface CliCommandMatrixValidationReport {
     leafCommands: CliLeafCommand[];
     duplicateEntries: string[];
     missingEntries: string[];
     extraEntries: string[];
 }
+export interface CliCommandTaxonomyValidationReport {
+    leafCommands: CliLeafCommand[];
+    classifiedCommands: CliCommandTaxonomyEntry[];
+    missingTaxonomy: string[];
+}
+export declare const CLI_PUBLIC_COMMAND_CLASS_DESCRIPTIONS: Record<CliPublicCommandClass, string>;
 export declare function collectCliLeafCommands(command: Command, prefix?: string[]): CliLeafCommand[];
+export declare function classifyCliCommandPath(commandPath: string): CliCommandTaxonomyEntry | undefined;
 export declare const CLI_COMMAND_MATRIX: ReadonlyArray<CliCommandMatrixEntry>;
 export declare function validateCliCommandMatrix(program: Command): CliCommandMatrixValidationReport;
+export declare function validateCliCommandTaxonomy(program: Command): CliCommandTaxonomyValidationReport;
 //# sourceMappingURL=command-matrix.d.ts.map

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

@@ -1,4 +1,122 @@
 import { CLI_NAME } from '../branding.js';
+export const CLI_PUBLIC_COMMAND_CLASS_DESCRIPTIONS = {
+    'canonical-lifecycle': 'Preferred CodeSDD-native lifecycle commands for discovery, planning, execution, and closure.',
+    'bootstrap-repair': 'Commands that create, refresh, or repair CodeSDD project or tool assets.',
+    'compatibility-workflow': 'Legacy or noun-based workflow commands kept for migration and existing automation.',
+    'migration-tool': 'Explicit import, migration, or upgrade commands for legacy or cross-version state.',
+    'diagnostics-governance': 'Health, configuration, schema, policy, provider, catalog, and governance support commands.',
+    'experimental-internal': 'Hidden, internal, or deprecated experimental surfaces that should not appear in first-run guidance.',
+};
+const CANONICAL_LIFECYCLE_RULE = {
+    publicClass: 'canonical-lifecycle',
+    boundary: 'codesdd-native',
+    llmPolicy: 'teach-first',
+    rationale: 'Canonical CodeSDD lifecycle surface backed by .sdd/state/*.yaml.',
+};
+const BOOTSTRAP_REPAIR_RULE = {
+    publicClass: 'bootstrap-repair',
+    boundary: 'codesdd-native',
+    llmPolicy: 'teach-first',
+    rationale: 'Creates or refreshes CodeSDD project state and generated tool assets.',
+};
+const COMPATIBILITY_WORKFLOW_RULE = {
+    publicClass: 'compatibility-workflow',
+    boundary: 'compatibility-window',
+    llmPolicy: 'compatibility-only',
+    rationale: 'Maintained for existing workflows and legacy automation; not the CodeSDD-native happy path.',
+};
+const MIGRATION_TOOL_RULE = {
+    publicClass: 'migration-tool',
+    boundary: 'migration-only',
+    llmPolicy: 'migration-only',
+    rationale: 'Explicitly moves or imports legacy state; never part of the default first-run flow.',
+};
+const DIAGNOSTICS_GOVERNANCE_RULE = {
+    publicClass: 'diagnostics-governance',
+    boundary: 'codesdd-native',
+    llmPolicy: 'advanced',
+    rationale: 'Supports health, configuration, schema, provider, catalog, policy, or governance diagnostics.',
+};
+const INTERNAL_RULE = {
+    publicClass: 'experimental-internal',
+    boundary: 'internal-hidden',
+    llmPolicy: 'internal-only',
+    rationale: 'Hidden or internal command surface; not documented as user onboarding guidance.',
+};
+const EXACT_COMMAND_TAXONOMY = new Map([
+    ['init', BOOTSTRAP_REPAIR_RULE],
+    ['reload', BOOTSTRAP_REPAIR_RULE],
+    ['install', BOOTSTRAP_REPAIR_RULE],
+    ['update', BOOTSTRAP_REPAIR_RULE],
+    ['sdd:init', BOOTSTRAP_REPAIR_RULE],
+    ['sdd:init-context', BOOTSTRAP_REPAIR_RULE],
+    ['sdd:insight', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:ingest-deposito', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:debate', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:decide', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:breakdown', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:start', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:frontend-impact', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:finalize', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:context', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:onboard', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:aprovar', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:next', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:plan-status', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:execute-next', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:check', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:diagnose', CANONICAL_LIFECYCLE_RULE],
+    ['sdd:reversa', CANONICAL_LIFECYCLE_RULE],
+    ['list', COMPATIBILITY_WORKFLOW_RULE],
+    ['view', COMPATIBILITY_WORKFLOW_RULE],
+    ['change:show', COMPATIBILITY_WORKFLOW_RULE],
+    ['change:list', COMPATIBILITY_WORKFLOW_RULE],
+    ['change:validate', COMPATIBILITY_WORKFLOW_RULE],
+    ['archive', COMPATIBILITY_WORKFLOW_RULE],
+    ['spec:show', COMPATIBILITY_WORKFLOW_RULE],
+    ['spec:list', COMPATIBILITY_WORKFLOW_RULE],
+    ['spec:validate', COMPATIBILITY_WORKFLOW_RULE],
+    ['validate', COMPATIBILITY_WORKFLOW_RULE],
+    ['show', COMPATIBILITY_WORKFLOW_RULE],
+    ['status', COMPATIBILITY_WORKFLOW_RULE],
+    ['instructions', COMPATIBILITY_WORKFLOW_RULE],
+    ['templates', COMPATIBILITY_WORKFLOW_RULE],
+    ['schemas', COMPATIBILITY_WORKFLOW_RULE],
+    ['new:change', COMPATIBILITY_WORKFLOW_RULE],
+    ['sdd:migrate', MIGRATION_TOOL_RULE],
+    ['sdd:upgrade-to-codesdd', MIGRATION_TOOL_RULE],
+    ['sdd:migrate-workspace', MIGRATION_TOOL_RULE],
+    ['sdd:import-legacy-spec', MIGRATION_TOOL_RULE],
+    ['experimental', INTERNAL_RULE],
+    ['__complete', INTERNAL_RULE],
+]);
+const PREFIX_COMMAND_TAXONOMY = [
+    { prefix: 'config:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'schema:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'completion:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'sdd:plugin:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'sdd:backlog:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'sdd:skills:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'sdd:sanitize:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'sdd:fgap:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+    { prefix: 'sdd:lint:', rule: DIAGNOSTICS_GOVERNANCE_RULE },
+];
+const EXACT_DIAGNOSTICS_GOVERNANCE_COMMANDS = new Set([
+    'feedback',
+    'sdd:intent-guard',
+    'sdd:fingerprint',
+    'sdd:historical-quality-regression',
+    'sdd:mcp-manifest',
+    'sdd:mcp-call',
+    'sdd:preflight',
+    'sdd:agent:run',
+    'sdd:release-readiness',
+    'sdd:rebuild',
+    'sdd:metrics',
+    'sdd:dedup',
+    'sdd:audit',
+    'sdd:scan-naming',
+]);
 function commandSegments(command, prefix = []) {
     const name = command.name();
     if (!name || name === CLI_NAME) {
@@ -21,6 +139,19 @@ export function collectCliLeafCommands(command, prefix = []) {
     }
     return children.flatMap((child) => collectCliLeafCommands(child, segments));
 }
+export function classifyCliCommandPath(commandPath) {
+    const exactRule = EXACT_COMMAND_TAXONOMY.get(commandPath);
+    const rule = exactRule ??
+        PREFIX_COMMAND_TAXONOMY.find((entry) => commandPath.startsWith(entry.prefix))?.rule ??
+        (EXACT_DIAGNOSTICS_GOVERNANCE_COMMANDS.has(commandPath) ? DIAGNOSTICS_GOVERNANCE_RULE : undefined);
+    if (!rule) {
+        return undefined;
+    }
+    return {
+        commandPath,
+        ...rule,
+    };
+}
 export const CLI_COMMAND_MATRIX = [
     { commandPath: 'init', strategy: 'contract', rationale: 'Project bootstrap is deterministic and already decomposes into testable setup services.' },
     { commandPath: 'reload', strategy: 'spawned-e2e', rationale: 'Reload reapplies base setup plus SDD bootstrap with the installed CLI version and needs real-bin smoke coverage.' },
@@ -46,12 +177,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 +196,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,7 +206,11 @@ 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:historical-quality-regression', strategy: 'contract', rationale: 'Historical quality regression scanning is deterministic over archived quality artifacts and bounded window options.' },
+    { commandPath: 'sdd:reversa', strategy: 'contract', rationale: 'Reversa command planning, including the governed URL preflight surface, is deterministic, fail-closed, frontend-only by default, and has no direct extraction or state writes.' },
     { 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.' },
     { commandPath: 'sdd:plugin:devtrack-api:scaffold-dry-run', strategy: 'contract', rationale: 'DevTrack API scaffold dry-run plans appliance artifacts without executing a generator.' },
@@ -129,4 +271,19 @@ export function validateCliCommandMatrix(program) {
         extraEntries,
     };
 }
+export function validateCliCommandTaxonomy(program) {
+    const leafCommands = collectCliLeafCommands(program).sort((left, right) => left.commandPath.localeCompare(right.commandPath));
+    const classifiedCommands = leafCommands
+        .map((entry) => classifyCliCommandPath(entry.commandPath))
+        .filter((entry) => entry !== undefined);
+    const classifiedPaths = new Set(classifiedCommands.map((entry) => entry.commandPath));
+    const missingTaxonomy = leafCommands
+        .map((entry) => entry.commandPath)
+        .filter((commandPath) => !classifiedPaths.has(commandPath));
+    return {
+        leafCommands,
+        classifiedCommands,
+        missingTaxonomy,
+    };
+}
 //# sourceMappingURL=command-matrix.js.map

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',
@@ -96,6 +101,7 @@ export const CLI_COMMAND_QUALITY_MATRIX = [
         'sdd check',
         'sdd diagnose',
         'sdd agent run',
+        'sdd historical-quality-regression',
         'sdd fgap add',
         'sdd fgap done',
         'sdd fingerprint',
@@ -107,6 +113,11 @@ export const CLI_COMMAND_QUALITY_MATRIX = [
         'sdd migrate-workspace',
         'sdd next',
         'sdd onboard',
+        'sdd plan-status',
+        'sdd preflight',
+        'sdd release-readiness',
+        'sdd reversa',
+        'sdd intent-guard',
         'sdd backlog project',
         'sdd plugin devtrack-api scaffold-dry-run',
         'sdd plugin inspect',

package/dist/core/completions/command-registry.js

@@ -449,6 +449,51 @@ const COMMAND_METADATA_OVERRIDES = [
                 description: 'Configure workflow profile (interactive picker or preset shortcut)',
                 flags: [],
             },
+            {
+                name: 'redis',
+                description: 'Inspect and operate the optional Redis runtime backend',
+                flags: [],
+                subcommands: [
+                    {
+                        name: 'status',
+                        description: 'Show Redis runtime status',
+                        flags: [
+                            COMMON_FLAGS.json,
+                        ],
+                    },
+                    {
+                        name: 'ping',
+                        description: 'Ping Redis using the effective CodeSDD configuration',
+                        flags: [
+                            COMMON_FLAGS.json,
+                        ],
+                    },
+                    {
+                        name: 'bench',
+                        description: 'Run a short redacted Redis latency benchmark',
+                        flags: [
+                            COMMON_FLAGS.json,
+                            {
+                                name: 'iterations',
+                                description: 'Number of benchmark iterations',
+                                takesValue: true,
+                            },
+                        ],
+                    },
+                    {
+                        name: 'flush-namespace',
+                        description: 'Delete only keys under the effective CodeSDD Redis namespace',
+                        flags: [
+                            COMMON_FLAGS.json,
+                            {
+                                name: 'yes',
+                                short: 'y',
+                                description: 'Confirm namespace-scoped deletion',
+                            },
+                        ],
+                    },
+                ],
+            },
         ],
     },
     {

package/dist/core/config-schema.d.ts

@@ -15,6 +15,36 @@ export declare const GlobalConfigSchema: z.ZodObject<{
         both: "both";
     }>>>;
     workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    redis: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+        url_env: z.ZodOptional<z.ZodString>;
+        namespace: z.ZodOptional<z.ZodString>;
+        tls: z.ZodOptional<z.ZodBoolean>;
+        connect_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        command_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        max_retries: z.ZodOptional<z.ZodNumber>;
+        fallback: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            filesystem: "filesystem";
+        }>>;
+        cache_default_ttl_ms: z.ZodOptional<z.ZodNumber>;
+        lock_ttl_ms: z.ZodOptional<z.ZodNumber>;
+        stream_max_len: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    enterprise: z.ZodOptional<z.ZodObject<{
+        provisioning: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                local: "local";
+                enterprise: "enterprise";
+            }>>;
+            project_id: z.ZodOptional<z.ZodString>;
+            authority_url: z.ZodOptional<z.ZodString>;
+            authority_url_env: z.ZodOptional<z.ZodString>;
+            tenant_id: z.ZodOptional<z.ZodString>;
+            required_for_numbered_artifacts: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$loose>;
 export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
 /**
@@ -84,5 +114,5 @@ export declare function validateConfig(config: unknown): {
     error?: string;
 };
 export declare function isSensitiveConfigPath(path: string): boolean;
-export declare function redactConfigSecrets(value: unknown): unknown;
+export declare function redactConfigSecrets(value: unknown, parentPath?: string): unknown;
 //# sourceMappingURL=config-schema.d.ts.map