@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/cli/program.js

@@ -0,0 +1,645 @@
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import ora from 'ora';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { AI_TOOLS } from '../core/config.js';
+import { CLI_NAME } from '../core/branding.js';
+import { UpdateCommand } from '../core/update.js';
+import { ListCommand } from '../core/list.js';
+import { ArchiveCommand } from '../core/archive.js';
+import { ViewCommand } from '../core/view.js';
+import { registerSpecCommand } from '../commands/spec.js';
+import { ChangeCommand } from '../commands/change.js';
+import { ValidateCommand } from '../commands/validate.js';
+import { ShowCommand } from '../commands/show.js';
+import { CompletionCommand } from '../commands/completion.js';
+import { FeedbackCommand } from '../commands/feedback.js';
+import { registerConfigCommand } from '../commands/config.js';
+import { registerSchemaCommand } from '../commands/schema.js';
+import { registerSddCommand } from '../commands/sdd.js';
+import { statusCommand, instructionsCommand, applyInstructionsCommand, templatesCommand, schemasCommand, newChangeCommand, DEFAULT_SCHEMA, } from '../commands/workflow/index.js';
+import { maybeShowTelemetryNotice, trackCommand, trackCommandCompleted, shutdown } from '../telemetry/index.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
+/**
+ * Get the full command path for nested commands.
+ * For example: 'change show' -> 'change:show'
+ */
+export function getCommandPath(command) {
+    const names = [];
+    let current = command;
+    while (current) {
+        const name = current.name();
+        if (name && name !== CLI_NAME) {
+            names.unshift(name);
+        }
+        current = current.parent;
+    }
+    return names.join(':') || CLI_NAME;
+}
+export function createCliProgram(options = {}) {
+    const program = new Command();
+    const telemetryEnabled = options.telemetry ?? true;
+    if (options.output) {
+        program.configureOutput(options.output);
+    }
+    if (options.exitOverride) {
+        program.exitOverride();
+    }
+    program
+        .name(CLI_NAME)
+        .description('AI-native system for spec-driven development')
+        .version(version);
+    // Global options
+    program.option('--no-color', 'Disable color output');
+    program.option('--no-telemetry', 'Disable telemetry for this run');
+    let currentCommandTiming = null;
+    // Apply global flags and telemetry before any command runs
+    // Note: preAction receives (thisCommand, actionCommand) where:
+    // - thisCommand: the command where hook was added (root program)
+    // - actionCommand: the command actually being executed (subcommand)
+    program.hook('preAction', async (thisCommand, actionCommand) => {
+        const opts = thisCommand.opts();
+        if (opts.color === false) {
+            process.env.NO_COLOR = '1';
+        }
+        if (opts.telemetry === false) {
+            process.env.CODESDD_TELEMETRY = '0';
+            process.env.CODESDD_TELEMETRY = '0';
+        }
+        if (!telemetryEnabled) {
+            return;
+        }
+        // Show first-run telemetry notice (if not seen)
+        await maybeShowTelemetryNotice();
+        // Track command execution (use actionCommand to get the actual subcommand)
+        const commandPath = getCommandPath(actionCommand);
+        currentCommandTiming = {
+            commandPath,
+            startedAt: Date.now(),
+        };
+        await trackCommand(commandPath, version);
+    });
+    // Shutdown telemetry after command completes
+    program.hook('postAction', async () => {
+        if (!telemetryEnabled) {
+            return;
+        }
+        if (currentCommandTiming) {
+            await trackCommandCompleted(currentCommandTiming.commandPath, version, Date.now() - currentCommandTiming.startedAt, 'success');
+            currentCommandTiming = null;
+        }
+        await shutdown();
+    });
+    const availableToolIds = AI_TOOLS.filter((tool) => tool.skillsDir).map((tool) => tool.value);
+    const toolsOptionDescription = `Configure AI tools non-interactively. Use "all", "none", or a comma-separated list of: ${availableToolIds.join(', ')}`;
+    function normalizeSddLang(value) {
+        if (!value)
+            return undefined;
+        if (value === 'pt-BR' || value === 'en-US')
+            return value;
+        throw new Error(`Invalid value for --lang: "${value}". Use pt-BR or en-US.`);
+    }
+    function normalizeSddLayout(value) {
+        if (!value)
+            return undefined;
+        if (value === 'legacy' || value === 'pt-BR' || value === 'en-US')
+            return value;
+        throw new Error(`Invalid value for --layout: "${value}". Use en-US, legacy, or pt-BR.`);
+    }
+    async function runInitCommand(targetPath, options) {
+        // Validate that the path is a valid directory
+        const resolvedPath = path.resolve(targetPath);
+        try {
+            const stats = await fs.stat(resolvedPath);
+            if (!stats.isDirectory()) {
+                throw new Error(`Path "${targetPath}" is not a directory`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                if (!options?.silent) {
+                    console.log(`Directory "${targetPath}" doesn't exist, it will be created.`);
+                }
+            }
+            else if (error.message && error.message.includes('not a directory')) {
+                throw error;
+            }
+            else {
+                throw new Error(`Cannot access path "${targetPath}": ${error.message}`);
+            }
+        }
+        const { InitCommand } = await import('../core/init.js');
+        const initCommand = new InitCommand({
+            tools: options?.tools,
+            force: options?.force,
+            profile: options?.profile,
+            interactive: options?.interactive,
+            allowNoToolsFallback: options?.allowNoToolsFallback,
+            silent: options?.silent,
+        });
+        await initCommand.execute(targetPath);
+    }
+    async function runFullInstallCommand(targetPath, options) {
+        await runInitCommand(targetPath, options);
+        const { SddInitCommand } = await import('../core/sdd/init.js');
+        const sddInitCommand = new SddInitCommand();
+        await sddInitCommand.execute(targetPath, {
+            frontendEnabled: options?.frontend ?? true,
+            language: normalizeSddLang(options?.lang),
+            layout: normalizeSddLayout(options?.layout),
+            render: true,
+        });
+    }
+    async function runReloadCommand(targetPath, options) {
+        await runInitCommand(targetPath, {
+            tools: options?.tools,
+            force: options?.force,
+            profile: options?.profile,
+            allowNoToolsFallback: true,
+            interactive: false,
+            silent: true,
+        });
+        const language = normalizeSddLang(options?.lang);
+        const layout = normalizeSddLayout(options?.layout);
+        const frontendEnabled = options?.frontend ?? true;
+        const render = options?.render ?? true;
+        const { SddInitCommand, SddInitContextCommand } = await import('../core/sdd/init.js');
+        const sddInitCommand = new SddInitCommand();
+        const initResult = await sddInitCommand.execute(targetPath, {
+            frontendEnabled,
+            language,
+            layout,
+            render: false,
+        });
+        const contextCommand = new SddInitContextCommand();
+        const contextResult = await contextCommand.execute(targetPath, {
+            mode: 'merge',
+            deep: true,
+            render,
+            frontendEnabled,
+            language,
+            layout,
+        });
+        return {
+            memoryDir: initResult.memoryDir,
+            frontendEnabled: initResult.frontendEnabled,
+            rendered: contextResult.rendered,
+            skillsSeeded: initResult.skillsSeeded,
+            localSkillsMaterialized: initResult.localSkillsMaterialized,
+            syncedTools: initResult.syncedTools,
+            contextUpdated: contextResult.sddBootstrap.updated,
+        };
+    }
+    program
+        .command('init [path]')
+        .description('Initialize CodeSDD in your project')
+        .alias('iniciar')
+        .option('--tools <tools>', toolsOptionDescription)
+        .option('--force', 'Auto-cleanup legacy files without prompting')
+        .option('--profile <profile>', 'Override global config profile (core or custom)')
+        .action(async (targetPath = '.', options) => {
+        try {
+            await runInitCommand(targetPath, options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    program
+        .command('reload [path]')
+        .description('Reload CodeSDD project files using the installed CLI version')
+        .alias('recarregar')
+        .option('--tools <tools>', toolsOptionDescription)
+        .option('--force', 'Auto-cleanup legacy files without prompting')
+        .option('--profile <profile>', 'Override global config profile (core or custom)')
+        .option('--lang <lang>', 'SDD language: pt-BR|en-US')
+        .option('--layout <layout>', 'SDD folder layout: en-US|legacy|pt-BR')
+        .option('--no-frontend', 'Disable frontend module in the SDD bootstrap')
+        .option('--no-render', 'Do not render Markdown views after reload')
+        .option('--json', 'Emit reload result as JSON')
+        .action(async (targetPath = '.', options) => {
+        try {
+            const result = await runReloadCommand(targetPath, options);
+            if (options?.json) {
+                console.log(JSON.stringify({ version, ...result }, null, 2));
+                return;
+            }
+            console.log(`CodeSDD project reloaded with CLI v${version}.`);
+            console.log(`Memory directory: ${result.memoryDir}`);
+            console.log(`Frontend module: ${result.frontendEnabled ? 'enabled' : 'disabled'}`);
+            console.log(`Views generated: ${result.rendered ? 'yes' : 'no'}`);
+            console.log(`Curated skills loaded: ${result.skillsSeeded}`);
+            console.log(`Local skills generated: ${result.localSkillsMaterialized}`);
+            console.log(`Tools synced: ${result.syncedTools.length > 0 ? result.syncedTools.join(', ') : 'none detected'}`);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    program
+        .command('install [path]')
+        .description('Install CodeSDD completely in your project (base + SDD)')
+        .alias('instalar')
+        .option('--tools <tools>', toolsOptionDescription)
+        .option('--force', 'Auto-cleanup legacy files without prompting')
+        .option('--profile <profile>', 'Override global config profile (core or custom)')
+        .option('--lang <lang>', 'SDD language: pt-BR|en-US')
+        .option('--layout <layout>', 'SDD folder layout: en-US|legacy|pt-BR')
+        .option('--no-frontend', 'Disable frontend module in the SDD bootstrap')
+        .action(async (targetPath = '.', options) => {
+        try {
+            await runFullInstallCommand(targetPath, options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Hidden alias: 'experimental' -> 'init' for backwards compatibility
+    program
+        .command('experimental', { hidden: true })
+        .description('Alias for init (deprecated)')
+        .option('--tool <tool-id>', 'Target AI tool (maps to --tools)')
+        .option('--no-interactive', 'Disable interactive prompts')
+        .action(async (options) => {
+        try {
+            console.log(`Note: "${CLI_NAME} experimental" is deprecated. Use "${CLI_NAME} init" instead.`);
+            const { InitCommand } = await import('../core/init.js');
+            const initCommand = new InitCommand({
+                tools: options?.tool,
+                interactive: options?.noInteractive === true ? false : undefined,
+            });
+            await initCommand.execute('.');
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    program
+        .command('update [path]')
+        .description('Update CodeSDD instruction files')
+        .option('--force', 'Force update even when tools are up to date')
+        .action(async (targetPath = '.', options) => {
+        try {
+            const resolvedPath = path.resolve(targetPath);
+            const updateCommand = new UpdateCommand({ force: options?.force });
+            await updateCommand.execute(resolvedPath);
+        }
+        catch (error) {
+            console.log(); // Empty line for spacing
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    program
+        .command('list')
+        .description('List items (changes by default). Use --specs to list specs.')
+        .option('--specs', 'List specs instead of changes')
+        .option('--changes', 'List changes explicitly (default)')
+        .option('--sort <order>', 'Sort order: "recent" (default) or "name"', 'recent')
+        .option('--json', 'Output as JSON (for programmatic use)')
+        .action(async (options) => {
+        try {
+            const listCommand = new ListCommand();
+            const mode = options?.specs ? 'specs' : 'changes';
+            const sort = options?.sort === 'name' ? 'name' : 'recent';
+            await listCommand.execute('.', mode, { sort, json: options?.json });
+        }
+        catch (error) {
+            console.log(); // Empty line for spacing
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    program
+        .command('view')
+        .description('Display an interactive dashboard of specs and changes')
+        .action(async () => {
+        try {
+            const viewCommand = new ViewCommand();
+            await viewCommand.execute('.');
+        }
+        catch (error) {
+            console.log(); // Empty line for spacing
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Change command with subcommands
+    const changeCmd = program
+        .command('change')
+        .description('Manage legacy change proposals');
+    // Deprecation notice for noun-based commands
+    changeCmd.hook('preAction', () => {
+        console.error(`Warning: The "${CLI_NAME} change ..." commands are deprecated. Prefer verb-first commands (e.g., "${CLI_NAME} list", "${CLI_NAME} validate --changes").`);
+    });
+    changeCmd
+        .command('show [change-name]')
+        .description('Show a change proposal in JSON or markdown format')
+        .option('--json', 'Output as JSON')
+        .option('--deltas-only', 'Show only deltas (JSON only)')
+        .option('--requirements-only', 'Alias for --deltas-only (deprecated)')
+        .option('--no-interactive', 'Disable interactive prompts')
+        .action(async (changeName, options) => {
+        try {
+            const changeCommand = new ChangeCommand();
+            await changeCommand.show(changeName, options);
+        }
+        catch (error) {
+            console.error(`Error: ${error.message}`);
+            process.exitCode = 1;
+        }
+    });
+    changeCmd
+        .command('list')
+        .description('List all active changes (DEPRECATED: use "codesdd list" instead)')
+        .option('--json', 'Output as JSON')
+        .option('--long', 'Show id and title with counts')
+        .action(async (options) => {
+        try {
+            // Specific list-only deprecation banner; the group-level preAction in changeCmd.hook
+            // already emits the broader "codesdd change ..." warning, so do not duplicate it here.
+            const changeCommand = new ChangeCommand();
+            await changeCommand.list(options);
+        }
+        catch (error) {
+            console.error(`Error: ${error.message}`);
+            process.exitCode = 1;
+        }
+    });
+    changeCmd
+        .command('validate [change-name]')
+        .description('Validate a change proposal')
+        .option('--strict', 'Enable strict validation mode')
+        .option('--json', 'Output validation report as JSON')
+        .option('--no-interactive', 'Disable interactive prompts')
+        .action(async (changeName, options) => {
+        try {
+            const changeCommand = new ChangeCommand();
+            await changeCommand.validate(changeName, options);
+            if (typeof process.exitCode === 'number' && process.exitCode !== 0) {
+                process.exit(process.exitCode);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error.message}`);
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command('archive [change-name]')
+        .description('Archive a completed change and update main specs')
+        .alias('arquivar')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .option('--skip-specs', 'Skip spec update operations (useful for infrastructure, tooling, or doc-only changes)')
+        .option('--no-validate', 'Skip validation (not recommended, requires confirmation)')
+        .action(async (changeName, options) => {
+        try {
+            const archiveCommand = new ArchiveCommand();
+            await archiveCommand.execute(changeName, options);
+        }
+        catch (error) {
+            console.log(); // Empty line for spacing
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    registerSpecCommand(program);
+    registerConfigCommand(program);
+    registerSchemaCommand(program);
+    registerSddCommand(program);
+    // Top-level validate command
+    program
+        .command('validate [item-name]')
+        .description('Validate changes and specs')
+        .option('--all', 'Validate all changes and specs')
+        .option('--changes', 'Validate all changes')
+        .option('--specs', 'Validate all specs')
+        .option('--type <type>', 'Specify item type when ambiguous: change|spec')
+        .option('--strict', 'Enable strict validation mode')
+        .option('--json', 'Output validation results as JSON')
+        .option('--concurrency <n>', 'Max concurrent validations (defaults to env CODESDD_CONCURRENCY or 6)')
+        .option('--no-interactive', 'Disable interactive prompts')
+        .action(async (itemName, options) => {
+        try {
+            const validateCommand = new ValidateCommand();
+            await validateCommand.execute(itemName, options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Top-level show command
+    program
+        .command('show [item-name]')
+        .description('Show a change or spec')
+        .option('--json', 'Output as JSON')
+        .option('--type <type>', 'Specify item type when ambiguous: change|spec')
+        .option('--no-interactive', 'Disable interactive prompts')
+        // change-only flags
+        .option('--deltas-only', 'Show only deltas (JSON only, change)')
+        .option('--requirements-only', 'Alias for --deltas-only (deprecated, change)')
+        // spec-only flags
+        .option('--requirements', 'JSON only: Show only requirements (exclude scenarios)')
+        .option('--no-scenarios', 'JSON only: Exclude scenario content')
+        .option('-r, --requirement <id>', 'JSON only: Show specific requirement by ID (1-based)')
+        // allow unknown options to pass-through to underlying command implementation
+        .allowUnknownOption(true)
+        .action(async (itemName, options) => {
+        try {
+            const showCommand = new ShowCommand();
+            await showCommand.execute(itemName, options ?? {});
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Feedback command
+    program
+        .command('feedback <message>')
+        .description('Submit feedback about CodeSDD')
+        .option('--body <text>', 'Detailed description for the feedback')
+        .action(async (message, options) => {
+        try {
+            const feedbackCommand = new FeedbackCommand();
+            await feedbackCommand.execute(message, options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Completion command with subcommands
+    const completionCmd = program
+        .command('completion')
+        .description('Manage shell completions for CodeSDD CLI');
+    completionCmd
+        .command('generate [shell]')
+        .description('Generate completion script for a shell (outputs to stdout)')
+        .action(async (shell) => {
+        try {
+            const completionCommand = new CompletionCommand();
+            await completionCommand.generate({ shell });
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    completionCmd
+        .command('install [shell]')
+        .description('Install completion script for a shell')
+        .option('--verbose', 'Show detailed installation output')
+        .action(async (shell, options) => {
+        try {
+            const completionCommand = new CompletionCommand();
+            await completionCommand.install({ shell, verbose: options?.verbose });
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    completionCmd
+        .command('uninstall [shell]')
+        .description('Uninstall completion script for a shell')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (shell, options) => {
+        try {
+            const completionCommand = new CompletionCommand();
+            await completionCommand.uninstall({ shell, yes: options?.yes });
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Hidden command for machine-readable completion data
+    program
+        .command('__complete <type>', { hidden: true })
+        .description('Output completion data in machine-readable format (internal use)')
+        .action(async (type) => {
+        try {
+            const completionCommand = new CompletionCommand();
+            await completionCommand.complete({ type });
+        }
+        catch (error) {
+            // Silently fail for graceful shell completion experience
+            process.exitCode = 1;
+        }
+    });
+    // ═══════════════════════════════════════════════════════════
+    // Workflow Commands (formerly experimental)
+    // ═══════════════════════════════════════════════════════════
+    // Status command
+    program
+        .command('status')
+        .description('Display artifact completion status for a change')
+        .option('--change <id>', 'Change name to show status for')
+        .option('--schema <name>', 'Schema override (auto-detected from config.yaml)')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            await statusCommand(options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Instructions command
+    program
+        .command('instructions [artifact]')
+        .description('Output enriched instructions for creating an artifact or applying tasks')
+        .option('--change <id>', 'Change name')
+        .option('--schema <name>', 'Schema override (auto-detected from config.yaml)')
+        .option('--json', 'Output as JSON')
+        .action(async (artifactId, options) => {
+        try {
+            // Special case: "apply" is not an artifact, but a command to get apply instructions
+            if (artifactId === 'apply') {
+                await applyInstructionsCommand(options);
+            }
+            else {
+                await instructionsCommand(artifactId, options);
+            }
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Templates command
+    program
+        .command('templates')
+        .description('Show resolved template paths for all artifacts in a schema')
+        .option('--schema <name>', `Schema to use (default: ${DEFAULT_SCHEMA})`)
+        .option('--json', 'Output as JSON mapping artifact IDs to template paths')
+        .action(async (options) => {
+        try {
+            await templatesCommand(options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Schemas command
+    program
+        .command('schemas')
+        .description('List available workflow schemas with descriptions')
+        .option('--json', 'Output as JSON (for agent use)')
+        .action(async (options) => {
+        try {
+            await schemasCommand(options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // New command group with change subcommand
+    const newCmd = program.command('new').description('Create new items');
+    newCmd
+        .command('change <name>')
+        .description('Create a new change directory')
+        .option('--description <text>', 'Description to add to README.md')
+        .option('--schema <name>', `Workflow schema to use (default: ${DEFAULT_SCHEMA})`)
+        .action(async (name, options) => {
+        try {
+            await newChangeCommand(name, options);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    return program;
+}
+export async function runCli(argv = process.argv) {
+    const program = createCliProgram();
+    await program.parseAsync(argv);
+}
+//# sourceMappingURL=program.js.map

package/dist/commands/change.js

@@ -6,7 +6,7 @@ import { ChangeParser } from '../core/parsers/change-parser.js';
 import { isInteractive } from '../utils/interactive.js';
 import { getActiveChangeIds } from '../utils/item-discovery.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';
 import { captureFingerprintsForChange, writeMeta } from '../core/sdd/fingerprint.js';
 // Constants for better maintainability
 const ARCHIVE_DIR = 'archive';
@@ -24,7 +24,7 @@ export class ChangeCommand {
      *   Note: --requirements-only is deprecated alias for --deltas-only
      */
     async show(changeName, options) {
-        const changesPath = resolveOpenSpecSubpath(process.cwd(), 'changes');
+        const changesPath = resolveLegacySpecSubpath(process.cwd(), 'changes');
         if (!changeName) {
             const canPrompt = isInteractive(options);
             const changes = await this.getActiveChanges(changesPath);
@@ -90,7 +90,7 @@ export class ChangeCommand {
      * - JSON: array of { id, title, deltaCount, taskStatus }, sorted by id
      */
     async list(options) {
-        const changesPath = resolveOpenSpecSubpath(process.cwd(), 'changes');
+        const changesPath = resolveLegacySpecSubpath(process.cwd(), 'changes');
         const changes = await this.getActiveChanges(changesPath);
         if (options?.json) {
             const changeDetails = await Promise.all(changes.map(async (changeName) => {
@@ -173,7 +173,7 @@ export class ChangeCommand {
         }
     }
     async validate(changeName, options) {
-        const changesPath = resolveOpenSpecSubpath(process.cwd(), 'changes');
+        const changesPath = resolveLegacySpecSubpath(process.cwd(), 'changes');
         if (!changeName) {
             const canPrompt = isInteractive(options);
             const changes = await getActiveChangeIds();
@@ -211,7 +211,7 @@ export class ChangeCommand {
         }
         else {
             if (report.valid) {
-                const mainSpecsDir = resolveOpenSpecSubpath(process.cwd(), 'specs');
+                const mainSpecsDir = resolveLegacySpecSubpath(process.cwd(), 'specs');
                 try {
                     const meta = await captureFingerprintsForChange(changeDir, mainSpecsDir, {
                         sourceChangeId: changeName,