@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/commands/completion.d.ts

@@ -13,7 +13,7 @@ interface CompleteOptions {
     type: string;
 }
 /**
- * Command for managing shell completions for OpenSpec CLI
+ * Command for managing shell completions for CodeSDD CLI
  */
 export declare class CompletionCommand {
     private completionProvider;

package/dist/commands/completion.js

@@ -6,7 +6,7 @@ import { CompletionProvider } from '../core/completions/completion-provider.js';
 import { getArchivedChangeIds } from '../utils/item-discovery.js';
 import { CLI_NAME } from '../core/branding.js';
 /**
- * Command for managing shell completions for OpenSpec CLI
+ * Command for managing shell completions for CodeSDD CLI
  */
 export class CompletionCommand {
     completionProvider;
@@ -180,7 +180,7 @@ export class CompletionCommand {
             };
             const configPath = configPaths[shell] || `${shell} configuration`;
             const confirmed = await confirm({
-                message: `Remove OpenSpec configuration from ${configPath}?`,
+                message: `Remove CodeSDD configuration from ${configPath}?`,
                 default: false,
             });
             if (!confirmed) {
@@ -237,6 +237,13 @@ export class CompletionCommand {
                     }
                     break;
                 }
+                case 'schemas': {
+                    const schemaNames = await this.completionProvider.getSchemaNames();
+                    for (const name of schemaNames) {
+                        console.log(`${name}\tworkflow schema`);
+                    }
+                    break;
+                }
                 default:
                     // Invalid type - silently exit with no output for graceful shell completion failure
                     process.exitCode = 1;

package/dist/commands/config.js

@@ -1,12 +1,18 @@
 import { spawn, execSync } from 'node:child_process';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
-import { getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, } from '../core/global-config.js';
-import { getNestedValue, setNestedValue, deleteNestedValue, coerceValue, formatValueYaml, validateConfigKeyPath, validateConfig, DEFAULT_CONFIG, } from '../core/config-schema.js';
+import { getGlobalConfigPath, getGlobalConfig, getGlobalCacheDir, getGlobalCacheTierDirs, ensureGlobalCacheLayout, readGlobalConfigRaw, parseTomlContent, saveGlobalConfig, } from '../core/global-config.js';
+import { getNestedValue, setNestedValue, deleteNestedValue, coerceValue, formatValueYaml, validateConfigKeyPath, validateConfig, isSensitiveConfigPath, redactConfigSecrets, DEFAULT_CONFIG, } from '../core/config-schema.js';
 import { CORE_WORKFLOWS, ALL_WORKFLOWS, getProfileWorkflows } from '../core/profiles.js';
-import { OPENSPEC_DIR_NAME } from '../core/config.js';
 import { hasProjectConfigDrift } from '../core/profile-sync-drift.js';
 import { CLI_NAME } from '../core/branding.js';
+import { resolveLegacySpecLiveRoot } from '../core/sdd/services/legacy-capability.service.js';
+import { buildRedisOperationalReport, deleteKeysByPrefix, RedisClientFactory, resolveRedisBoundaryConfig, runRedisBenchmark, } from '../core/sdd/coordination/index.js';
+import { buildCodesddStorageBoundaryReport } from '../core/sdd/runtime-boundary-contract.js';
+import { buildDeepAgentsOperationalPreflight, createDeepAgentsPolicySnapshot, } from '../core/sdd/deepagents/policy.js';
+import { detectShell } from '../utils/shell-detection.js';
+import { ZshInstaller } from '../core/completions/installers/zsh-installer.js';
 const WORKFLOW_PROMPT_META = {
     propose: {
         name: 'Propose change',
@@ -50,9 +56,37 @@ const WORKFLOW_PROMPT_META = {
     },
     onboard: {
         name: 'Onboard',
-        description: 'Guided onboarding flow for OpenSpec',
+        description: 'Guided onboarding flow for CodeSDD',
     },
 };
+function resolveHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+function buildCodesddEnvTemplate() {
+    return [
+        '#!/usr/bin/env zsh',
+        '# CodeSDD global runtime profile (non-secret settings only).',
+        'export CODESDD_AGENT_PROVIDER="${CODESDD_AGENT_PROVIDER:-deepagents}"',
+        'export CODESDD_DEEPAGENTS_ENABLED="${CODESDD_DEEPAGENTS_ENABLED:-false}"',
+        'export CODESDD_DEEPAGENTS_RUNTIME="${CODESDD_DEEPAGENTS_RUNTIME:-disabled}"',
+        'export CODESDD_AGENT_NETWORK_POLICY="${CODESDD_AGENT_NETWORK_POLICY:-disabled}"',
+        'export CODESDD_DEEPAGENTS_PROVIDER_SMOKE="${CODESDD_DEEPAGENTS_PROVIDER_SMOKE:-0}"',
+        'export CODESDD_REDIS_ENABLED="${CODESDD_REDIS_ENABLED:-false}"',
+        'export CODESDD_REDIS_NAMESPACE="${CODESDD_REDIS_NAMESPACE:-codesdd}"',
+        '# export CODESDD_REDIS_URL="redis://localhost:6379"',
+        '# export CODESDD_REDIS_FALLBACK="filesystem"',
+        '# Optional live-provider launcher references. Keep values in your shell,',
+        '# password manager, CI secret store, or another untracked launcher context.',
+        '# export CODESDD_DEEPAGENTS_ENABLED=true',
+        '# export CODESDD_DEEPAGENTS_RUNTIME=deepagents-js',
+        '# export CODESDD_AGENT_NETWORK_POLICY=restricted',
+        '# export CODESDD_DEEPAGENTS_MODEL="azure-openai:gpt-4o-mini"',
+        '# export CODESDD_AGENT_ALLOWED_DOMAINS="api.openai.com"',
+        '# export AZURE_OPENAI_ENDPOINT="https://example-resource.openai.azure.com/"',
+        '# export AZURE_OPENAI_API_KEY="<secret-from-manager>"',
+        '',
+    ].join('\n');
+}
 function isPromptCancellationError(error) {
     return (error instanceof Error &&
         (error.name === 'ExitPromptError' || error.message.includes('force closed the prompt with SIGINT')));
@@ -134,8 +168,8 @@ export function diffProfileState(before, after) {
     };
 }
 function maybeWarnConfigDrift(projectDir, state, colorize) {
-    const openspecDir = path.join(projectDir, OPENSPEC_DIR_NAME);
-    if (!fs.existsSync(openspecDir)) {
+    const codesddDir = resolveLegacySpecLiveRoot(projectDir);
+    if (!fs.existsSync(codesddDir)) {
         return;
     }
     if (!hasProjectConfigDrift(projectDir, state.workflows, state.delivery)) {
@@ -151,7 +185,7 @@ function maybeWarnConfigDrift(projectDir, state, colorize) {
 export function registerConfigCommand(program) {
     const configCmd = program
         .command('config')
-        .description('View and modify global OpenSpec configuration')
+        .description('View and modify global CodeSDD configuration')
         .option('--scope <scope>', 'Config scope (only "global" supported currently)')
         .hook('preAction', (thisCommand) => {
         const opts = thisCommand.opts();
@@ -167,6 +201,249 @@ export function registerConfigCommand(program) {
         .action(() => {
         console.log(getGlobalConfigPath());
     });
+    // config init
+    configCmd
+        .command('init')
+        .description('Initialize ~/.codesdd runtime files and idempotent shell integration')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const homeDir = resolveHomeDir();
+        const configPath = getGlobalConfigPath();
+        const envPath = path.join(homeDir, '.codesdd', 'env.zsh');
+        if (!fs.existsSync(configPath)) {
+            saveGlobalConfig(getGlobalConfig());
+        }
+        const tierPaths = ensureGlobalCacheLayout();
+        const envTemplate = buildCodesddEnvTemplate();
+        if (!fs.existsSync(path.dirname(envPath))) {
+            fs.mkdirSync(path.dirname(envPath), { recursive: true });
+        }
+        fs.writeFileSync(envPath, envTemplate, { encoding: 'utf-8', mode: 0o600 });
+        try {
+            fs.chmodSync(envPath, 0o600);
+        }
+        catch {
+            // best effort on non-POSIX filesystems
+        }
+        const detectedShell = detectShell().shell;
+        let zshrcConfigured = false;
+        if (detectedShell === 'zsh' || process.env.SHELL?.toLowerCase().includes('zsh')) {
+            const installer = new ZshInstaller(homeDir);
+            zshrcConfigured = await installer.ensureCodesddEnvSource(envPath);
+        }
+        const payload = {
+            schema_version: 1,
+            config_path: configPath,
+            env_path: envPath,
+            cache_root: getGlobalCacheDir(),
+            cache_tiers: Object.keys(tierPaths),
+            shell_detected: detectedShell ?? 'unknown',
+            zshrc_configured: zshrcConfigured,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        console.log(`Config file: ${configPath}`);
+        console.log(`Shell profile: ${envPath}`);
+        console.log(`Cache root: ${payload.cache_root}`);
+        console.log(`Cache tiers: ${payload.cache_tiers.join(', ')}`);
+        if (detectedShell === 'zsh') {
+            console.log('Zsh source block ensured for ~/.codesdd/env.zsh.');
+        }
+        else {
+            console.log('Shell source block was not changed automatically (non-zsh or undetected shell).');
+        }
+    });
+    // config doctor
+    configCmd
+        .command('doctor')
+        .description('Run operational readiness checks for DeepAgents/Azure, cache, and Redis boundary')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const snapshot = createDeepAgentsPolicySnapshot(process.env);
+        const preflight = buildDeepAgentsOperationalPreflight(snapshot, process.env);
+        const redisReport = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        const cacheTiers = getGlobalCacheTierDirs();
+        const storageBoundary = buildCodesddStorageBoundaryReport(process.cwd());
+        const report = {
+            schema_version: 1,
+            global_config_path: getGlobalConfigPath(),
+            cache: {
+                root: getGlobalCacheDir(),
+                tiers: Object.keys(cacheTiers),
+            },
+            storage_boundary: storageBoundary,
+            redis: {
+                requested: redisReport.requested,
+                namespace: redisReport.namespace,
+                status: redisReport.status,
+                fallback: redisReport.fallback,
+                redacted_url: redisReport.redacted_url,
+                latency_ms: redisReport.latency_ms,
+                reason: redisReport.reason,
+                validation_errors: redisReport.validation_errors,
+                warnings: redisReport.warnings,
+            },
+            deepagents: preflight,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`Global config: ${report.global_config_path}`);
+            console.log(`Cache root: ${report.cache.root}`);
+            console.log(`Cache tiers: ${report.cache.tiers.join(', ')}`);
+            console.log(`Project state: ${report.storage_boundary.project_state_dir}`);
+            console.log(`Global runtime: ${report.storage_boundary.global_runtime_dir}`);
+            console.log(`Redis: ${report.redis.status} (namespace=${report.redis.namespace}, fallback=${report.redis.fallback})`);
+            if (report.redis.redacted_url) {
+                console.log(`Redis URL: ${report.redis.redacted_url}`);
+            }
+            if (report.redis.latency_ms !== undefined) {
+                console.log(`Redis latency: ${report.redis.latency_ms}ms`);
+            }
+            console.log(`Redis reason: ${report.redis.reason}`);
+            for (const warning of report.redis.warnings) {
+                console.log(`- ${warning}`);
+            }
+            for (const error of report.redis.validation_errors) {
+                console.log(`- ${error}`);
+            }
+            console.log(`DeepAgents preflight: ${preflight.status}`);
+            for (const reason of preflight.reasons) {
+                console.log(`- ${reason}`);
+            }
+        }
+        if (preflight.status === 'blocked' || redisReport.status === 'blocked') {
+            process.exitCode = 1;
+        }
+    });
+    const redisCmd = configCmd
+        .command('redis')
+        .description('Inspect and operate the optional Redis runtime backend');
+    redisCmd
+        .command('status')
+        .description('Show Redis runtime status')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const report = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(`Redis: ${report.status}`);
+        console.log(`Namespace: ${report.namespace}`);
+        console.log(`Fallback: ${report.fallback}`);
+        if (report.redacted_url)
+            console.log(`URL: ${report.redacted_url}`);
+        if (report.latency_ms !== undefined)
+            console.log(`Latency: ${report.latency_ms}ms`);
+        console.log(`Reason: ${report.reason}`);
+        if (report.status === 'blocked')
+            process.exitCode = 1;
+    });
+    redisCmd
+        .command('ping')
+        .description('Ping Redis using the effective CodeSDD configuration')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const report = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`Redis ping: ${report.status}`);
+            if (report.latency_ms !== undefined)
+                console.log(`Latency: ${report.latency_ms}ms`);
+            console.log(report.reason);
+        }
+        if (report.status !== 'ready')
+            process.exitCode = 1;
+    });
+    redisCmd
+        .command('bench')
+        .description('Run a short redacted Redis latency benchmark')
+        .option('--json', 'Output as JSON')
+        .option('--iterations <n>', 'Number of benchmark iterations')
+        .action(async (options) => {
+        const iterations = options.iterations ? Number.parseInt(options.iterations, 10) : undefined;
+        const report = await runRedisBenchmark({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+            iterations,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`Redis benchmark: ${report.status}`);
+            console.log(`Namespace: ${report.namespace}`);
+            console.log(`Iterations: ${report.iterations}`);
+            if (report.p50_ms !== undefined)
+                console.log(`p50: ${report.p50_ms}ms`);
+            if (report.p95_ms !== undefined)
+                console.log(`p95: ${report.p95_ms}ms`);
+            console.log(`Reason: ${report.reason}`);
+        }
+        if (report.status !== 'ready')
+            process.exitCode = 1;
+    });
+    redisCmd
+        .command('flush-namespace')
+        .description('Delete only keys under the effective CodeSDD Redis namespace')
+        .option('--json', 'Output as JSON')
+        .option('-y, --yes', 'Confirm namespace-scoped deletion')
+        .action(async (options) => {
+        const config = resolveRedisBoundaryConfig(process.env, getGlobalConfig());
+        if (!options.yes) {
+            console.error('Error: --yes is required to flush the CodeSDD Redis namespace.');
+            process.exitCode = 1;
+            return;
+        }
+        const report = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        if (report.status !== 'ready') {
+            if (options.json) {
+                console.log(JSON.stringify({ ...report, deleted_keys: 0 }, null, 2));
+            }
+            else {
+                console.log(`Redis namespace flush skipped: ${report.reason}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const factory = new RedisClientFactory(config);
+        try {
+            const deleted = await deleteKeysByPrefix(factory, `${config.namespace}:`);
+            const payload = {
+                schema_version: 1,
+                namespace: config.namespace,
+                deleted_keys: deleted,
+                status: 'ok',
+            };
+            if (options.json) {
+                console.log(JSON.stringify(payload, null, 2));
+            }
+            else {
+                console.log(`Deleted ${deleted} Redis key(s) under namespace ${config.namespace}.`);
+            }
+        }
+        finally {
+            await factory.close();
+        }
+    });
     // config list
     configCmd
         .command('list')
@@ -174,22 +451,20 @@ export function registerConfigCommand(program) {
         .option('--json', 'Output as JSON')
         .action((options) => {
         const config = getGlobalConfig();
+        const redactedConfig = redactConfigSecrets(config);
         if (options.json) {
-            console.log(JSON.stringify(config, null, 2));
+            console.log(JSON.stringify(redactedConfig, null, 2));
         }
         else {
             // Read raw config to determine which values are explicit vs defaults
-            const configPath = getGlobalConfigPath();
             let rawConfig = {};
             try {
-                if (fs.existsSync(configPath)) {
-                    rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                }
+                rawConfig = readGlobalConfigRaw();
             }
             catch {
                 // If reading fails, treat all as defaults
             }
-            console.log(formatValueYaml(config));
+            console.log(formatValueYaml(redactedConfig));
             // Annotate profile settings
             const profileSource = rawConfig.profile !== undefined ? '(explicit)' : '(default)';
             const deliverySource = rawConfig.delivery !== undefined ? '(explicit)' : '(default)';
@@ -205,6 +480,23 @@ export function registerConfigCommand(program) {
             else {
                 console.log(`  workflows: (none)`);
             }
+            const cacheTiers = getGlobalCacheTierDirs();
+            console.log(`\nCache settings:`);
+            console.log(`  root: ${getGlobalCacheDir()}`);
+            console.log(`  tiers: ${Object.keys(cacheTiers).join(', ')}`);
+            const redisBoundary = resolveRedisBoundaryConfig(process.env, config);
+            const redisStatus = redisBoundary.validationErrors.length > 0
+                ? 'blocked'
+                : redisBoundary.requested
+                    ? 'requested-unavailable or ready after ping'
+                    : 'disabled';
+            console.log(`\nRedis boundary:`);
+            console.log(`  status: ${redisStatus}`);
+            console.log(`  namespace: ${redisBoundary.namespace}`);
+            console.log(`  fallback: ${redisBoundary.fallback}`);
+            if (redisBoundary.redactedUrl) {
+                console.log(`  url: ${redisBoundary.redactedUrl}`);
+            }
         }
     });
     // config get
@@ -218,6 +510,10 @@ export function registerConfigCommand(program) {
             process.exitCode = 1;
             return;
         }
+        if (isSensitiveConfigPath(key)) {
+            console.log('[REDACTED]');
+            return;
+        }
         if (typeof value === 'object' && value !== null) {
             console.log(JSON.stringify(value));
         }
@@ -257,7 +553,11 @@ export function registerConfigCommand(program) {
         // Apply changes and save
         setNestedValue(config, key, coercedValue);
         saveGlobalConfig(config);
-        const displayValue = typeof coercedValue === 'string' ? `"${coercedValue}"` : String(coercedValue);
+        const displayValue = isSensitiveConfigPath(key)
+            ? '[REDACTED]'
+            : typeof coercedValue === 'string'
+                ? `"${coercedValue}"`
+                : String(coercedValue);
         console.log(`Set ${key} = ${displayValue}`);
     });
     // config unset
@@ -351,7 +651,7 @@ export function registerConfigCommand(program) {
         });
         try {
             const rawConfig = fs.readFileSync(configPath, 'utf-8');
-            const parsedConfig = JSON.parse(rawConfig);
+            const parsedConfig = parseTomlContent(rawConfig);
             const validation = validateConfig(parsedConfig);
             if (!validation.success) {
                 console.error(`Error: Invalid configuration - ${validation.error}`);
@@ -363,7 +663,7 @@ export function registerConfigCommand(program) {
                 console.error(`Error: Config file not found at ${configPath}`);
             }
             else if (error instanceof SyntaxError) {
-                console.error(`Error: Invalid JSON in ${configPath}`);
+                console.error(`Error: Invalid TOML in ${configPath}`);
                 console.error(error.message);
             }
             else {
@@ -377,7 +677,7 @@ export function registerConfigCommand(program) {
         .command('profile [preset]')
         .description('Configure workflow profile (interactive picker or preset shortcut)')
         .action(async (preset) => {
-        // Preset shortcut: `openspec config profile core`
+        // Preset shortcut: `codesdd config profile core`
         if (preset === 'core') {
             const config = getGlobalConfig();
             config.profile = 'core';
@@ -517,10 +817,10 @@ export function registerConfigCommand(program) {
             config.delivery = nextState.delivery;
             config.workflows = nextState.workflows;
             saveGlobalConfig(config);
-            // Check if inside an OpenSpec project
+            // Check if inside a legacy spec compatibility project
             const projectDir = process.cwd();
-            const openspecDir = path.join(projectDir, OPENSPEC_DIR_NAME);
-            if (fs.existsSync(openspecDir)) {
+            const codesddDir = resolveLegacySpecLiveRoot(projectDir);
+            if (fs.existsSync(codesddDir)) {
                 const applyNow = await confirm({
                     message: 'Apply changes to this project now?',
                     default: true,

package/dist/commands/feedback.js

@@ -30,7 +30,7 @@ function isGhAuthenticated() {
     }
 }
 /**
- * Get OpenSDD version from package.json
+ * Get CodeSDD version from package.json
  */
 function getVersion() {
     try {

package/dist/commands/schema.d.ts

@@ -1,6 +1,69 @@
 import { Command } from 'commander';
+/**
+ * Schema source location type
+ */
+export type SchemaSource = 'project' | 'user' | 'package';
+/**
+ * Result of checking a schema location
+ */
+export interface SchemaLocation {
+    source: SchemaSource;
+    path: string;
+    exists: boolean;
+}
+/**
+ * Schema resolution info with shadowing details
+ */
+export interface SchemaResolution {
+    name: string;
+    source: SchemaSource;
+    path: string;
+    shadows: Array<{
+        source: SchemaSource;
+        path: string;
+    }>;
+}
+/**
+ * Validation issue structure
+ */
+export interface ValidationIssue {
+    level: 'error' | 'warning';
+    path: string;
+    message: string;
+}
+/**
+ * Check all three locations for a schema and return which ones exist.
+ */
+export declare function checkAllLocations(name: string, projectRoot: string): SchemaLocation[];
+/**
+ * Get resolution info for a schema including shadow detection.
+ */
+export declare function getSchemaResolution(name: string, projectRoot: string): SchemaResolution | null;
+/**
+ * Get all schemas with resolution info.
+ */
+export declare function getAllSchemasWithResolution(projectRoot: string): SchemaResolution[];
+/**
+ * Validate a schema and return issues.
+ */
+export declare function validateSchema(schemaDir: string, verbose?: boolean): {
+    valid: boolean;
+    issues: ValidationIssue[];
+};
+/**
+ * Validate schema name format (kebab-case).
+ */
+export declare function isValidSchemaName(name: string): boolean;
+/**
+ * Copy a directory recursively.
+ */
+export declare function copyDirRecursive(src: string, dest: string): void;
 /**
  * Register the schema command and all its subcommands.
  */
 export declare function registerSchemaCommand(program: Command): void;
+/**
+ * Create default template content for an artifact.
+ */
+export declare function createDefaultTemplate(artifactId: string): string;
 //# sourceMappingURL=schema.d.ts.map

package/dist/commands/schema.js

@@ -4,11 +4,11 @@ import ora from 'ora';
 import { stringify as stringifyYaml } from 'yaml';
 import { getSchemaDir, getProjectSchemasDir, getUserSchemasDir, getPackageSchemasDir, listSchemas, } from '../core/artifact-graph/resolver.js';
 import { parseSchema, SchemaValidationError } from '../core/artifact-graph/schema.js';
-import { resolveOpenSpecLiveSubpath } from '../core/sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecLiveSubpath } from '../core/sdd/services/legacy-capability.service.js';
 /**
  * Check all three locations for a schema and return which ones exist.
  */
-function checkAllLocations(name, projectRoot) {
+export function checkAllLocations(name, projectRoot) {
     const locations = [];
     // Project location
     const projectDir = path.join(getProjectSchemasDir(projectRoot), name);
@@ -39,7 +39,7 @@ function checkAllLocations(name, projectRoot) {
 /**
  * Get resolution info for a schema including shadow detection.
  */
-function getSchemaResolution(name, projectRoot) {
+export function getSchemaResolution(name, projectRoot) {
     const locations = checkAllLocations(name, projectRoot);
     const existingLocations = locations.filter((loc) => loc.exists);
     if (existingLocations.length === 0) {
@@ -60,7 +60,7 @@ function getSchemaResolution(name, projectRoot) {
 /**
  * Get all schemas with resolution info.
  */
-function getAllSchemasWithResolution(projectRoot) {
+export function getAllSchemasWithResolution(projectRoot) {
     const schemaNames = listSchemas(projectRoot);
     const results = [];
     for (const name of schemaNames) {
@@ -74,7 +74,7 @@ function getAllSchemasWithResolution(projectRoot) {
 /**
  * Validate a schema and return issues.
  */
-function validateSchema(schemaDir, verbose = false) {
+export function validateSchema(schemaDir, verbose = false) {
     const issues = [];
     const schemaPath = path.join(schemaDir, 'schema.yaml');
     // Check schema.yaml exists
@@ -157,13 +157,13 @@ function validateSchema(schemaDir, verbose = false) {
 /**
  * Validate schema name format (kebab-case).
  */
-function isValidSchemaName(name) {
+export function isValidSchemaName(name) {
     return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name);
 }
 /**
  * Copy a directory recursively.
  */
-function copyDirRecursive(src, dest) {
+export function copyDirRecursive(src, dest) {
     fs.mkdirSync(dest, { recursive: true });
     const entries = fs.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
@@ -592,12 +592,12 @@ export function registerSchemaCommand(program) {
                         console.log(JSON.stringify({
                             created: false,
                             error: `Schema '${name}' already exists`,
-                            suggestion: 'Use --force to overwrite or "openspec schema fork" to copy',
+                            suggestion: 'Use --force to overwrite or "codesdd schema fork" to copy',
                         }, null, 2));
                     }
                     else {
                         console.error(`Error: Schema '${name}' already exists at ${schemaDir}`);
-                        console.error('Use --force to overwrite or "openspec schema fork" to copy');
+                        console.error('Use --force to overwrite or "codesdd schema fork" to copy');
                     }
                     process.exitCode = 1;
                     return;
@@ -734,7 +734,7 @@ export function registerSchemaCommand(program) {
             }
             // Update config if --default
             if (options?.default) {
-                const configPath = resolveOpenSpecLiveSubpath(projectRoot, 'config.yaml');
+                const configPath = resolveLegacySpecLiveSubpath(projectRoot, 'config.yaml');
                 if (fs.existsSync(configPath)) {
                     const { parse: parseYaml, stringify: stringifyYaml2 } = await import('yaml');
                     const configContent = fs.readFileSync(configPath, 'utf-8');
@@ -771,7 +771,7 @@ export function registerSchemaCommand(program) {
                 console.log(`\nNext steps:`);
                 console.log(`  1. Edit ${schemaDir}/schema.yaml to customize artifacts`);
                 console.log(`  2. Modify templates in the schema directory`);
-                console.log(`  3. Use with: openspec new --schema ${name}`);
+                console.log(`  3. Use with: codesdd new --schema ${name}`);
             }
         }
         catch (error) {
@@ -793,7 +793,7 @@ export function registerSchemaCommand(program) {
 /**
  * Create default template content for an artifact.
  */
-function createDefaultTemplate(artifactId) {
+export function createDefaultTemplate(artifactId) {
     switch (artifactId) {
         case 'proposal':
             return `## Why

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

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