@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/commands/sdd/execution.js

@@ -10,11 +10,21 @@ 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 { ensureMandatorySddMigration, parseCsvOption, parseFlowModeOption, resolveRoot } from './shared.js';
+function parseJsonObjectOption(value) {
+    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.');
+    }
+    return parsed;
+}
 export function registerExecutionCommands(sddCmd) {
     sddCmd
         .command('mcp-manifest')
-        .description('Render a provider-agnostic MCP manifest for OpenSDD execution tools')
+        .description('Render a provider-agnostic MCP manifest for CodeSDD execution tools')
         .option('--provider <provider>', 'Client profile: codex|claude-code|kimmy-code|kilo-code|open-code|generic')
         .option('--json', 'JSON output')
         .action(async (options) => {
@@ -28,22 +38,46 @@ export function registerExecutionCommands(sddCmd) {
             console.log(JSON.stringify(manifest, null, 2));
             return;
         }
-        console.log(chalk.green(`OpenSDD MCP manifest for ${manifest.provider.label}`));
+        console.log(chalk.green(`CodeSDD MCP manifest for ${manifest.provider.label}`));
         console.log(`Protocol: ${manifest.protocol}`);
         console.log(`Transport: ${manifest.provider.transport}`);
         console.log(`Tools: ${manifest.tools.map((tool) => tool.name).join(', ')}`);
     });
     sddCmd
         .command('mcp-call <tool>')
-        .description('Invoke the provider-agnostic MCP bridge for next/context/finalize')
+        .description('Invoke governed CodeSDD MCP tools for DeepAgents')
         .option('--provider <provider>', 'Client profile: codex|claude-code|kimmy-code|kilo-code|open-code|generic')
-        .option('--ref <ref>', 'Reference for opensdd.context or opensdd.finalize')
-        .option('--rank <rank>', 'Ranking for opensdd.next: impact|criticality|fifo')
-        .option('--limit <n>', 'Limit for opensdd.next')
-        .option('--max-agents <n>', 'Max agents for opensdd.next wave simulation')
-        .option('--all-ready', 'Apply to all ready items for opensdd.finalize')
-        .option('--force-frontend', 'Force frontend finalize guardrail bypass')
-        .option('--force-transition', 'Force transition guardrail bypass')
+        .option('--ref <ref>', 'Reference for context/read/query/quality tools')
+        .option('--ref-or-text <value>', 'Reference or free text for codesdd.start intent')
+        .option('--feature-id <id>', 'Feature id for codesdd.finalize_intent or codesdd.frontend_impact')
+        .option('--status <status>', 'Status for codesdd.frontend_impact: unknown|none|required')
+        .option('--reason <text>', 'Reason for codesdd.frontend_impact when applicable')
+        .option('--routes <list>', 'CSV routes for codesdd.frontend_impact')
+        .option('--surfaces <list>', 'CSV surfaces for codesdd.frontend_impact')
+        .option('--manifest-path <path>', 'Plugin manifest path for plugin tools')
+        .option('--feature-ref <ref>', 'Feature ref for plugin plan/apply_sandbox')
+        .option('--capability <name>', 'Plugin capability for plugin plan/apply_sandbox')
+        .option('--skill-ref <ref>', 'Skill reference for plugin plan/apply_sandbox')
+        .option('--input <json>', 'JSON object input for plugin plan/apply_sandbox')
+        .option('--write-scope <list>', 'CSV write scope for plugin plan/apply_sandbox')
+        .option('--approval-grants <list>', 'CSV approvals for plugin plan/apply_sandbox')
+        .option('--planned-writes <list>', 'CSV planned writes for plugin plan/apply_sandbox')
+        .option('--requested-env <list>', 'CSV env vars for plugin plan/apply_sandbox')
+        .option('--network-domains <list>', 'CSV domains for plugin plan/apply_sandbox')
+        .option('--process-spawn-requested', 'Whether plugin plan/apply_sandbox requests process spawn')
+        .option('--strict', 'Strict mode for codesdd.check and codesdd.diagnose')
+        .option('--doc <doc>', 'Workspace doc for codesdd.read: spec|plan|tasks|changelog|quality|all')
+        .option('--query <query>', 'Search expression for codesdd.query')
+        .option('--scope <scope>', 'Search scope for codesdd.query: backlog|discovery|all')
+        .option('--rank <rank>', 'Ranking for codesdd.next: impact|criticality|fifo')
+        .option('--limit <n>', 'Limit for codesdd.next')
+        .option('--max-agents <n>', 'Max agents for codesdd.next wave simulation')
+        .option('--ids <list>', 'CSV skill IDs for codesdd.skill_prompt')
+        .option('--phase <phase>', 'Phase for codesdd.skill_prompt')
+        .option('--domains <list>', 'CSV domains for codesdd.skill_prompt')
+        .option('--bundles <list>', 'CSV bundles for codesdd.skill_prompt')
+        .option('--max <n>', 'Max suggested skills for codesdd.skill_prompt')
+        .option('--objective <text>', 'Objective text for codesdd.skill_prompt')
         .option('--json', 'JSON output')
         .action(async (tool, options) => {
         const root = resolveRoot();
@@ -57,30 +91,124 @@ export function registerExecutionCommands(sddCmd) {
             tool: tool,
             args: {
                 ref: options?.ref,
+                refOrText: options?.refOrText,
+                featureId: options?.featureId,
+                status: options?.status,
+                reason: options?.reason,
+                routes: parseCsvOption(options?.routes),
+                surfaces: parseCsvOption(options?.surfaces),
+                manifestPath: options?.manifestPath,
+                featureRef: options?.featureRef,
+                capability: options?.capability,
+                skillRef: options?.skillRef,
+                inputs: parseJsonObjectOption(options?.input),
+                writeScope: parseCsvOption(options?.writeScope),
+                approvalGrants: parseCsvOption(options?.approvalGrants),
+                plannedWrites: parseCsvOption(options?.plannedWrites),
+                requestedEnv: parseCsvOption(options?.requestedEnv),
+                networkDomains: parseCsvOption(options?.networkDomains),
+                processSpawnRequested: options?.processSpawnRequested,
+                strict: options?.strict,
+                doc: options?.doc,
+                query: options?.query,
+                scope: options?.scope,
                 rank: options?.rank,
                 limit: options?.limit ? Number.parseInt(options.limit, 10) : undefined,
                 maxAgents: options?.maxAgents ? Number.parseInt(options.maxAgents, 10) : undefined,
-                allReady: options?.allReady,
-                forceFrontend: options?.forceFrontend,
-                forceTransition: options?.forceTransition,
-                cwd: process.cwd(),
+                ids: parseCsvOption(options?.ids),
+                phase: options?.phase,
+                domains: parseCsvOption(options?.domains),
+                bundles: parseCsvOption(options?.bundles),
+                max: options?.max ? Number.parseInt(options.max, 10) : undefined,
+                objective: options?.objective,
             },
         });
         if (options?.json) {
             console.log(JSON.stringify(response, null, 2));
             return;
         }
-        console.log(chalk.green(`OpenSDD MCP call completed: ${response.tool}`));
+        console.log(chalk.green(`CodeSDD MCP call completed: ${response.tool}`));
         console.log(`Provider: ${response.provider}`);
         console.log(`Invoked at: ${response.invoked_at}`);
         console.log(JSON.stringify(response.result, null, 2));
     });
