@devtrack-solution/codesdd 1.2.4-rc3 → 1.2.4

package/dist/commands/sdd/execution.js

@@ -9,6 +9,8 @@ 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 { evaluateReleaseReadiness, formatReleaseReadinessReport } from '../../core/sdd/release-readiness.js';
@@ -142,7 +144,7 @@ async function buildPlanStatus(root, stores, options) {
 export function registerExecutionCommands(sddCmd) {
     sddCmd
         .command('release-readiness')
-        .description('Report non-mutating release readiness gates and CI parity commands')
+        .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')
@@ -834,10 +836,55 @@ export function registerExecutionCommands(sddCmd) {
         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);
@@ -847,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.'));
@@ -864,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.js

@@ -25,6 +25,7 @@ import { FeatureLintService, formatFeatureLintReport } from "../core/sdd/service
 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 { 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';
@@ -67,6 +68,101 @@ export function registerSddCommand(program) {
             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')
@@ -448,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) {
@@ -719,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.' },
@@ -78,6 +209,8 @@ export const CLI_COMMAND_MATRIX = [
     { 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.' },
@@ -138,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

@@ -101,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',
@@ -115,6 +116,7 @@ export const CLI_COMMAND_QUALITY_MATRIX = [
         'sdd plan-status',
         'sdd preflight',
         'sdd release-readiness',
+        'sdd reversa',
         'sdd intent-guard',
         'sdd backlog project',
         'sdd plugin devtrack-api scaffold-dry-run',

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

@@ -25,13 +25,26 @@ export declare const GlobalConfigSchema: z.ZodObject<{
         command_timeout_ms: z.ZodOptional<z.ZodNumber>;
         max_retries: z.ZodOptional<z.ZodNumber>;
         fallback: z.ZodOptional<z.ZodEnum<{
-            filesystem: "filesystem";
             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>;
 /**

package/dist/core/config-schema.js

@@ -36,6 +36,20 @@ export const GlobalConfigSchema = z
         stream_max_len: z.number().int().positive().optional(),
     })
         .optional(),
+    enterprise: z
+        .object({
+        provisioning: z
+            .object({
+            mode: z.enum(['local', 'enterprise']).optional(),
+            project_id: z.string().min(1).optional(),
+            authority_url: z.string().min(1).optional(),
+            authority_url_env: z.string().min(1).optional(),
+            tenant_id: z.string().min(1).optional(),
+            required_for_numbered_artifacts: z.boolean().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
 })
     .passthrough();
 /**
@@ -46,7 +60,7 @@ export const DEFAULT_CONFIG = {
     profile: 'core',
     delivery: 'both',
 };
-const KNOWN_TOP_LEVEL_KEYS = new Set([...Object.keys(DEFAULT_CONFIG), 'workflows', 'redis']);
+const KNOWN_TOP_LEVEL_KEYS = new Set([...Object.keys(DEFAULT_CONFIG), 'workflows', 'redis', 'enterprise']);
 const SENSITIVE_KEY_TOKENS = ['key', 'secret', 'token', 'password', 'credential', 'private', 'auth'];
 /**
  * Validate a config key path for CLI set operations.
@@ -90,6 +104,23 @@ export function validateConfigKeyPath(path) {
         }
         return { valid: true };
     }
+    if (rootKey === 'enterprise') {
+        if (rawKeys.length !== 3 || rawKeys[1] !== 'provisioning') {
+            return { valid: false, reason: 'enterprise settings use enterprise.provisioning.<key>' };
+        }
+        const provisioningKeys = new Set([
+            'mode',
+            'project_id',
+            'authority_url',
+            'authority_url_env',
+            'tenant_id',
+            'required_for_numbered_artifacts',
+        ]);
+        if (!provisioningKeys.has(rawKeys[2])) {
+            return { valid: false, reason: `Unknown enterprise provisioning key "${rawKeys[2]}"` };
+        }
+        return { valid: true };
+    }
     if (rawKeys.length > 1) {
         return { valid: false, reason: `"${rootKey}" does not support nested keys` };
     }

package/dist/core/config.d.ts

@@ -13,5 +13,6 @@ export interface AIToolOption {
     successLabel?: string;
     skillsDir?: string;
 }
+export declare function getToolInstallGuidance(toolIds: readonly string[]): string[];
 export declare const AI_TOOLS: AIToolOption[];
 //# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -3,6 +3,17 @@ export const CODESDD_MARKERS = {
     start: '<!-- CODESDD:START -->',
     end: '<!-- CODESDD:END -->'
 };
+export function getToolInstallGuidance(toolIds) {
+    const normalized = new Set(toolIds.map((toolId) => toolId.toLowerCase()));
+    const notes = [];
+    if (normalized.size > 0) {
+        notes.push('Tool scope: generated assistant skills/prompts only; canonical project state stays in .sdd/.');
+    }
+    if (normalized.has('opencode')) {
+        notes.push('OpenCode tool id: use --tools opencode for generated assistant assets; use --provider open-code only for SDD MCP bridge commands.');
+    }
+    return notes;
+}
 export const AI_TOOLS = [
     { name: 'Amazon Q Developer', value: 'amazon-q', available: true, successLabel: 'Amazon Q Developer', skillsDir: '.amazonq' },
     { name: 'Antigravity', value: 'antigravity', available: true, successLabel: 'Antigravity', skillsDir: '.agent' },

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

@@ -22,12 +22,25 @@ export interface RedisGlobalConfig {
     lock_ttl_ms?: number;
     stream_max_len?: number;
 }
+export type EnterpriseProvisioningMode = 'local' | 'enterprise';
+export interface EnterpriseProvisioningGlobalConfig {
+    mode?: EnterpriseProvisioningMode;
+    project_id?: string;
+    authority_url?: string;
+    authority_url_env?: string;
+    tenant_id?: string;
+    required_for_numbered_artifacts?: boolean;
+}
+export interface EnterpriseGlobalConfig {
+    provisioning?: EnterpriseProvisioningGlobalConfig;
+}
 export interface GlobalConfig {
     featureFlags?: Record<string, boolean>;
     profile?: Profile;
     delivery?: Delivery;
     workflows?: string[];
     redis?: RedisGlobalConfig;
+    enterprise?: EnterpriseGlobalConfig;
 }
 export declare function parseTomlContent(content: string): Record<string, unknown>;
 export declare function stringifyTomlContent(value: Record<string, unknown>): string;

package/dist/core/init.d.ts

@@ -1,8 +1,8 @@
 /**
  * Init Command
  *
- * Sets up CodeSDD with Agent Skills and /opsx:* slash commands.
- * This is the unified setup command that replaces both the old init and experimental commands.
+ * Sets up CodeSDD agent skills and compatibility slash commands.
+ * The canonical project lifecycle lives under .sdd and codesdd sdd commands.
  */
 type InitCommandOptions = {
     tools?: string;