@fission-ai/openspec 1.13.2 → 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

@@ -45,6 +45,7 @@ function filterSpec(spec, options) {
     const filteredRequirements = (requirementIndex !== undefined
         ? [spec.requirements[requirementIndex]]
         : spec.requirements).map(req => ({
+        name: req.name,
         text: req.text,
         scenarios: includeScenarios ? req.scenarios : [],
     }));
@@ -118,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

@@ -103,6 +103,14 @@ export function printInstructionsText(instructions, isBlocked) {
         ` change="${escapeEnvelopeAttribute(changeName)}"` +
         ` schema="${escapeEnvelopeAttribute(schemaName)}">`);
     console.log();
+    if (instructions.warnings) {
+        for (const warning of instructions.warnings) {
+            console.log('<warning>');
+            console.log(escapeEnvelopeTags(warning));
+            console.log('</warning>');
+            console.log();
+        }
+    }
     // Artifacts skipped via skip_specs get no creation directive: emitting the
     // task/template anyway would prompt an agent to write spec files that
     // validate then rejects as conflicting with the marker.
@@ -215,9 +223,16 @@ export function printInstructionsText(instructions, isBlocked) {
     // Closing tag
     console.log('</artifact>');
 }
-// -----------------------------------------------------------------------------
-// Apply Instructions Command
-// -----------------------------------------------------------------------------
+/** Adds one-based source locations to parsed tasks without changing task parsing. */
+function parseLocatedTasks(content, sourcePath) {
+    const tasks = [];
+    for (const [index, line] of content.split('\n').entries()) {
+        const [task] = parseTaskLines(line);
+        if (task)
+            tasks.push({ ...task, sourcePath, line: index + 1 });
+    }
+    return tasks;
+}
 /**
  * Turns parsed task lines into the listed task items.
  *
@@ -238,6 +253,8 @@ function toTaskItems(parsed) {
             id: `${tasks.length + 1}`,
             description: task.description,
             done: task.done,
+            sourcePath: task.sourcePath,
+            line: task.line,
         });
     }
     return tasks;
@@ -406,7 +423,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         for (const tracksPath of tracksPaths) {
             try {
                 const tasksContent = await fs.promises.readFile(tracksPath, 'utf-8');
-                parsedTasks.push(...parseTaskLines(tasksContent));
+                parsedTasks.push(...parseLocatedTasks(tasksContent, tracksPath));
             }
             catch (error) {
                 const code = error?.code;
@@ -466,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
@@ -483,13 +500,16 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
             .join('\n');
         instruction += `\nTask completion is not verified because tracking evidence was unavailable:\n${unavailableDetails}`;
     }
-    const warnings = await collectApplyWarnings({
-        state,
-        schema,
-        changeDir,
-        changeName,
-        skippedArtifacts: context.skippedArtifacts,
-    });
+    const warnings = [
+        ...(context.warnings ?? []),
+        ...(await collectApplyWarnings({
+            state,
+            schema,
+            changeDir,
+            changeName,
+            skippedArtifacts: context.skippedArtifacts,
+        })),
+    ];
     return {
         changeName,
         changeDir,

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

@@ -16,6 +16,8 @@ export interface TaskItem {
     id: string;
     description: string;
     done: boolean;
+    sourcePath: string;
+    line: number;
 }
 export interface ApplyInstructions {
     changeName: string;
@@ -58,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/workflow/status.js

@@ -6,7 +6,7 @@
 import ora from 'ora';
 import chalk from 'chalk';
 import { getChangeDir } from '../../core/planning-home.js';
-import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
+import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, findDeclaringProjectRoot, } from '../../core/root-selection.js';
 import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
 import { resolveNextStep } from '../../core/change-status-policy.js';
 import { asStatus } from '../shared-output.js';
@@ -43,12 +43,20 @@ export async function statusCommand(options) {
         // `Next:` line, so a store-selected root can never carry `--store` in one
         // and drop it from the other.
         const storeOptions = isStoreSelectedRoot(root) ? { storeId: root.storeId } : {};
+        // A store holds planning artifacts only; the project declaring it is
+        // where implementation edits go (#2013).
+        const implementationRoot = isStoreSelectedRoot(root)
+            ? findDeclaringProjectRoot(root.storeId)
+            : null;
+        const statusOptions = implementationRoot
+            ? { ...storeOptions, implementationRoot }
+            : storeOptions;
         // Single definition of "load one change's status" so the batch and
         // single-change payloads can never drift apart.
         const loadStatus = (changeName) => formatChangeStatus(loadChangeContext(projectRoot, changeName, options.schema, {
             changeDir: getChangeDir(planningHome, changeName),
             planningHome,
-        }), storeOptions);
+        }), statusOptions);
         // Handle no-changes case gracefully — status is informational,
         // so "no changes" is a valid state, not an error.
         if (!options.change) {
@@ -157,6 +165,11 @@ export function printStatusText(status, options = {}) {
     const total = status.artifacts.length - skippedCount;
     console.log(`Change: ${status.changeName}`);
     console.log(`Schema: ${status.schemaName}`);
+    if (status.warnings) {
+        for (const warning of status.warnings) {
+            console.log(chalk.yellow(`Warning: ${warning}`));
+        }
+    }
     if (status.changeRoot) {
         console.log(`Change root: ${status.changeRoot}`);
     }

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