@fission-ai/openspec 1.14.0 → 1.14.1

package/dist/commands/spec.d.ts

@@ -1,6 +1,5 @@
-import { program } from 'commander';
 import type { RootOutput } from '../core/root-selection.js';
-interface ShowOptions {
+export interface ShowOptions {
     json?: boolean;
     requirements?: boolean;
     scenarios?: boolean;
@@ -14,6 +13,16 @@ export declare class SpecCommand {
     constructor(rootPath?: string);
     show(specId?: string, options?: ShowOptions): Promise<void>;
 }
-export declare function registerSpecCommand(rootProgram: typeof program): import("commander").Command;
-export {};
+export declare function specShowCommand(specId: string | undefined, options: ShowOptions & {
+    noInteractive?: boolean;
+}): Promise<void>;
+export declare function specListCommand(options: {
+    json?: boolean;
+    long?: boolean;
+}): Promise<void>;
+export declare function specValidateCommand(specId: string | undefined, options: {
+    strict?: boolean;
+    json?: boolean;
+    noInteractive?: boolean;
+}): Promise<void>;
 //# sourceMappingURL=spec.d.ts.map

package/dist/commands/spec.js

@@ -119,139 +119,110 @@ export class SpecCommand {
         printSpecTextRaw(this.specsDir, specPath);
     }
 }
-export function registerSpecCommand(rootProgram) {
-    const specCommand = rootProgram
-        .command('spec')
-        .description('Manage and view OpenSpec specifications');
-    // Deprecation notice for noun-based commands
-    specCommand.hook('preAction', () => {
-        console.error('Warning: The "openspec spec ..." commands are deprecated. Prefer verb-first commands (e.g., "openspec show", "openspec validate --specs").');
-    });
-    specCommand
-        .command('show [spec-id]')
-        .description('Display a specific specification')
-        .option('--json', 'Output as JSON')
-        .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)')
-        .option('--no-interactive', 'Disable interactive prompts')
-        .action(async (specId, options) => {
-        try {
-            const cmd = new SpecCommand();
-            await cmd.show(specId, options);
+export async function specShowCommand(specId, options) {
+    try {
+        const cmd = new SpecCommand();
+        await cmd.show(specId, options);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exitCode = 1;
+    }
+}
+export async function specListCommand(options) {
+    try {
+        if (!existsSync(SPECS_DIR)) {
+            console.log('No items found');
+            return;
         }
-        catch (error) {
-            console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            process.exitCode = 1;
+        const discovered = await discoverSpecFiles(SPECS_DIR);
+        const specs = discovered
+            .map(({ id, specFile }) => {
+            try {
+                assertSpecPath(SPECS_DIR, specFile);
+                const spec = parseSpecFromFile(SPECS_DIR, specFile, id);
+                return {
+                    id,
+                    title: spec.name,
+                    requirementCount: spec.requirements.length
+                };
+            }
+            catch {
+                return {
+                    id,
+                    title: id,
+                    requirementCount: 0
+                };
+            }
+        })
+            .sort((a, b) => a.id.localeCompare(b.id));
+        if (options.json) {
+            console.log(JSON.stringify(specs, null, 2));
         }
-    });
-    specCommand
-        .command('list')
-        .description('List all available specifications')
-        .option('--json', 'Output as JSON')
-        .option('--long', 'Show id and title with counts')
-        .action(async (options) => {
-        try {
-            if (!existsSync(SPECS_DIR)) {
+        else {
+            if (specs.length === 0) {
                 console.log('No items found');
                 return;
             }
-            const discovered = await discoverSpecFiles(SPECS_DIR);
-            const specs = discovered
-                .map(({ id, specFile }) => {
-                try {
-                    assertSpecPath(SPECS_DIR, specFile);
-                    const spec = parseSpecFromFile(SPECS_DIR, specFile, id);
-                    return {
-                        id,
-                        title: spec.name,
-                        requirementCount: spec.requirements.length
-                    };
-                }
-                catch {
-                    return {
-                        id,
-                        title: id,
-                        requirementCount: 0
-                    };
-                }
-            })
-                .sort((a, b) => a.id.localeCompare(b.id));
-            if (options.json) {
-                console.log(JSON.stringify(specs, null, 2));
+            if (!options.long) {
+                specs.forEach(spec => console.log(spec.id));
+                return;
             }
-            else {
-                if (specs.length === 0) {
-                    console.log('No items found');
-                    return;
-                }
-                if (!options.long) {
-                    specs.forEach(spec => console.log(spec.id));
-                    return;
-                }
-                specs.forEach(spec => {
-                    console.log(`${spec.id}: ${spec.title} [requirements ${spec.requirementCount}]`);
+            specs.forEach(spec => {
+                console.log(`${spec.id}: ${spec.title} [requirements ${spec.requirementCount}]`);
+            });
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exitCode = 1;
+    }
+}
+export async function specValidateCommand(specId, options) {
+    try {
+        if (!specId) {
+            const canPrompt = isInteractive(options);
+            const specIds = await getSpecIds();
+            if (canPrompt && specIds.length > 0) {
+                const { select } = await import('@inquirer/prompts');
+                specId = await select({
+                    message: 'Select a spec to validate',
+                    choices: specIds.map(id => ({ name: id, value: id })),
                 });
             }
+            else {
+                throw new Error('Missing required argument <spec-id>');
+            }
         }
-        catch (error) {
-            console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            process.exitCode = 1;
+        const specPath = join(SPECS_DIR, specId, 'spec.md');
+        assertSpecPath(SPECS_DIR, specPath);
+        if (!existsSync(specPath)) {
+            throw new Error(`Spec '${specId}' not found at openspec/specs/${specId}/spec.md`);
         }
-    });
-    specCommand
-        .command('validate [spec-id]')
-        .description('Validate a specification structure')
-        .option('--strict', 'Enable strict validation mode')
-        .option('--json', 'Output validation report as JSON')
-        .option('--no-interactive', 'Disable interactive prompts')
-        .action(async (specId, options) => {
-        try {
-            if (!specId) {
-                const canPrompt = isInteractive(options);
-                const specIds = await getSpecIds();
-                if (canPrompt && specIds.length > 0) {
-                    const { select } = await import('@inquirer/prompts');
-                    specId = await select({
-                        message: 'Select a spec to validate',
-                        choices: specIds.map(id => ({ name: id, value: id })),
-                    });
-                }
-                else {
-                    throw new Error('Missing required argument <spec-id>');
-                }
-            }
-            const specPath = join(SPECS_DIR, specId, 'spec.md');
-            assertSpecPath(SPECS_DIR, specPath);
-            if (!existsSync(specPath)) {
-                throw new Error(`Spec '${specId}' not found at openspec/specs/${specId}/spec.md`);
-            }
-            const validator = new Validator(options.strict);
-            assertSpecPath(SPECS_DIR, specPath);
-            const report = await validator.validateSpec(specPath);
-            if (options.json) {
-                console.log(JSON.stringify(report, null, 2));
+        const validator = new Validator(options.strict);
+        assertSpecPath(SPECS_DIR, specPath);
+        const report = await validator.validateSpec(specPath);
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            if (report.valid) {
+                console.log(`Specification '${specId}' is valid`);
             }
             else {
-                if (report.valid) {
-                    console.log(`Specification '${specId}' is valid`);
-                }
-                else {
-                    console.error(`Specification '${specId}' has issues`);
-                    report.issues.forEach(issue => {
-                        const label = issue.level === 'ERROR' ? 'ERROR' : issue.level;
-                        const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
-                        console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
-                    });
-                }
+                console.error(`Specification '${specId}' has issues`);
+                report.issues.forEach(issue => {
+                    const label = issue.level === 'ERROR' ? 'ERROR' : issue.level;
+                    const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
+                    console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
+                });
             }
-            process.exitCode = report.valid ? 0 : 1;
-        }
-        catch (error) {
-            console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            process.exitCode = 1;
         }
-    });
-    return specCommand;
+        process.exitCode = report.valid ? 0 : 1;
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exitCode = 1;
+    }
 }
 //# sourceMappingURL=spec.js.map

package/dist/commands/store.d.ts

@@ -1,3 +1,28 @@
-import { Command } from 'commander';
-export declare function registerStoreCommand(program: Command): void;
+export interface StoreSetupOptions {
+    path?: string;
+    initGit?: boolean;
+    json?: boolean;
+    remote?: string;
+}
+export interface StoreRegisterOptions {
+    id?: string;
+    yes?: boolean;
+    json?: boolean;
+}
+export interface StoreRemoveOptions {
+    yes?: boolean;
+    json?: boolean;
+}
+export interface StoreJsonOptions {
+    json?: boolean;
+}
+export declare class StoreCommand {
+    setup(id: string | undefined, options?: StoreSetupOptions): Promise<void>;
+    register(inputPath: string | undefined, options?: StoreRegisterOptions): Promise<void>;
+    unregister(id: string, options?: StoreJsonOptions): Promise<void>;
+    remove(id: string, options?: StoreRemoveOptions): Promise<void>;
+    list(options?: StoreJsonOptions): Promise<void>;
+    doctor(id: string | undefined, options?: StoreJsonOptions): Promise<void>;
+    private handleFailure;
+}
 //# sourceMappingURL=store.d.ts.map

package/dist/commands/store.js

@@ -1,7 +1,6 @@
 import * as os from 'node:os';
 import { asErrorMessage, emitFailure, printJson } from './shared-output.js';
 import * as path from 'node:path';
-import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
 import { StoreError, doctorStores, listStores, prepareStoreSetup, prepareStoreCleanup, registerExistingStore, removeStore, resolveSetupGitEnabled, setupPreparedStore, unregisterStore, validateStoreId, } from '../core/store/index.js';
 import { isInteractive } from '../utils/interactive.js';
 function toStoreOutput(store) {
@@ -318,7 +317,7 @@ function printDoctorHuman(payload) {
         }
     }
 }
-class StoreCommand {
+export class StoreCommand {
     async setup(id, options = {}) {
         try {
             const setupInput = await resolveSetupInput(id, options);
@@ -429,122 +428,4 @@ class StoreCommand {
         emitFailure(json, payload, error, 'store_error');
     }
 }
-export function registerStoreCommand(program) {
-    const storeCommand = new StoreCommand();
-    // One source for the locked group one-liner: the completions registry
-    // entry, which shell completion scripts also consume.
-    const storeGroupDescription = COMMAND_REGISTRY.find((entry) => entry.name === 'store')?.description ??
-        'Create and manage stores - standalone OpenSpec repos you register on this machine';
-    const store = program.command('store').description(storeGroupDescription);
-    store
-        .command('setup [id]')
-        .description('Create and register a local store')
-        .option('--path <path>', 'Folder where the store should live (for example ~/openspec/<id>)')
-        .option('--init-git', 'Initialize a Git repository with an initial commit (default)')
-        .option('--no-init-git', 'Skip every Git action: no init, no initial commit')
-        .option('--remote <url>', 'Canonical clone source recorded in store.yaml')
-        .option('--json', 'Output as JSON')
-        .action(async (id, options) => {
-        await storeCommand.setup(id, options);
-    });
-    store
-        .command('register [path]')
-        .description('Register an existing local store')
-        .option('--id <id>', 'Store id; defaults to metadata or folder name')
-        .option('--yes', 'Confirm creating store identity metadata for a healthy OpenSpec root')
-        .option('--json', 'Output as JSON')
-        .action(async (inputPath, options) => {
-        await storeCommand.register(inputPath, options);
-    });
-    store
-        .command('unregister <id>')
-        .description('Forget a local store registration without deleting files')
-        .option('--json', 'Output as JSON')
-        .action(async (id, options) => {
-        await storeCommand.unregister(id, options);
-    });
-    store
-        .command('remove <id>')
-        .description('Forget a local store registration and delete its local folder')
-        .option('--yes', 'Confirm local store folder deletion')
-        .option('--json', 'Output as JSON')
-        .action(async (id, options) => {
-        await storeCommand.remove(id, options);
-    });
-    store
-        .command('list')
-        .alias('ls')
-        .description('List locally registered stores')
-        .option('--json', 'Output as JSON')
-        .action(async (options) => {
-        await storeCommand.list(options);
-    });
-    store
-        .command('doctor [id]')
-        .description('Check local store registration and metadata')
-        .option('--json', 'Output as JSON')
-        .action(async (id, options) => {
-        await storeCommand.doctor(id, options);
-    });
-    const lifecycleRedirects = new Set(COMMAND_REGISTRY.filter((entry) => entry.flags.some((flag) => flag.name === 'store') ||
-        (entry.subcommands ?? []).some((subcommand) => subcommand.flags.some((flag) => flag.name === 'store'))).map((entry) => entry.name));
-    const storeSubcommandsLine = store.commands
-        .map((subcommand) => {
-        const aliases = subcommand.aliases();
-        return aliases.length > 0 ? `${subcommand.name()} (${aliases.join(', ')})` : subcommand.name();
-    })
-        .join(', ');
-    // One group action owns missing AND unknown subcommands. Known
-    // subcommands dispatch above; everything else — including a bare
-    // `store --json` with no operand — lands here, so the handler owns the
-    // entire message and exit path (same text for human and --json). The
-    // permissive flags route unknown operands/options here instead of
-    // letting Commander emit a raw error before the action runs. We detect
-    // `--json` in the residual args rather than declaring a group option,
-    // which would otherwise shadow each subcommand's own `--json` flag.
-    store.allowExcessArguments(true);
-    store.allowUnknownOption(true);
-    store.action(() => {
-        const operands = store.args;
-        // Flag values are indistinguishable from operands without a full
-        // parse, so the verbatim echo only applies to plain-operand input.
-        const attempted = operands.filter((operand) => !operand.startsWith('-'));
-        const hasFlagLikeToken = operands.some((operand) => operand.startsWith('-'));
-        // The agent contract: --json failures emit one JSON document.
-        if (operands.includes('--json')) {
-            const message = attempted.length > 0
-                ? `Unknown command '${attempted[0]}' for 'openspec store'. Store subcommands: ${storeSubcommandsLine}.`
-                : `Missing subcommand for 'openspec store'. Store subcommands: ${storeSubcommandsLine}.`;
-            printJson({
-                status: [
-                    {
-                        severity: 'error',
-                        code: 'unknown_store_subcommand',
-                        message,
-                        fix: 'Run a store subcommand, or use the lifecycle command with --store <id>.',
-                    },
-                ],
-            });
-            process.exitCode = 1;
-            return;
-        }
-        let example = 'openspec new change <change-id> --store <id>';
-        if (!hasFlagLikeToken && attempted.length > 0 && lifecycleRedirects.has(attempted[0])) {
-            if (attempted[0] === 'new') {
-                const changeId = attempted[1] === 'change' && attempted[2] ? attempted[2] : '<change-id>';
-                example = `openspec new change ${changeId} --store <id>`;
-            }
-            else {
-                example = `openspec ${attempted.join(' ')} --store <id>`;
-            }
-        }
-        console.error(attempted.length > 0
-            ? `Error: unknown command '${attempted[0]}' for 'openspec store'.`
-            : "Error: missing subcommand for 'openspec store'.");
-        console.error(`Store subcommands manage store registration: ${storeSubcommandsLine}.`);
-        console.error('To create or work on a change in a store, use the normal command with --store, for example:');
-        console.error(`  ${example}`);
-        process.exitCode = 1;
-    });
-}
 //# sourceMappingURL=store.js.map

package/dist/commands/workflow/default-schema.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_SCHEMA = "spec-driven";
+//# sourceMappingURL=default-schema.d.ts.map

package/dist/commands/workflow/default-schema.js

@@ -0,0 +1,4 @@
+// Its own module so the CLI's command definitions can show it in help text
+// without loading the workflow implementation.
+export const DEFAULT_SCHEMA = 'spec-driven';
+//# sourceMappingURL=default-schema.js.map

package/dist/commands/workflow/instructions.js

@@ -483,7 +483,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         remaining === 0 &&
         total > 0) {
         state = 'all_done';
-        instruction = 'All tasks are complete! This change is ready to be archived.\nConsider running tests and reviewing the changes before archiving.';
+        instruction = 'All tracked tasks are complete.\nReview or verify the change as appropriate before archiving.';
     }
     else if (!tracksFile) {
         // No tracking file configured in schema - ready to apply

package/dist/commands/workflow/shared.d.ts

@@ -60,7 +60,7 @@ export interface ArchiveInstructions {
     /** Current advisory guidance for archive. */
     operationGuidance?: string[];
 }
-export declare const DEFAULT_SCHEMA = "spec-driven";
+export { DEFAULT_SCHEMA } from './default-schema.js';
 export declare function printJson(payload: unknown): void;
 export declare function statusFromError(error: unknown): ChangeCommandStatus;
 /**

package/dist/commands/workflow/shared.js

@@ -13,7 +13,7 @@ import { isRootSelectionError } from '../../core/root-selection.js';
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
-export const DEFAULT_SCHEMA = 'spec-driven';
+export { DEFAULT_SCHEMA } from './default-schema.js';
 // -----------------------------------------------------------------------------
 // Utility Functions
 // -----------------------------------------------------------------------------

package/dist/commands/workset.d.ts

@@ -1,6 +1,18 @@
 import type { spawn as nodeSpawn } from 'node:child_process';
-import { Command } from 'commander';
 import { type LaunchCommand } from '../core/openers.js';
+export interface WorksetCreateOptions {
+    member?: string[];
+    tool?: string;
+    json?: boolean;
+}
+export interface WorksetOpenOptions {
+    tool?: string;
+    json?: boolean;
+}
+export interface WorksetRemoveOptions {
+    yes?: boolean;
+    json?: boolean;
+}
 interface LaunchResult {
     code: number | null;
     signal: NodeJS.Signals | null;
@@ -20,6 +32,14 @@ export interface LaunchOptions {
 export declare function launchOpenerCommand(command: LaunchCommand, options?: LaunchOptions): Promise<LaunchResult>;
 /** 130 for SIGINT, 143 for SIGTERM - the shell's 128+n convention. */
 export declare function exitCodeForLaunch(result: LaunchResult): number;
-export declare function registerWorksetCommand(program: Command): void;
+export declare class WorksetCommand {
+    create(name: string | undefined, options?: WorksetCreateOptions): Promise<void>;
+    private composeFromFlags;
+    list(options?: {
+        json?: boolean;
+    }): Promise<void>;
+    open(name: string, options?: WorksetOpenOptions): Promise<void>;
+    remove(name: string, options?: WorksetRemoveOptions): Promise<void>;
+}
 export {};
 //# sourceMappingURL=workset.d.ts.map

package/dist/commands/workset.js

@@ -8,7 +8,6 @@
  */
 import * as os from 'node:os';
 import { createRequire } from 'node:module';
-import { Option } from 'commander';
 import { buildWorksetCodeWorkspaceJson, getWorkset, getWorksetCodeWorkspacePath, listWorksets, readWorksetsState, removeWorkset, updateWorksetsState, validateWorksetName, withWorkset, withWorksetsLock, worksetNotFoundError, } from '../core/worksets.js';
 import { buildLaunchCommand, findOpener, isOpenerCommandAvailable, isOpenerEnabled, listOpenerChoices, mergeOpenerTable, } from '../core/openers.js';
 import { pathIsDirectory, writeFileAtomically } from '../core/file-state.js';
@@ -18,7 +17,6 @@ import { isInteractive } from '../utils/interactive.js';
 import { asErrorMessage, emitFailure, isPromptCancellationError, printJson, } from './shared-output.js';
 import { finalizeWorkset, firstInstalledAlternative, formatMemberRows, noToolInstalledError, resolveMemberFlags, toolUnavailableError, toolUnknownError, } from './workset-input.js';
 import { composeInteractively, confirmRemoveInteractively, promptOpenNow, promptToolFromChoices, } from './workset-prompts.js';
-import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
 // cross-spawn is CJS with no types and only `workset open` needs it -
 // loaded lazily so every other CLI invocation skips its module graph.
 let cachedSpawn;
@@ -93,7 +91,7 @@ export function exitCodeForLaunch(result) {
     }
     return result.code ?? 0;
 }
-class WorksetCommand {
+export class WorksetCommand {
     async create(name, options = {}) {
         try {
             const interactive = !options.json && isInteractive();
@@ -358,89 +356,4 @@ class WorksetCommand {
         }
     }
 }
-function collectMember(value, previous) {
-    return [...previous, value];
-}
-export function registerWorksetCommand(program) {
-    const worksetCommand = new WorksetCommand();
-    const groupDescription = COMMAND_REGISTRY.find((entry) => entry.name === 'workset')?.description ??
-        'Compose, keep, and open personal working views (purely local)';
-    const workset = program.command('workset').description(groupDescription);
-    // Parsed at the group level so `openspec workset --json` keeps the
-    // one-JSON-document contract instead of a raw Commander error. The
-    // parent option matches anywhere; actions read optsWithGlobals().
-    workset.addOption(new Option('--json', 'Output as JSON').hideHelp());
-    workset
-        .command('create [name]')
-        .description('Compose and save a named working view of folders you choose')
-        .option('--member <member>', 'Member folder as <path> or <name>=<path>; repeatable, first is the primary', collectMember, [])
-        .option('--tool <id>', 'Preferred tool to open this workset with')
-        .option('--json', 'Output as JSON')
-        .action(async (name, _options, command) => {
-        await worksetCommand.create(name, command.optsWithGlobals());
-    });
-    workset
-        .command('list')
-        .alias('ls')
-        .description('Show saved worksets with their members')
-        .option('--json', 'Output as JSON')
-        .action(async (_options, command) => {
-        await worksetCommand.list(command.optsWithGlobals());
-    });
-    workset
-        .command('open <name>')
-        .description('Open a saved workset in your tool (editor window or agent session)')
-        .option('--tool <id>', 'Open with this tool just this once')
-        .addOption(
-    // Parsed so Commander never owns the error; rejected in the
-    // action with one JSON document. Hidden because help should not
-    // advertise a mode that only rejects.
-    new Option('--json', 'Not supported for open').hideHelp())
-        .action(async (name, _options, command) => {
-        await worksetCommand.open(name, command.optsWithGlobals());
-    });
-    workset
-        .command('remove <name>')
-        .description('Delete a saved workset (member folders are never touched)')
-        .option('--yes', 'Confirm removal non-interactively')
-        .option('--json', 'Output as JSON')
-        .action(async (name, _options, command) => {
-        await worksetCommand.remove(name, command.optsWithGlobals());
-    });
-    const subcommandsLine = workset.commands
-        .map((subcommand) => {
-        const aliases = subcommand.aliases();
-        return aliases.length > 0
-            ? `${subcommand.name()} (${aliases.join(', ')})`
-            : subcommand.name();
-    })
-        .join(', ');
-    // One handler owns missing AND unknown subcommands: known
-    // subcommands dispatch above; everything else lands in this action
-    // (allowExcessArguments routes the unknown operand here), keeping
-    // the one-JSON-document contract for `--json` probes.
-    workset.allowExcessArguments(true);
-    workset.action(() => {
-        const attempted = workset.args.filter((operand) => !operand.startsWith('-'));
-        const message = attempted.length > 0
-            ? `Unknown command '${attempted[0]}' for 'openspec workset'. Workset subcommands: ${subcommandsLine}.`
-            : `Missing subcommand for 'openspec workset'. Workset subcommands: ${subcommandsLine}.`;
-        if (workset.opts().json) {
-            printJson({
-                status: [
-                    {
-                        severity: 'error',
-                        code: 'unknown_workset_subcommand',
-                        message,
-                        fix: 'Run one of the workset subcommands.',
-                    },
-                ],
-            });
-        }
-        else {
-            console.error(`Error: ${message}`);
-        }
-        process.exitCode = 1;
-    });
-}
 //# sourceMappingURL=workset.js.map