@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/commands/sdd/plugin.js

@@ -0,0 +1,158 @@
+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('--project-root <path>', 'Project root used for standalone storage-boundary validation')
+        .option('--language <language>', 'Technology language constraint')
+        .option('--framework <framework>', 'Technology framework constraint')
+        .option('--json', 'Return invocation plan as JSON')
+        .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,
+            project_root: options.projectRoot,
+            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'}`);
+    console.log(`Standalone runner: ${result.workcell_runner.standalone.status}`);
+    console.log(`Package governance: ${result.workcell_runner.standalone.package_governance.status}`);
+    console.log(`Storage boundary: ${result.workcell_runner.standalone.storage_boundary.status}`);
+    if (plan.envelope) {
+        console.log(`Operation: ${plan.envelope.operation_id}`);
+        console.log(`Plugin: ${plan.envelope.plugin_ref.id}@${plan.envelope.plugin_ref.version}`);
+        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.d.ts

@@ -2,6 +2,7 @@ import { type SddLanguage, type SddLayout } from '../../core/sdd/state.js';
 import type { FlowMode } from '../../core/sdd/types.js';
 export declare function parseCsvOption(value?: string): string[];
 export declare function resolveRoot(targetPath?: string): string;
+export declare function resolveInitRoot(targetPath?: string): string;
 export declare function parseLangOption(value?: string): SddLanguage | undefined;
 export declare function parseLayoutOption(value?: string): SddLayout | undefined;
 export declare function parseFlowModeOption(value?: string): FlowMode | undefined;

package/dist/commands/sdd/shared.js

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

package/dist/commands/spec.js

@@ -5,7 +5,7 @@ import { Validator } from '../core/validation/validator.js';
 import { isInteractive } from '../utils/interactive.js';
 import { getSpecIds } from '../utils/item-discovery.js';
 import { CLI_NAME } from '../core/branding.js';
-import { displayLegacyOpenSpecPath, resolveOpenSpecSubpath, } from '../core/sdd/services/legacy-capability.service.js';
+import { displayLegacySpecPath, resolveLegacySpecSubpath, } from '../core/sdd/services/legacy-capability.service.js';
 const SPECS_DIR = 'specs';
 function parseSpecFromFile(specPath, specId) {
     const content = readFileSync(specPath, 'utf-8');
@@ -30,7 +30,7 @@ function filterSpec(spec, options) {
         text: req.text,
         scenarios: includeScenarios ? req.scenarios : [],
     }));
-    const metadata = spec.metadata ?? { version: '1.0.0', format: 'openspec' };
+    const metadata = spec.metadata ?? { version: '1.0.0', format: 'codesdd' };
     return {
         name: spec.name,
         overview: spec.overview,
@@ -63,9 +63,9 @@ export class SpecCommand {
                 throw new Error('Missing required argument <spec-id>');
             }
         }
