@fission-ai/openspec 1.4.1 → 1.6.0-beta.1

package/dist/commands/workflow/new-change.js

@@ -1,62 +1,37 @@
 /**
  * New Change Command
  *
- * Creates a new change directory with optional description and schema.
+ * Creates a new change directory with optional description and schema in the
+ * resolved OpenSpec root. `--store <id>` selects a registered store's
+ * root; initiative linking and workspace affected areas are no longer part of
+ * this command.
  */
 import ora from 'ora';
 import path from 'path';
 import { createChange, validateChangeName } from '../../utils/change-utils.js';
-import { formatChangeLocation, resolveCurrentPlanningHomeSync, } from '../../core/planning-home.js';
-import { validateSchemaExists } from './shared.js';
-import { resolveInitiativeLinkReference, } from '../../core/collections/initiatives/index.js';
-import { assertInitiativeSelectorsHaveReference, assertRepoLocalInitiativeLinkPlanningHome, formatInitiativeLink, printJson, statusFromError, } from './initiative-link.js';
+import { formatChangeLocation } from '../../core/planning-home.js';
+import { resolveRootForCommand, RootSelectionError, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
+import { printJson, statusFromError, validateSchemaExists } from './shared.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
-function parseAffectedAreas(value) {
-    return (value ?? '')
-        .split(',')
-        .map((area) => area.trim())
-        .filter((area) => area.length > 0);
-}
-function validateWorkspaceAffectedAreas(planningHome, affectedAreas) {
-    if (affectedAreas.length === 0) {
-        return;
-    }
-    if (planningHome.kind !== 'workspace') {
-        throw new Error('--areas can only be used when creating a workspace-scoped change');
+function assertRemovedOptionsAbsent(options) {
+    if (options.initiative !== undefined) {
+        throw new RootSelectionError('--initiative is no longer supported. Normal changes no longer attach to initiatives; --store <id> selects the OpenSpec root.', 'initiative_option_removed', { target: 'change.options' });
     }
-    const validAreas = new Set(planningHome.workspace?.links ?? []);
-    const invalidAreas = affectedAreas.filter((area) => !validAreas.has(area));
-    if (invalidAreas.length > 0) {
-        const validList = [...validAreas].sort((a, b) => a.localeCompare(b));
-        const validMessage = validList.length > 0 ? validList.join(', ') : '(no registered links)';
-        throw new Error(`Invalid affected area${invalidAreas.length === 1 ? '' : 's'}: ${invalidAreas.join(', ')}. ` +
-            `Valid workspace link names: ${validMessage}`);
+    if (options.areas !== undefined) {
+        throw new RootSelectionError('--areas is no longer supported. Workspace affected areas are not part of the normal OpenSpec root path.', 'areas_option_removed', { target: 'change.options' });
     }
 }
-function outputForCreatedChange(id, changeDir, schema, initiative) {
-    return {
-        change: {
-            id,
-            path: changeDir,
-            metadataPath: path.join(changeDir, '.openspec.yaml'),
-            schema,
-        },
-        ...(initiative ? { initiative } : {}),
-    };
-}
-function printCreatedChangeHuman(payload, planningHome) {
-    if (!payload.change) {
-        return;
-    }
-    const location = formatChangeLocation(planningHome, payload.change.id);
-    const scope = planningHome.kind === 'workspace' ? 'workspace change' : 'change';
-    console.log(`Created ${scope} '${payload.change.id}' at ${location}/`);
+function printCreatedChangeHuman(payload, root) {
+    // A relative path is only honest when the root is where the user
+    // stands; a distant ancestor root gets the absolute path.
+    const location = !isStoreSelectedRoot(root) && root.path === process.cwd()
+        ? formatChangeLocation(toPlanningHome(root), payload.change.id)
+        : payload.change.path;
+    console.log(`Created change '${payload.change.id}' at ${location}/`);
     console.log(`Schema: ${payload.change.schema}`);
-    if (payload.initiative) {
-        console.log(`Initiative: ${formatInitiativeLink(payload.initiative)}`);
-    }
+    console.log(`Next: ${withStoreFlag(root, `openspec status --change ${payload.change.id}`)}`);
 }
 export async function newChangeCommand(name, options) {
     const spinner = options.json ? undefined : ora();
@@ -68,38 +43,29 @@ export async function newChangeCommand(name, options) {
         if (!validation.valid) {
             throw new Error(validation.error);
         }
-        assertInitiativeSelectorsHaveReference(options);
-        const planningHome = resolveCurrentPlanningHomeSync();
-        const projectRoot = planningHome.root;
-        const affectedAreas = parseAffectedAreas(options.areas);
-        validateWorkspaceAffectedAreas(planningHome, affectedAreas);
-        let initiative;
-        if (options.initiative !== undefined) {
-            assertRepoLocalInitiativeLinkPlanningHome(planningHome);
-            initiative = await resolveInitiativeLinkReference(options.initiative, {
-                store: options.store,
-                storePath: options.storePath,
-            });
+        assertRemovedOptionsAbsent(options);
+        const root = await resolveRootForCommand(options, {
+            json: options.json,
+            failurePayload: { change: null },
+        });
+        if (!root) {
+            return;
         }
+        const projectRoot = root.path;
         // Validate schema if provided
         if (options.schema) {
             validateSchemaExists(options.schema, projectRoot);
         }
-        const resolvedSchema = options.schema ?? planningHome.defaultSchema;
+        const resolvedSchema = options.schema ?? root.defaultSchema;
         if (spinner) {
             spinner.start(`Creating change '${name}' with schema '${resolvedSchema}'...`);
         }
-        const workspaceGoal = planningHome.kind === 'workspace'
-            ? options.goal ?? options.description
-            : options.goal;
         const result = await createChange(projectRoot, name, {
             schema: options.schema,
-            defaultSchema: planningHome.defaultSchema,
-            changesDir: planningHome.changesDir,
+            defaultSchema: root.defaultSchema,
+            changesDir: root.changesDir,
             metadata: {
-                ...(workspaceGoal ? { goal: workspaceGoal } : {}),
-                ...(affectedAreas.length > 0 ? { affected_areas: affectedAreas } : {}),
-                ...(initiative ? { initiative } : {}),
+                ...(options.goal ? { goal: options.goal } : {}),
             },
         });
         // If description provided, create README.md with description
@@ -108,22 +74,21 @@ export async function newChangeCommand(name, options) {
             const readmePath = path.join(result.changeDir, 'README.md');
             await fs.writeFile(readmePath, `# ${name}\n\n${options.description}\n`, 'utf-8');
         }
-        const payload = outputForCreatedChange(name, result.changeDir, result.schema, initiative);
+        const payload = {
+            change: {
+                id: name,
+                path: result.changeDir,
+                metadataPath: path.join(result.changeDir, '.openspec.yaml'),
+                schema: result.schema,
+            },
+            root: toRootOutput(root),
+        };
         if (options.json) {
             printJson(payload);
             return;
         }
         spinner?.stop();
-        printCreatedChangeHuman(payload, planningHome);
-        if (planningHome.kind === 'workspace' && !initiative) {
-            if (affectedAreas.length > 0) {
-                console.log(`Affected areas: ${affectedAreas.join(', ')}`);
-            }
-            else {
-                console.log('Affected areas: unresolved; identify them in change metadata or coordination tasks as planning continues.');
-            }
-            console.log('Next: run openspec status --change "' + name + '" to inspect workspace planning artifacts.');
-        }
+        printCreatedChangeHuman(payload, root);
     }
     catch (error) {
         spinner?.stop();

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

@@ -4,7 +4,14 @@
  * This module contains types, constants, and validation helpers used across
  * multiple artifact workflow commands.
  */
-import type { InitiativeLink } from '../../core/change-metadata/index.js';
+import type { ReferenceIndexEntry } from '../../core/references.js';
+export interface ChangeCommandStatus {
+    severity: 'error' | 'warning';
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+}
 export interface TaskItem {
     id: string;
     description: string;
@@ -14,7 +21,6 @@ export interface ApplyInstructions {
     changeName: string;
     changeDir: string;
     schemaName: string;
-    initiative?: InitiativeLink;
     contextFiles: Record<string, string[]>;
     progress: {
         total: number;
@@ -25,8 +31,12 @@ export interface ApplyInstructions {
     state: 'blocked' | 'all_done' | 'ready';
     missingArtifacts?: string[];
     instruction: string;
+    /** Referenced-store index (read-only upstream context; omitted when none declared) */
+    references?: ReferenceIndexEntry[];
 }
 export declare const DEFAULT_SCHEMA = "spec-driven";
+export declare function printJson(payload: unknown): void;
+export declare function statusFromError(error: unknown): ChangeCommandStatus;
 /**
  * Checks if color output is disabled via NO_COLOR env or --no-color flag.
  */
@@ -48,7 +58,9 @@ export declare function getAvailableChanges(projectRoot: string, changesDir?: st
  * Validates that a change exists and returns available changes if not.
  * Checks directory existence directly to support scaffolded changes (without proposal.md).
  */
-export declare function validateChangeExists(changeName: string | undefined, projectRoot: string, changesDir?: string): Promise<string>;
+export declare function validateChangeExists(changeName: string | undefined, projectRoot: string, changesDir?: string, hints?: {
+    newChangeHint?: string;
+}): Promise<string>;
 /**
  * Validates that a schema exists and returns available schemas if not.
  *

package/dist/commands/workflow/shared.js

@@ -8,6 +8,7 @@ import chalk from 'chalk';
 import path from 'path';
 import * as fs from 'fs';
 import { getSchemaDir, listSchemas } from '../../core/artifact-graph/index.js';
+import { isRootSelectionError } from '../../core/root-selection.js';
 import { validateChangeName } from '../../utils/change-utils.js';
 // -----------------------------------------------------------------------------
 // Constants
@@ -16,6 +17,19 @@ export const DEFAULT_SCHEMA = 'spec-driven';
 // -----------------------------------------------------------------------------
 // Utility Functions
 // -----------------------------------------------------------------------------
+export function printJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+export function statusFromError(error) {
+    if (isRootSelectionError(error)) {
+        return { ...error.diagnostic };
+    }
+    return {
+        severity: 'error',
+        code: 'change_error',
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
 /**
  * Checks if color output is disabled via NO_COLOR env or --no-color flag.
  */
@@ -74,11 +88,14 @@ export async function getAvailableChanges(projectRoot, changesDir = path.join(pr
  * Validates that a change exists and returns available changes if not.
  * Checks directory existence directly to support scaffolded changes (without proposal.md).
  */
-export async function validateChangeExists(changeName, projectRoot, changesDir = path.join(projectRoot, 'openspec', 'changes')) {
+export async function validateChangeExists(changeName, projectRoot, changesDir = path.join(projectRoot, 'openspec', 'changes'), hints = {}) {
+    // Hints must stay pasteable: callers with a selected store pass a
+    // store-carrying hint so following it lands in the same root.
+    const newChangeHint = hints.newChangeHint ?? 'openspec new change <name>';
     if (!changeName) {
         const available = await getAvailableChanges(projectRoot, changesDir);
         if (available.length === 0) {
-            throw new Error('No changes found. Create one with: openspec new change <name>');
+            throw new Error(`No changes found. Create one with: ${newChangeHint}`);
         }
         throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
     }
@@ -93,7 +110,7 @@ export async function validateChangeExists(changeName, projectRoot, changesDir =
     if (!exists) {
         const available = await getAvailableChanges(projectRoot, changesDir);
         if (available.length === 0) {
-            throw new Error(`Change '${changeName}' not found. No changes exist. Create one with: openspec new change <name>`);
+            throw new Error(`Change '${changeName}' not found. No changes exist. Create one with: ${newChangeHint}`);
         }
         throw new Error(`Change '${changeName}' not found. Available changes:\n  ${available.join('\n  ')}`);
     }

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

@@ -7,6 +7,8 @@ import { type ChangeStatus } from '../../core/artifact-graph/index.js';
 export interface StatusOptions {
     change?: string;
     schema?: string;
+    store?: string;
+    storePath?: string;
     json?: boolean;
 }
 export declare function statusCommand(options: StatusOptions): Promise<void>;

package/dist/commands/workflow/status.js

@@ -5,35 +5,44 @@
  */
 import ora from 'ora';
 import chalk from 'chalk';
-import { resolveCurrentPlanningHomeSync, getChangeDir } from '../../core/planning-home.js';
+import { getChangeDir } from '../../core/planning-home.js';
+import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
 import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
 import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
 export async function statusCommand(options) {
+    // The root resolves (and the store banner prints) before the spinner starts
+    // so the two do not fight over stderr.
+    const root = await resolveRootForCommand(options, { json: options.json });
+    if (!root) {
+        return;
+    }
     const spinner = options.json ? undefined : ora('Loading change status...').start();
     try {
-        const planningHome = resolveCurrentPlanningHomeSync();
-        const projectRoot = planningHome.root;
+        const planningHome = toPlanningHome(root);
+        const projectRoot = root.path;
+        const rootOutput = toRootOutput(root);
+        const newChangeHint = withStoreFlag(root, 'openspec new change <name>');
         // Handle no-changes case gracefully — status is informational,
         // so "no changes" is a valid state, not an error.
         if (!options.change) {
-            const available = await getAvailableChanges(projectRoot, planningHome.changesDir);
+            const available = await getAvailableChanges(projectRoot, root.changesDir);
             if (available.length === 0) {
                 spinner?.stop();
                 if (options.json) {
-                    console.log(JSON.stringify({ changes: [], message: 'No active changes.' }, null, 2));
+                    console.log(JSON.stringify({ changes: [], message: 'No active changes.', root: rootOutput }, null, 2));
                     return;
                 }
-                console.log('No active changes. Create one with: openspec new change <name>');
+                console.log(`No active changes. Create one with: ${newChangeHint}`);
                 return;
             }
             // Changes exist but --change not provided
             spinner?.stop();
             throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
         }
-        const changeName = await validateChangeExists(options.change, projectRoot, planningHome.changesDir);
+        const changeName = await validateChangeExists(options.change, projectRoot, root.changesDir, { newChangeHint });
         // Validate schema if explicitly provided
         if (options.schema) {
             validateSchemaExists(options.schema, projectRoot);
@@ -43,10 +52,10 @@ export async function statusCommand(options) {
             changeDir: getChangeDir(planningHome, changeName),
             planningHome,
         });
-        const status = formatChangeStatus(context);
+        const status = formatChangeStatus(context, isStoreSelectedRoot(root) ? { storeId: root.storeId } : {});
         spinner?.stop();
         if (options.json) {
-            console.log(JSON.stringify(status, null, 2));
+            console.log(JSON.stringify({ ...status, root: rootOutput }, null, 2));
             return;
         }
         printStatusText(status);
@@ -61,14 +70,7 @@ export function printStatusText(status) {
     const total = status.artifacts.length;
     console.log(`Change: ${status.changeName}`);
     console.log(`Schema: ${status.schemaName}`);
-    if (status.initiative) {
-        console.log(`Initiative: ${status.initiative.store}/${status.initiative.id}`);
-    }
-    if (status.planningHome) {
-        const label = status.planningHome.kind === 'workspace'
-            ? `workspace${status.planningHome.workspaceName ? ` (${status.planningHome.workspaceName})` : ''}`
-            : 'repo';
-        console.log(`Planning home: ${label}`);
+    if (status.changeRoot) {
         console.log(`Change root: ${status.changeRoot}`);
     }
     console.log(`Progress: ${doneCount}/${total} artifacts complete`);

package/dist/commands/workset-input.d.ts

@@ -0,0 +1,19 @@
+import { type OpenerDefinition, type OpenerScanOptions } from '../core/openers.js';
+import { StoreError } from '../core/store/errors.js';
+import { type Workset, type WorksetMember } from '../core/worksets.js';
+/** Concurrent stats; the first invalid flag (by flag order) reports. */
+export declare function resolveMemberFlags(flags: string[]): Promise<WorksetMember[]>;
+/** One spelling of "this tool id must exist in the merged table". */
+export declare function assertKnownTool(tool: string, table: OpenerDefinition[]): void;
+/** Final assembly shared by both compose paths: one validation rule. */
+export declare function finalizeWorkset(name: string, members: WorksetMember[], tool: string | undefined, table: OpenerDefinition[]): Workset;
+/** The aligned `<name>  <path>` rows used by list, remove, and the
+ * open fallback; callers pick the stream and indent. */
+export declare function formatMemberRows(members: WorksetMember[]): string[];
+export declare function toolUnknownError(toolId: string, table: OpenerDefinition[]): StoreError;
+/** Stops at the first installed alternative instead of scanning all. */
+export declare function firstInstalledAlternative(table: OpenerDefinition[], excludeId: string | undefined, scan?: OpenerScanOptions): string | null;
+export declare function toolUnavailableError(opener: OpenerDefinition, table: OpenerDefinition[], worksetName: string, scan?: OpenerScanOptions): StoreError;
+/** Interactive open with no saved tool and nothing installed at all. */
+export declare function noToolInstalledError(table: OpenerDefinition[], worksetName: string): StoreError;
+//# sourceMappingURL=workset-input.d.ts.map

package/dist/commands/workset-input.js

@@ -0,0 +1,112 @@
+/**
+ * Input resolution and error builders shared by the workset command
+ * and its interactive prompt flows.
+ */
+import * as path from 'node:path';
+import { pathIsDirectory } from '../core/file-state.js';
+import { findOpener, isOpenerCommandAvailable, isOpenerEnabled, } from '../core/openers.js';
+import { StoreError } from '../core/store/errors.js';
+import { expandUserPath } from '../core/store/operations.js';
+import { getGlobalConfigPath } from '../core/global-config.js';
+import { memberLabelProblem, memberListProblem, } from '../core/worksets.js';
+function memberInvalidError(problem) {
+    return new StoreError(`Invalid workset member: ${problem}.`, 'workset_member_invalid', {
+        target: 'workset.member',
+        fix: 'Pass --member <path> with an existing folder, or --member <name>=<path> to label it.',
+    });
+}
+/** `--member <path>` or `--member <name>=<path>` (the first `=` splits). */
+async function resolveMemberFlag(raw) {
+    const separator = raw.indexOf('=');
+    const label = separator > 0 ? raw.slice(0, separator) : undefined;
+    const rawPath = separator > 0 ? raw.slice(separator + 1) : raw;
+    if (rawPath.length === 0) {
+        throw memberInvalidError(`'${raw}' has no path`);
+    }
+    const resolvedPath = path.resolve(expandUserPath(rawPath));
+    if (!(await pathIsDirectory(resolvedPath))) {
+        throw memberInvalidError(`'${rawPath}' is not an existing folder`);
+    }
+    const name = label ?? path.basename(resolvedPath);
+    const labelProblem = memberLabelProblem(name);
+    if (labelProblem !== null) {
+        throw memberInvalidError(labelProblem);
+    }
+    return { name, path: resolvedPath };
+}
+/** Concurrent stats; the first invalid flag (by flag order) reports. */
+export async function resolveMemberFlags(flags) {
+    const settled = await Promise.allSettled(flags.map(resolveMemberFlag));
+    const members = [];
+    for (const result of settled) {
+        if (result.status === 'rejected') {
+            throw result.reason;
+        }
+        members.push(result.value);
+    }
+    return members;
+}
+/** One spelling of "this tool id must exist in the merged table". */
+export function assertKnownTool(tool, table) {
+    if (findOpener(table, tool) === null) {
+        throw toolUnknownError(tool, table);
+    }
+}
+/** Final assembly shared by both compose paths: one validation rule. */
+export function finalizeWorkset(name, members, tool, table) {
+    const problem = memberListProblem(members);
+    if (problem !== null) {
+        throw memberInvalidError(problem);
+    }
+    if (tool !== undefined) {
+        assertKnownTool(tool, table);
+    }
+    return {
+        name,
+        ...(tool !== undefined ? { tool } : {}),
+        members,
+    };
+}
+/** The aligned `<name>  <path>` rows used by list, remove, and the
+ * open fallback; callers pick the stream and indent. */
+export function formatMemberRows(members) {
+    const width = Math.max(...members.map((member) => member.name.length));
+    return members.map((member) => `${member.name.padEnd(width)}  ${member.path}`);
+}
+export function toolUnknownError(toolId, table) {
+    const knownIds = table
+        .filter((opener) => isOpenerEnabled(opener))
+        .map((opener) => opener.id)
+        .join(', ');
+    return new StoreError(`Unknown tool '${toolId}'.`, 'workset_tool_unknown', {
+        target: 'workset.tool',
+        fix: `Known tools: ${knownIds}. Add new tools under "openers" in ${getGlobalConfigPath()}.`,
+    });
+}
+/** Stops at the first installed alternative instead of scanning all. */
+export function firstInstalledAlternative(table, excludeId, scan) {
+    return (table.find((candidate) => candidate.id !== excludeId &&
+        isOpenerEnabled(candidate) &&
+        isOpenerCommandAvailable(candidate.command, scan))?.id ?? null);
+}
+export function toolUnavailableError(opener, table, worksetName, scan) {
+    const alternative = firstInstalledAlternative(table, opener.id, scan);
+    return new StoreError(`${opener.label} ('${opener.command}') is not on PATH.`, 'workset_tool_unavailable', {
+        target: 'workset.tool',
+        fix: alternative !== null
+            ? `Install '${opener.command}' or run: openspec workset open ${worksetName} --tool ${alternative}`
+            : `Install '${opener.command}', then rerun: openspec workset open ${worksetName}`,
+    });
+}
+/** Interactive open with no saved tool and nothing installed at all. */
+export function noToolInstalledError(table, worksetName) {
+    const commands = table
+        .filter((opener) => isOpenerEnabled(opener))
+        .map((opener) => opener.command)
+        .join(', ');
+    return new StoreError('None of the known tools is on PATH.', 'workset_tool_unavailable', {
+        target: 'workset.tool',
+        fix: `Install one of: ${commands}. Then rerun: openspec workset open ${worksetName}`,
+    });
+}
+//# sourceMappingURL=workset-input.js.map

package/dist/commands/workset-prompts.d.ts

@@ -0,0 +1,12 @@
+import { type OpenerChoice, type OpenerDefinition } from '../core/openers.js';
+import { type Workset } from '../core/worksets.js';
+export interface ComposeInput {
+    memberFlags: string[];
+    tool?: string;
+}
+export declare function composeInteractively(givenName: string | undefined, input: ComposeInput, table: OpenerDefinition[]): Promise<Workset>;
+export declare function promptToolFromChoices(available: OpenerChoice[]): Promise<string>;
+export declare function promptOpenNow(label: string): Promise<boolean>;
+/** Prints the workset (decision 13: remove shows what it removes). */
+export declare function confirmRemoveInteractively(workset: Workset): Promise<boolean>;
+//# sourceMappingURL=workset-prompts.d.ts.map

package/dist/commands/workset-prompts.js

@@ -0,0 +1,143 @@
+/**
+ * The workset command's interactive prompt flows (the compose wizard,
+ * the open-time tool select, the remove confirm). @inquirer is always
+ * imported dynamically at the call site - never at module top.
+ */
+import * as path from 'node:path';
+import { pathIsDirectory } from '../core/file-state.js';
+import { listOpenerChoices, } from '../core/openers.js';
+import { expandUserPath } from '../core/store/operations.js';
+import { memberLabelProblem, validateWorksetName, } from '../core/worksets.js';
+import { asErrorMessage } from './shared-output.js';
+import { assertKnownTool, finalizeWorkset, formatMemberRows, resolveMemberFlags, } from './workset-input.js';
+export async function composeInteractively(givenName, input, table) {
+    const prompts = await import('@inquirer/prompts');
+    console.log('[1/3] Name the workset');
+    let name;
+    if (givenName !== undefined) {
+        name = validateWorksetName(givenName);
+        console.log(`  Workset name: ${name}`);
+    }
+    else {
+        name = await prompts.input({
+            message: 'Workset name:',
+            required: true,
+            validate(value) {
+                try {
+                    validateWorksetName(value);
+                    return true;
+                }
+                catch (error) {
+                    return asErrorMessage(error);
+                }
+            },
+        });
+    }
+    // Flag-provided pieces are validated before any prompting, so a
+    // bad flag or tool cannot discard a finished wizard walk.
+    if (input.tool !== undefined) {
+        assertKnownTool(input.tool, table);
+    }
+    console.log('');
+    console.log('[2/3] Add member folders (the first one is the primary - sessions start there)');
+    const members = await resolveMemberFlags(input.memberFlags);
+    if (members.length > 0) {
+        finalizeWorkset(name, members, input.tool, table);
+        for (const member of members) {
+            console.log(`  Added '${member.name}' (${member.path})`);
+        }
+    }
+    while (true) {
+        if (members.length > 0) {
+            const next = await prompts.select({
+                message: 'Add another folder or finish:',
+                choices: [
+                    { name: 'Finish', value: 'finish' },
+                    { name: 'Add another folder', value: 'add' },
+                ],
+                default: 'finish',
+            });
+            if (next === 'finish') {
+                break;
+            }
+        }
+        const rawPath = await prompts.input({
+            message: 'Folder path:',
+            ...(members.length === 0 ? { default: '.', prefill: 'editable' } : {}),
+            required: true,
+            async validate(value) {
+                const resolved = path.resolve(expandUserPath(value));
+                if (!(await pathIsDirectory(resolved))) {
+                    return `'${value}' is not an existing folder`;
+                }
+                return true;
+            },
+        });
+        const resolvedPath = path.resolve(expandUserPath(rawPath));
+        let label = path.basename(resolvedPath);
+        const collision = members.some((member) => member.name === label);
+        if (memberLabelProblem(label) !== null || collision) {
+            label = await prompts.input({
+                message: 'Name this member (the folder label):',
+                required: true,
+                validate(value) {
+                    const problem = memberLabelProblem(value);
+                    if (problem !== null) {
+                        return problem;
+                    }
+                    if (members.some((member) => member.name === value)) {
+                        return `duplicate member name '${value}'`;
+                    }
+                    return true;
+                },
+            });
+        }
+        members.push({ name: label, path: resolvedPath });
+        console.log(`  Added '${label}' (${resolvedPath})`);
+    }
+    console.log('');
+    console.log('[3/3] Choose your tool');
+    let tool = input.tool;
+    if (tool === undefined) {
+        const choices = listOpenerChoices(table);
+        const available = choices.filter((choice) => choice.available);
+        if (available.length === 0) {
+            console.log('  None of the known tools is on PATH; not saving a preference.');
+            console.log(`  (Known tools: ${choices.map((choice) => `${choice.opener.id} ${choice.note ?? ''}`.trim()).join(', ')})`);
+        }
+        else {
+            tool = await promptToolFromChoices(available);
+        }
+    }
+    return finalizeWorkset(name, members, tool, table);
+}
+export async function promptToolFromChoices(available) {
+    const { select } = await import('@inquirer/prompts');
+    return select({
+        message: 'Open with:',
+        choices: available.map((choice) => ({
+            name: choice.opener.label,
+            value: choice.opener.id,
+        })),
+    });
+}
+export async function promptOpenNow(label) {
+    const { confirm } = await import('@inquirer/prompts');
+    return confirm({
+        message: `Open it now in ${label}?`,
+        default: true,
+    });
+}
+/** Prints the workset (decision 13: remove shows what it removes). */
+export async function confirmRemoveInteractively(workset) {
+    const { confirm } = await import('@inquirer/prompts');
+    console.log(`Workset '${workset.name}':`);
+    for (const row of formatMemberRows(workset.members)) {
+        console.log(`  ${row}`);
+    }
+    return confirm({
+        message: `Remove workset '${workset.name}'? (member folders are never touched)`,
+        default: false,
+    });
+}
+//# sourceMappingURL=workset-prompts.js.map