+    const agentCmd = sddCmd
+        .command('agent')
+        .description('Governed agent execution commands for external providers');
+    agentCmd
+        .command('run <featureId>')
+        .description('Run DeepAgents mode policy gate with fail-closed enforcement')
+        .requiredOption('--provider <provider>', 'Execution provider (FEAT-0243 accepts only deepagents)')
+        .option('--mode <mode>', 'Execution mode: read-only|plan|validate|apply-sandbox|apply-approved')
+        .option('--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('--requested-env <list>', 'CSV environment variables requested for runtime passthrough')
+        .option('--network-domains <list>', 'CSV network domains requested by this run')
+        .option('--approval-grants <list>', 'CSV HITL approval grants: operation names or all')
+        .option('--json', 'JSON output')
+        .action(async (featureId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        void stores;
+        await ensureMandatorySddMigration(root);
+        const command = new DeepAgentsRunService();
+        const result = await command.execute(featureId, {
+            provider: options.provider,
+            mode: options.mode,
+            plugin_execution_path: options.pluginExecutionPath,
+            plugin_flow: parseCsvOption(options.pluginFlow),
+            operations: parseCsvOption(options.operations),
+            write_scope: parseCsvOption(options.writeScope),
+            planned_writes: parseCsvOption(options.plannedWrites),
+            requested_env: parseCsvOption(options.requestedEnv),
+            network_domains: parseCsvOption(options.networkDomains),
+            approval_grants: parseCsvOption(options.approvalGrants),
+        }, { projectRoot: root, stores });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            if (result.status === 'blocked') {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        if (result.status === 'allowed') {
+            console.log(chalk.green(`DeepAgents run policy: ${result.status}`));
+        }
+        else {
+            console.log(chalk.red(`DeepAgents run policy: ${result.status}`));
+        }
+        console.log(`Feature: ${result.feature_id}`);
+        console.log(`Provider: ${result.provider}`);
+        console.log(`Mode: ${result.mode}`);
+        console.log(`Fail-closed: ${result.fail_closed ? 'yes' : 'no'}`);
+        console.log(`Direct .sdd/state writes: ${result.evidence.direct_state_write_allowed ? 'allowed' : 'blocked'}`);
+        console.log(`Plugin execution path: ${result.evidence.plugin_execution.requested_path}`);
+        if (result.evidence.runtime) {
+            console.log(`Runtime: ${result.evidence.runtime.adapter.runtime}`);
+            console.log(`Runtime status: ${result.evidence.runtime.adapter.status}`);
+        }
+        if (result.evidence.plugin_execution.missing_flow.length > 0) {
+            console.log(`Missing plugin flow: ${result.evidence.plugin_execution.missing_flow.join(', ')}`);
+        }
+        console.log(`Evidence run id: ${result.evidence.run_id}`);
+        if (result.reasons.length > 0) {
+            console.log(`Reasons: ${result.reasons.join(' | ')}`);
+        }
+        if (result.status === 'blocked') {
+            process.exitCode = 1;
+        }
+    });
     sddCmd
         .command('start <refOrText>')
         .description('Starts FEAT/EPIC/FGAP/TD execution or creates a direct FEAT')
         .alias('iniciar-execucao')
         .option('--scale <scale>', 'Escala QUICK|STANDARD|LARGE')
-        .option('--schema <schema>', 'Schema para criar change em openspec/changes')
+        .option('--schema <schema>', 'Schema para criar change de compatibilidade em legacy-spec/changes')
         .option('--force', 'Bypass de bloqueios e conflitos de lock')
         .option('--force-transition', 'Bypass das restrições e violações das lentes estruturais')
         .option('--flow-mode <flowMode>', 'Flow: direct|standard|rigorous')
@@ -262,6 +390,9 @@ export function registerExecutionCommands(sddCmd) {
         .option('--compact', 'Retorna payload resumido')
         .option('--full', 'Retorna payload completo em JSON (desativa modo compacto automatico)')
         .action(async (target = 'system', options) => {
+        if (options?.compact && options?.full) {
+            throw new Error("Options '--compact' and '--full' are mutually exclusive. Choose one.");
+        }
         const root = resolveRoot();
         const __config = await loadProjectSddConfig(root);
         const __paths = resolveSddPaths(root, __config);

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

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

package/dist/commands/sdd/plugin.js

@@ -0,0 +1,153 @@
+import chalk from 'chalk';
+import { inspectPluginManifestFromFile, planDevTrackApiScaffoldDryRunFromFile, planPluginInvocationFromFile, } from '../../core/sdd/plugin-cli.js';
+import { parseCsvOption } from './shared.js';
+export function registerPluginCommands(sddCmd) {
+    const pluginCmd = sddCmd.command('plugin').description('Inspect and plan enterprise plugin operations');
+    pluginCmd
+        .command('inspect <manifestPath>')
+        .description('Inspect a CodeSDD plugin manifest without executing it')
+        .option('--json', 'Return plugin manifest summary as JSON')
+        .action(async (manifestPath, options) => {
+        const result = await inspectPluginManifestFromFile(manifestPath);
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        printInspectResult(result);
+    });
+    pluginCmd
+        .command('plan <manifestPath>')
+        .description('Build a non-executing runtime invocation plan for a plugin capability')
+        .requiredOption('--feature <ref>', 'Feature reference that owns the operation, for example FEAT-0148')
+        .requiredOption('--capability <name>', 'Plugin capability to resolve, for example scaffold.project')
+        .option('--skill <ref>', 'Skill reference bound to the operation')
+        .option('--input <json>', 'JSON object passed as plugin capability input')
+        .option('--write-scope <list>', 'Comma-separated requested write scope')
+        .option('--apply', 'Plan an apply operation instead of dry-run')
+        .option('--rollback', 'Plan a rollback operation instead of dry-run')
+        .option('--approval <list>', 'Comma-separated approval grants: maintainer,security,architecture-board')
+        .option('--operation-id <id>', 'Stable operation id to use in the invocation envelope')
+        .option('--source-checksum <checksum>', 'Expected source checksum for policy evaluation')
+        .option('--planned-writes <list>', 'Comma-separated planned write paths for policy evaluation')
+        .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('--language <language>', 'Technology language constraint')
+        .option('--framework <framework>', 'Technology framework constraint')
+        .option('--json', 'Return invocation plan as JSON')
+        .action(async (manifestPath, options) => {
+        const result = await planPluginInvocationFromFile(manifestPath, {
+            feature_ref: options.feature,
+            capability: options.capability,
+            mode: resolvePlanMode(options),
+            skill_ref: options.skill,
+            inputs: parseJsonObjectOption(options.input),
+            requested_write_scope: parseCsvOption(options.writeScope),
+            approval_grants: parseCsvOption(options.approval),
+            operation_id: options.operationId,
+            source_checksum: options.sourceChecksum,
+            planned_writes: parseCsvOption(options.plannedWrites),
+            requested_env: parseCsvOption(options.env),
+            network_domains: parseCsvOption(options.networkDomains),
+            process_spawn_requested: options.processSpawn ?? false,
+            technology: resolveTechnologyConstraint(options),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        printPlanResult(result);
+    });
+    const devtrackApiCmd = pluginCmd.command('devtrack-api').description('Plan DevTrack API appliance operations');
+    devtrackApiCmd
+        .command('scaffold-dry-run <manifestPath>')
+        .description('Build a deterministic DevTrack API scaffold dry-run plan without executing the appliance')
+        .requiredOption('--feature <ref>', 'Feature reference that owns the scaffold operation, for example FEAT-0152')
+        .requiredOption('--project <name>', 'Project display name to scaffold')
+        .option('--package <name>', 'Package name to use in the scaffold plan')
+        .option('--operation-id <id>', 'Stable operation id to use in the dry-run plan')
+        .option('--write-scope <list>', 'Comma-separated requested write scope')
+        .option('--json', 'Return scaffold dry-run plan as JSON')
+        .action(async (manifestPath, options) => {
+        const result = await planDevTrackApiScaffoldDryRunFromFile(manifestPath, {
+            feature_ref: options.feature,
+            project_name: options.project,
+            package_name: options.package,
+            operation_id: options.operationId,
+            requested_write_scope: parseCsvOption(options.writeScope),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        printDevTrackApiScaffoldDryRunResult(result);
+    });
+}
+function resolvePlanMode(options) {
+    if (options.apply && options.rollback) {
+        throw new Error('Use only one of --apply or --rollback.');
+    }
+    if (options.apply)
+        return 'apply';
+    if (options.rollback)
+        return 'rollback';
+    return 'dry-run';
+}
+function parseJsonObjectOption(value) {
+    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.');
+    }
+    return parsed;
+}
+function resolveTechnologyConstraint(options) {
+    if (!options.language && !options.framework) {
+        return undefined;
+    }
+    return {
+        language: options.language,
+        framework: options.framework,
+    };
+}
+function printInspectResult(result) {
+    console.log(chalk.green(`Plugin: ${result.plugin_ref.id}@${result.plugin_ref.version}`));
+    console.log(`Manifest: ${result.manifest_path}`);
+    console.log(`Contract: ${result.contract_version}`);
+    console.log(`Technology: ${result.technology.language}${result.technology.framework ? `/${result.technology.framework}` : ''}`);
+    console.log(`Trust: ${result.governance.trust_tier}`);
+    console.log(`Capabilities: ${result.capabilities.map((capability) => capability.name).join(', ')}`);
+}
+function printPlanResult(result) {
+    const { plan } = result;
+    console.log(chalk.green(`Plugin plan: ${plan.status}`));
+    console.log(`Manifest: ${result.manifest_path}`);
+    console.log(`Policy: ${plan.policy?.decision ?? 'not-evaluated'}`);
+    if (plan.envelope) {
+        console.log(`Operation: ${plan.envelope.operation_id}`);
+        console.log(`Plugin: ${plan.envelope.plugin_ref.id}@${plan.envelope.plugin_ref.version}`);
+        console.log(`Capability: ${plan.envelope.capability}`);
+        console.log(`Mode: ${plan.envelope.mode}`);
+        console.log(`Write scope: ${plan.envelope.write_scope.join(', ') || 'none'}`);
+    }
+    if (plan.reasons.length > 0) {
+        console.log(`Reasons: ${plan.reasons.join(' | ')}`);
+    }
+}
+function printDevTrackApiScaffoldDryRunResult(result) {
+    const { plan } = result;
+    console.log(chalk.green(`DevTrack API scaffold dry-run: ${plan.status}`));
+    console.log(`Manifest: ${result.manifest_path}`);
+    console.log(`Project: ${plan.project_name}`);
+    console.log(`Package: ${plan.package_name}`);
+    if (plan.status === 'planned') {
+        console.log(`Operation: ${plan.operation_id}`);
+        console.log(`Artifacts: ${plan.artifacts.length}`);
+        console.log(`Policy: ${plan.runtime_plan.policy?.decision ?? 'not-evaluated'}`);
+    }
+    if (plan.issues.length > 0) {
+        console.log(`Issues: ${plan.issues.join(' | ')}`);
+    }
+}
+//# sourceMappingURL=plugin.js.map

package/dist/commands/sdd/shared.js

@@ -1,11 +1,7 @@
 import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import chalk from 'chalk';
 import { resolveProjectRoot } from '../../core/sdd/resolve-project-root.js';
 import { loadProjectSddConfig, resolveSddPaths, } from '../../core/sdd/state.js';
-import { assessSddMigration, SddMigrateCommand } from '../../core/sdd/migrate.js';
-import { withStateLock } from '../../core/sdd/state-lock.js';
-import { isInteractive } from '../../utils/interactive.js';
+import { assessSddMigration } from '../../core/sdd/migrate.js';
 export function parseCsvOption(value) {
     if (!value)
         return [];
@@ -62,23 +58,6 @@ export async function ensureMandatorySddMigration(targetPath) {
         return;
     }
     const summary = assessment.reasons.join(' | ');
-    if (isInteractive()) {
-        const { confirm } = await import('@inquirer/prompts');
-        const approved = await confirm({
-            message: `Migracao SDD obrigatoria detectada. Deseja aplicar agora para continuar? ${summary}`,
-            default: true,
-        });
-        if (!approved) {
-            throw new Error('Operacao interrompida: aplique a migracao SDD mandatória com `openspec sdd migrate`.');
-        }
-    }
-    const stateDir = path.dirname(paths.stateFiles.discoveryIndex);
-    const result = await withStateLock(stateDir, async () => {
-        const command = new SddMigrateCommand();
-        return command.execute(resolved, { radToEpic: true });
-    });
-    for (const message of result.messages) {
-        console.log(chalk.yellow(`[sdd:migrate] ${message}`));
-    }
+    throw new Error(`Migracao SDD obrigatoria detectada: ${summary}. Execute \`codesdd sdd migrate --yes\` e reexecute o comando.`);
 }
 //# sourceMappingURL=shared.js.map

package/dist/commands/sdd/skills.js

@@ -62,6 +62,13 @@ export function registerSkillsCommands(sddCmd) {
         console.log(chalk.green(`Skills sincronizadas: ${result.synced}`));
         console.log(`Skills locais (${localSkillsPath}): ${result.local_synced}`);
         console.log(`Ferramentas atualizadas: ${result.tools.length > 0 ? result.tools.join(', ') : 'nenhuma'}`);
+        if (result.alerts.length > 0) {
+            console.log(chalk.yellow(`Alertas de user-extension (nao bloqueante): ${result.alerts.length}`));
+            for (const alert of result.alerts) {
+                const expected = alert.expected_sha256 || '<missing>';
+                console.log(`- ${alert.skill_id}: ${alert.status} (expected=${expected}, observed=${alert.observed_sha256})`);
+            }
+        }
     });
     skillsCmd
         .command('suggest [path]')

package/dist/commands/sdd.js

@@ -5,8 +5,9 @@ import { SddInitCommand, SddInitContextCommand } from '../core/sdd/init.js';
 import { SddCheckCommand } from '../core/sdd/check.js';
 import { loadProjectSddConfig, resolveSddPaths, } from '../core/sdd/state.js';
 import { assessSddMigration, SddMigrateCommand } from '../core/sdd/migrate.js';
+import { formatUpgradeToCodeSddReadiness, UpgradeToCodeSddCommand, } from '../core/sdd/upgrade-to-codesdd.js';
 import { MigrateWorkspaceCommand } from '../core/sdd/migrate-workspace.js';
-import { SddImportOpenSpecCommand } from '../core/sdd/import-openspec.js';
+import { SddImportLegacySpecCommand } from '../core/sdd/import-legacy-spec.js';
 import { isInteractive } from '../utils/interactive.js';
 import { createSddStores } from "../core/sdd/store/sdd-stores.js";
 import { InsightService } from "../core/sdd/services/insight.service.js";
@@ -25,8 +26,10 @@ import { SddDedupApplyService, formatSddDedupApplyReport } from "../core/sdd/ser
 import { captureFingerprintsForChange, writeMeta } from '../core/sdd/fingerprint.js';
 import { ensureMandatorySddMigration, parseCsvOption, parseFlowModeOption, parseLangOption, parseLayoutOption, resolveRoot, } from './sdd/shared.js';
 import { registerExecutionCommands } from './sdd/execution.js';
+import { registerPluginCommands } from './sdd/plugin.js';
 import { registerSkillsCommands } from './sdd/skills.js';
-import { displayLegacyOpenSpecPath, resolveOpenSpecSubpath, } from '../core/sdd/services/legacy-capability.service.js';
+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
@@ -69,6 +72,9 @@ export function registerSddCommand(program) {
         .alias('iniciar-contexto')
         .option('--mode <mode>', 'Modo de escrita: merge|replace (padrao: merge)')
         .option('--no-deep', 'Desativa inspecao profunda de estrutura de repositorio')
+        .option('--frontend', 'Ativa arquivos e views de frontend durante o bootstrap')
+        .option('--lang <lang>', 'Idioma SDD: pt-BR|en-US')
+        .option('--layout <layout>', 'Layout de pastas: en-US|legacy|pt-BR')
         .option('--no-render', 'Nao gera views apos bootstrap de contexto')
         .option('--json', 'Saida em JSON')
         .action(async (targetPath = '.', options) => {
@@ -84,6 +90,9 @@ export function registerSddCommand(program) {
             mode: options?.mode,
             deep: options?.deep,
             render: options?.render,
+            frontendEnabled: options?.frontend,
+            language: parseLangOption(options?.lang),
+            layout: parseLayoutOption(options?.layout),
         });
         if (options?.json) {
             console.log(JSON.stringify(result, null, 2));
@@ -113,8 +122,8 @@ export function registerSddCommand(program) {
         if (!options?.backfill) {
             throw new Error('Use --backfill para executar esta operação.');
         }
-        const changeRoot = resolveOpenSpecSubpath(root, 'changes');
-        const mainSpecsDir = resolveOpenSpecSubpath(root, 'specs');
+        const changeRoot = resolveLegacySpecSubpath(root, 'changes');
+        const mainSpecsDir = resolveLegacySpecSubpath(root, 'specs');
         await fs.access(changeRoot);
         let changeIds;
         if (options?.ref) {
@@ -124,7 +133,7 @@ export function registerSddCommand(program) {
             const requestedChangeDir = path.join(changeRoot, options.ref);
             const stat = await fs.stat(requestedChangeDir);
             if (!stat.isDirectory()) {
-                throw new Error(`Change '${options.ref}' nao encontrado em ${displayLegacyOpenSpecPath('changes')}`);
+                throw new Error(`Change '${options.ref}' nao encontrado em ${displayLegacySpecPath('changes')}`);
             }
             changeIds = [options.ref];
         }
@@ -341,6 +350,8 @@ export function registerSddCommand(program) {
         console.log(`Duplicatas puladas: ${result.skipped_duplicates.length}`);
     });
     registerExecutionCommands(sddCmd);
+    registerPluginCommands(sddCmd);
+    registerBacklogCommands(sddCmd);
     sddCmd
         .command('check [path]')
         .description('Valida arquivos de estado .sdd e opcionalmente gera views')
@@ -545,6 +556,52 @@ export function registerSddCommand(program) {
             console.log(`- ${msg}`);
         }
     });
+    sddCmd
+        .command('upgrade-to-codesdd')
+        .description('Plans, applies, or rolls back a transactional upgrade to the CodeSDD SDD contract')
+        .option('--dry-run', 'Preview readiness and planned steps without writing files')
+        .option('--apply', 'Apply the transactional upgrade')
+        .option('--yes', 'Confirm transactional mutation')
+        .option('--rollback <transactionId>', 'Rollback a previous upgrade transaction id')
+        .option('--reason <reason>', 'Rollback reason used with --rollback')
+        .option('--json', 'JSON output')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const command = new UpgradeToCodeSddCommand();
+        if (options?.rollback) {
+            if (options.apply || options.dryRun) {
+                throw new Error('Use --rollback without --apply or --dry-run.');
+            }
+            const result = await command.rollback(root, options.rollback, {
+                reason: options.reason,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(chalk.green(`Upgrade rollback completed: ${result.transaction_id}`));
+            console.log(`Manifest: ${result.manifest_path}`);
+            console.log(`Restored: ${result.restored_paths.join(', ') || '-'}`);
+            console.log(`Skipped: ${result.skipped_paths.join(', ') || '-'}`);
+            console.log(`Reason: ${result.reason}`);
+            return;
+        }
+        const result = await command.execute(root, {
+            dryRun: options?.dryRun || !options?.apply,
+            apply: options?.apply,
+            yes: options?.yes,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(formatUpgradeToCodeSddReadiness(result.readiness));
+        if (result.mode === 'apply') {
+            console.log(chalk.green('Transactional upgrade applied.'));
+            console.log(`Transaction: ${result.manifest?.transaction_id}`);
+            console.log(`Manifest: ${result.manifest_path}`);
+        }
+    });
     sddCmd
         .command('migrate-workspace')
         .description('Migra workspaces SDD legados de Markdown para YAML validado')
@@ -586,11 +643,11 @@ export function registerSddCommand(program) {
         }
     });
     sddCmd
-        .command('import-openspec [path]')
-        .description('Imports legacy openspec/ state into .sdd sources and source-index')
-        .alias('importar-openspec')
+        .command('import-legacy-spec [path]')
+        .description('Imports legacy legacy-spec/ state into .sdd sources and source-index')
+        .alias('importar-codesdd')
         .option('--dry-run', 'Preview import without writing files')
-        .option('--remove', 'Remove openspec/ after successful import verification')
+        .option('--remove', 'Remove legacy-spec/ after successful import verification')
         .option('--yes', 'Confirm destructive removal when --remove is used')
         .option('--json', 'JSON output')
         .option('--no-render', 'Does not generate views after updating state')
@@ -600,7 +657,7 @@ export function registerSddCommand(program) {
         const __paths = resolveSddPaths(root, __config);
         const stores = createSddStores(__paths);
         await ensureMandatorySddMigration(root);
-        const command = new SddImportOpenSpecCommand();
+        const command = new SddImportLegacySpecCommand();
         const result = await command.execute(root, {
             dryRun: options?.dryRun,
             remove: options?.remove,
@@ -611,7 +668,7 @@ export function registerSddCommand(program) {
             console.log(JSON.stringify(result, null, 2));
             return;
         }
-        console.log(chalk.green('OpenSpec import completed.'));
+        console.log(chalk.green('Legacy spec import completed.'));
         console.log(`Source root: ${result.source_root}`);
         console.log(`Target root: ${result.target_root}`);
         console.log(`Report: ${result.report_path}`);
@@ -619,7 +676,7 @@ export function registerSddCommand(program) {
         console.log(`Files seen: ${result.files_seen}`);
         console.log(`Files copied: ${result.files_copied}`);
         console.log(`Sources indexed: ${result.sources_indexed}`);
-        console.log(`Removed openspec/: ${result.removed_source_root ? 'yes' : 'no'}`);
+        console.log(`Removed legacy-spec/: ${result.removed_source_root ? 'yes' : 'no'}`);
         const categories = Object.entries(result.categories)
             .map(([name, count]) => `${name}=${count}`)
             .join(', ');