-        const specPath = resolveOpenSpecSubpath(process.cwd(), this.SPECS_DIR, specId, 'spec.md');
+        const specPath = resolveLegacySpecSubpath(process.cwd(), this.SPECS_DIR, specId, 'spec.md');
         if (!existsSync(specPath)) {
-            throw new Error(`Spec '${specId}' not found at ${displayLegacyOpenSpecPath('specs', specId, 'spec.md')}`);
+            throw new Error(`Spec '${specId}' not found at ${displayLegacySpecPath('specs', specId, 'spec.md')}`);
         }
         if (options.json) {
             if (options.requirements && options.requirement) {
@@ -79,7 +79,7 @@ export class SpecCommand {
                 overview: parsed.overview,
                 requirementCount: filtered.requirements.length,
                 requirements: filtered.requirements,
-                metadata: parsed.metadata ?? { version: '1.0.0', format: 'openspec' },
+                metadata: parsed.metadata ?? { version: '1.0.0', format: 'codesdd' },
             };
             console.log(JSON.stringify(output, null, 2));
             return;
@@ -90,7 +90,7 @@ export class SpecCommand {
 export function registerSpecCommand(rootProgram) {
     const specCommand = rootProgram
         .command('spec')
-        .description('Manage and view OpenSpec specifications');
+        .description('Manage and view specifications');
     // Deprecation notice for noun-based commands
     specCommand.hook('preAction', () => {
         console.error(`Warning: The "${CLI_NAME} spec ..." commands are deprecated. Prefer verb-first commands (e.g., "${CLI_NAME} show", "${CLI_NAME} validate --specs").`);
@@ -120,7 +120,7 @@ export function registerSpecCommand(rootProgram) {
         .option('--long', 'Show id and title with counts')
         .action((options) => {
         try {
-            const specsDir = resolveOpenSpecSubpath(process.cwd(), SPECS_DIR);
+            const specsDir = resolveLegacySpecSubpath(process.cwd(), SPECS_DIR);
             if (!existsSync(specsDir)) {
                 console.log('No items found');
                 return;
@@ -194,9 +194,9 @@ export function registerSpecCommand(rootProgram) {
                     throw new Error('Missing required argument <spec-id>');
                 }
             }
-            const specPath = resolveOpenSpecSubpath(process.cwd(), SPECS_DIR, specId, 'spec.md');
+            const specPath = resolveLegacySpecSubpath(process.cwd(), SPECS_DIR, specId, 'spec.md');
             if (!existsSync(specPath)) {
-                throw new Error(`Spec '${specId}' not found at ${displayLegacyOpenSpecPath('specs', specId, 'spec.md')}`);
+                throw new Error(`Spec '${specId}' not found at ${displayLegacySpecPath('specs', specId, 'spec.md')}`);
             }
             const validator = new Validator(options.strict);
             const report = await validator.validateSpec(specPath);

package/dist/commands/validate.js

@@ -4,7 +4,7 @@ import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
 import { getActiveChangeIds, getSpecIds } from '../utils/item-discovery.js';
 import { nearestMatches } from '../utils/match.js';
 import { CLI_NAME } from '../core/branding.js';
-import { resolveOpenSpecSubpath } from '../core/sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from '../core/sdd/services/legacy-capability.service.js';
 export class ValidateCommand {
     async execute(itemName, options = {}) {
         const interactive = isInteractive(options);
@@ -100,7 +100,7 @@ export class ValidateCommand {
     async validateByType(type, id, opts) {
         const validator = new Validator(opts.strict);
         if (type === 'change') {
-            const changeDir = resolveOpenSpecSubpath(process.cwd(), 'changes', id);
+            const changeDir = resolveLegacySpecSubpath(process.cwd(), 'changes', id);
             const start = Date.now();
             const report = await validator.validateChangeDeltaSpecs(changeDir);
             const durationMs = Date.now() - start;
@@ -109,7 +109,7 @@ export class ValidateCommand {
             process.exitCode = report.valid ? 0 : 1;
             return;
         }
-        const file = resolveOpenSpecSubpath(process.cwd(), 'specs', id, 'spec.md');
+        const file = resolveLegacySpecSubpath(process.cwd(), 'specs', id, 'spec.md');
         const start = Date.now();
         const report = await validator.validateSpec(file);
         const durationMs = Date.now() - start;
@@ -158,13 +158,13 @@ export class ValidateCommand {
         ]);
         const DEFAULT_CONCURRENCY = 6;
         const maxSuggestions = 5; // used by nearestMatches
-        const concurrency = normalizeConcurrency(opts.concurrency) ?? normalizeConcurrency(process.env.OPENSPEC_CONCURRENCY) ?? DEFAULT_CONCURRENCY;
+        const concurrency = normalizeConcurrency(opts.concurrency) ?? normalizeConcurrency(process.env.CODESDD_CONCURRENCY) ?? DEFAULT_CONCURRENCY;
         const validator = new Validator(opts.strict);
         const queue = [];
         for (const id of changeIds) {
             queue.push(async () => {
                 const start = Date.now();
-                const changeDir = resolveOpenSpecSubpath(process.cwd(), 'changes', id);
+                const changeDir = resolveLegacySpecSubpath(process.cwd(), 'changes', id);
                 const report = await validator.validateChangeDeltaSpecs(changeDir);
                 const durationMs = Date.now() - start;
                 return { id, type: 'change', valid: report.valid, issues: report.issues, durationMs };
@@ -173,7 +173,7 @@ export class ValidateCommand {
         for (const id of specIds) {
             queue.push(async () => {
                 const start = Date.now();
-                const file = resolveOpenSpecSubpath(process.cwd(), 'specs', id, 'spec.md');
+                const file = resolveLegacySpecSubpath(process.cwd(), 'specs', id, 'spec.md');
                 const report = await validator.validateSpec(file);
                 const durationMs = Date.now() - start;
                 return { id, type: 'spec', valid: report.valid, issues: report.issues, durationMs };

package/dist/commands/workflow/instructions.js

@@ -8,7 +8,7 @@ import ora from 'ora';
 import path from 'path';
 import * as fs from 'fs';
 import { loadChangeContext, generateInstructions, resolveSchema, } from '../../core/artifact-graph/index.js';
-import { resolveOpenSpecSubpath } from '../../core/sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from '../../core/sdd/services/legacy-capability.service.js';
 import { validateChangeExists, validateSchemaExists, } from './shared.js';
 import { CLI_NAME } from '../../core/branding.js';
 // -----------------------------------------------------------------------------
@@ -228,7 +228,7 @@ function artifactOutputExists(changeDir, generates) {
 export async function generateApplyInstructions(projectRoot, changeName, schemaName) {
     // loadChangeContext will auto-detect schema from metadata if not provided
     const context = loadChangeContext(projectRoot, changeName, schemaName);
-    const changeDir = resolveOpenSpecSubpath(projectRoot, 'changes', changeName);
+    const changeDir = resolveLegacySpecSubpath(projectRoot, 'changes', changeName);
     // Get the full schema to access the apply phase configuration
     const schema = resolveSchema(context.schemaName, projectRoot);
     const applyConfig = schema.apply;
@@ -272,19 +272,19 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
     let instruction;
     if (missingArtifacts.length > 0) {
         state = 'blocked';
-        instruction = `Cannot apply this change yet. Missing artifacts: ${missingArtifacts.join(', ')}.\nUse the openspec-continue-change skill or run ${CLI_NAME} instructions to create the missing artifacts first.`;
+        instruction = `Cannot apply this change yet. Missing artifacts: ${missingArtifacts.join(', ')}.\nUse the codesdd-continue-change skill or run ${CLI_NAME} instructions to create the missing artifacts first.`;
     }
     else if (tracksFile && !tracksFileExists) {
         // Tracking file configured but doesn't exist yet
         const tracksFilename = path.basename(tracksFile);
         state = 'blocked';
-        instruction = `The ${tracksFilename} file is missing and must be created.\nUse openspec-continue-change or run ${CLI_NAME} instructions to generate the tracking file.`;
+        instruction = `The ${tracksFilename} file is missing and must be created.\nUse codesdd-continue-change or run ${CLI_NAME} instructions to generate the tracking file.`;
     }
     else if (tracksFile && tracksFileExists && total === 0) {
         // Tracking file exists but contains no tasks
         const tracksFilename = path.basename(tracksFile);
         state = 'blocked';
-        instruction = `The ${tracksFilename} file exists but contains no tasks.\nAdd tasks to ${tracksFilename} or regenerate it with openspec-continue-change.`;
+        instruction = `The ${tracksFilename} file exists but contains no tasks.\nAdd tasks to ${tracksFilename} or regenerate it with codesdd-continue-change.`;
     }
     else if (tracksFile && remaining === 0 && total > 0) {
         state = 'all_done';
@@ -344,7 +344,7 @@ export function printApplyInstructionsText(instructions) {
         console.log('### ⚠️ Blocked');
         console.log();
         console.log(`Missing artifacts: ${missingArtifacts.join(', ')}`);
-        console.log(`Use the openspec-continue-change skill or run ${CLI_NAME} instructions to create these first.`);
+        console.log(`Use the codesdd-continue-change skill or run ${CLI_NAME} instructions to create these first.`);
         console.log();
     }
     // Context files (dynamically from schema)