@fission-ai/openspec 1.3.0 → 1.4.0

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

@@ -6,38 +6,135 @@
 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';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
-export async function newChangeCommand(name, options) {
-    if (!name) {
-        throw new Error('Missing required argument <name>');
+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');
+    }
+    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}`);
     }
-    const validation = validateChangeName(name);
-    if (!validation.valid) {
-        throw new Error(validation.error);
+}
+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 projectRoot = process.cwd();
-    // Validate schema if provided
-    if (options.schema) {
-        validateSchemaExists(options.schema, projectRoot);
+    const location = formatChangeLocation(planningHome, payload.change.id);
+    const scope = planningHome.kind === 'workspace' ? 'workspace change' : 'change';
+    console.log(`Created ${scope} '${payload.change.id}' at ${location}/`);
+    console.log(`Schema: ${payload.change.schema}`);
+    if (payload.initiative) {
+        console.log(`Initiative: ${formatInitiativeLink(payload.initiative)}`);
     }
-    const schemaDisplay = options.schema ? ` with schema '${options.schema}'` : '';
-    const spinner = ora(`Creating change '${name}'${schemaDisplay}...`).start();
+}
+export async function newChangeCommand(name, options) {
+    const spinner = options.json ? undefined : ora();
     try {
-        const result = await createChange(projectRoot, name, { schema: options.schema });
+        if (!name) {
+            throw new Error('Missing required argument <name>');
+        }
+        const validation = validateChangeName(name);
+        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,
+            });
+        }
+        // Validate schema if provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        const resolvedSchema = options.schema ?? planningHome.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,
+            metadata: {
+                ...(workspaceGoal ? { goal: workspaceGoal } : {}),
+                ...(affectedAreas.length > 0 ? { affected_areas: affectedAreas } : {}),
+                ...(initiative ? { initiative } : {}),
+            },
+        });
         // If description provided, create README.md with description
         if (options.description) {
             const { promises: fs } = await import('fs');
-            const changeDir = path.join(projectRoot, 'openspec', 'changes', name);
-            const readmePath = path.join(changeDir, 'README.md');
+            const readmePath = path.join(result.changeDir, 'README.md');
             await fs.writeFile(readmePath, `# ${name}\n\n${options.description}\n`, 'utf-8');
         }
-        spinner.succeed(`Created change '${name}' at openspec/changes/${name}/ (schema: ${result.schema})`);
+        const payload = outputForCreatedChange(name, result.changeDir, result.schema, initiative);
+        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.');
+        }
     }
     catch (error) {
-        spinner.fail(`Failed to create change '${name}'`);
+        spinner?.stop();
+        if (options.json) {
+            printJson({
+                change: null,
+                status: [statusFromError(error)],
+            });
+            process.exitCode = 1;
+            return;
+        }
         throw error;
     }
 }

package/dist/commands/workflow/set-change.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Set Change Command
+ *
+ * Mutates checked-in repo-local change metadata.
+ */
+export interface SetChangeOptions {
+    initiative?: string;
+    store?: string;
+    storePath?: string;
+    json?: boolean;
+}
+export declare function setChangeCommand(name: string | undefined, options: SetChangeOptions): Promise<void>;
+//# sourceMappingURL=set-change.d.ts.map

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

@@ -0,0 +1,87 @@
+/**
+ * Set Change Command
+ *
+ * Mutates checked-in repo-local change metadata.
+ */
+import path from 'node:path';
+import { getChangeDir, resolveCurrentPlanningHomeSync, } from '../../core/planning-home.js';
+import { readChangeMetadata, resolveSchemaForChange, writeChangeMetadata, } from '../../utils/change-metadata.js';
+import { validateChangeExists } from './shared.js';
+import { resolveInitiativeLinkReference, } from '../../core/collections/initiatives/index.js';
+import { assertInitiativeReference, assertRepoLocalInitiativeLinkPlanningHome, formatInitiativeLink, printJson, sameInitiativeLink, statusFromError, } from './initiative-link.js';
+function outputForSetChange(id, changeDir, schema, initiative, updated) {
+    return {
+        change: {
+            id,
+            path: changeDir,
+            metadataPath: path.join(changeDir, '.openspec.yaml'),
+            schema,
+        },
+        initiative,
+        updated,
+    };
+}
+function printSetChangeHuman(payload) {
+    if (!payload.change || !payload.initiative) {
+        return;
+    }
+    const verb = payload.updated ? 'Linked' : 'Change already linked';
+    console.log(`${verb}: ${payload.change.id}`);
+    console.log(`Initiative: ${formatInitiativeLink(payload.initiative)}`);
+    console.log(`Metadata: ${payload.change.metadataPath}`);
+}
+export async function setChangeCommand(name, options) {
+    try {
+        if (!name) {
+            throw new Error('Missing required argument <name>');
+        }
+        assertInitiativeReference(options.initiative);
+        const planningHome = resolveCurrentPlanningHomeSync();
+        assertRepoLocalInitiativeLinkPlanningHome(planningHome);
+        const projectRoot = planningHome.root;
+        const changeName = await validateChangeExists(name, projectRoot, planningHome.changesDir);
+        const changeDir = getChangeDir(planningHome, changeName);
+        const initiative = await resolveInitiativeLinkReference(options.initiative, {
+            store: options.store,
+            storePath: options.storePath,
+        });
+        const existingMetadata = readChangeMetadata(changeDir, projectRoot);
+        const metadata = existingMetadata ?? {
+            schema: resolveSchemaForChange(changeDir, undefined, projectRoot, { metadata: null }),
+        };
+        if (sameInitiativeLink(metadata.initiative, initiative)) {
+            const payload = outputForSetChange(changeName, changeDir, metadata.schema, initiative, false);
+            if (options.json) {
+                printJson(payload);
+                return;
+            }
+            printSetChangeHuman(payload);
+            return;
+        }
+        if (metadata.initiative) {
+            throw new Error(`Change '${changeName}' is already linked to initiative ${formatInitiativeLink(metadata.initiative)}.`);
+        }
+        writeChangeMetadata(changeDir, {
+            ...metadata,
+            initiative,
+        }, projectRoot);
+        const payload = outputForSetChange(changeName, changeDir, metadata.schema, initiative, true);
+        if (options.json) {
+            printJson(payload);
+            return;
+        }
+        printSetChangeHuman(payload);
+    }
+    catch (error) {
+        if (options.json) {
+            printJson({
+                change: null,
+                status: [statusFromError(error)],
+            });
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=set-change.js.map

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

@@ -4,6 +4,7 @@
  * This module contains types, constants, and validation helpers used across
  * multiple artifact workflow commands.
  */
+import type { InitiativeLink } from '../../core/change-metadata/index.js';
 export interface TaskItem {
     id: string;
     description: string;
@@ -13,7 +14,8 @@ export interface ApplyInstructions {
     changeName: string;
     changeDir: string;
     schemaName: string;
-    contextFiles: Record<string, string>;
+    initiative?: InitiativeLink;
+    contextFiles: Record<string, string[]>;
     progress: {
         total: number;
         complete: number;
@@ -41,12 +43,12 @@ export declare function getStatusIndicator(status: 'done' | 'ready' | 'blocked')
  * Returns the list of available change directory names under openspec/changes/.
  * Excludes the archive directory and hidden directories.
  */
-export declare function getAvailableChanges(projectRoot: string): Promise<string[]>;
+export declare function getAvailableChanges(projectRoot: string, changesDir?: string): Promise<string[]>;
 /**
  * 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): Promise<string>;
+export declare function validateChangeExists(changeName: string | undefined, projectRoot: string, changesDir?: string): Promise<string>;
 /**
  * Validates that a schema exists and returns available schemas if not.
  *

package/dist/commands/workflow/shared.js

@@ -56,8 +56,8 @@ export function getStatusIndicator(status) {
  * Returns the list of available change directory names under openspec/changes/.
  * Excludes the archive directory and hidden directories.
  */
-export async function getAvailableChanges(projectRoot) {
-    const changesPath = path.join(projectRoot, 'openspec', 'changes');
+export async function getAvailableChanges(projectRoot, changesDir = path.join(projectRoot, 'openspec', 'changes')) {
+    const changesPath = changesDir;
     try {
         const entries = await fs.promises.readdir(changesPath, { withFileTypes: true });
         return entries
@@ -74,9 +74,9 @@ export async function getAvailableChanges(projectRoot) {
  * 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) {
+export async function validateChangeExists(changeName, projectRoot, changesDir = path.join(projectRoot, 'openspec', 'changes')) {
     if (!changeName) {
-        const available = await getAvailableChanges(projectRoot);
+        const available = await getAvailableChanges(projectRoot, changesDir);
         if (available.length === 0) {
             throw new Error('No changes found. Create one with: openspec new change <name>');
         }
@@ -88,10 +88,10 @@ export async function validateChangeExists(changeName, projectRoot) {
         throw new Error(`Invalid change name '${changeName}': ${nameValidation.error}`);
     }
     // Check directory existence directly
-    const changePath = path.join(projectRoot, 'openspec', 'changes', changeName);
+    const changePath = path.join(changesDir, changeName);
     const exists = fs.existsSync(changePath) && fs.statSync(changePath).isDirectory();
     if (!exists) {
-        const available = await getAvailableChanges(projectRoot);
+        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>`);
         }

package/dist/commands/workflow/status.js

@@ -5,21 +5,23 @@
  */
 import ora from 'ora';
 import chalk from 'chalk';
+import { resolveCurrentPlanningHomeSync, getChangeDir } from '../../core/planning-home.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) {
-    const spinner = ora('Loading change status...').start();
+    const spinner = options.json ? undefined : ora('Loading change status...').start();
     try {
-        const projectRoot = process.cwd();
+        const planningHome = resolveCurrentPlanningHomeSync();
+        const projectRoot = planningHome.root;
         // 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);
+            const available = await getAvailableChanges(projectRoot, planningHome.changesDir);
             if (available.length === 0) {
-                spinner.stop();
+                spinner?.stop();
                 if (options.json) {
                     console.log(JSON.stringify({ changes: [], message: 'No active changes.' }, null, 2));
                     return;
@@ -28,18 +30,21 @@ export async function statusCommand(options) {
                 return;
             }
             // Changes exist but --change not provided
-            spinner.stop();
+            spinner?.stop();
             throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
         }
-        const changeName = await validateChangeExists(options.change, projectRoot);
+        const changeName = await validateChangeExists(options.change, projectRoot, planningHome.changesDir);
         // Validate schema if explicitly provided
         if (options.schema) {
             validateSchemaExists(options.schema, projectRoot);
         }
         // loadChangeContext will auto-detect schema from metadata if not provided
-        const context = loadChangeContext(projectRoot, changeName, options.schema);
+        const context = loadChangeContext(projectRoot, changeName, options.schema, {
+            changeDir: getChangeDir(planningHome, changeName),
+            planningHome,
+        });
         const status = formatChangeStatus(context);
-        spinner.stop();
+        spinner?.stop();
         if (options.json) {
             console.log(JSON.stringify(status, null, 2));
             return;
@@ -47,7 +52,7 @@ export async function statusCommand(options) {
         printStatusText(status);
     }
     catch (error) {
-        spinner.stop();
+        spinner?.stop();
         throw error;
     }
 }
@@ -56,6 +61,16 @@ 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}`);
+        console.log(`Change root: ${status.changeRoot}`);
+    }
     console.log(`Progress: ${doneCount}/${total} artifacts complete`);
     console.log();
     for (const artifact of status.artifacts) {

package/dist/commands/workflow/templates.js

@@ -6,12 +6,13 @@
 import ora from 'ora';
 import path from 'path';
 import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
 import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
 export async function templatesCommand(options) {
-    const spinner = ora('Loading templates...').start();
+    const spinner = options.json ? undefined : ora('Loading templates...').start();
     try {
         const projectRoot = process.cwd();
         const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);
@@ -40,10 +41,10 @@ export async function templatesCommand(options) {
         }
         const templates = graph.getAllArtifacts().map((artifact) => ({
             artifactId: artifact.id,
-            templatePath: path.join(schemaDir, 'templates', artifact.template),
+            templatePath: FileSystemUtils.canonicalizeExistingPath(path.join(schemaDir, 'templates', artifact.template)),
             source,
         }));
-        spinner.stop();
+        spinner?.stop();
         if (options.json) {
             const output = {};
             for (const t of templates) {
@@ -61,7 +62,7 @@ export async function templatesCommand(options) {
         }
     }
     catch (error) {
-        spinner.stop();
+        spinner?.stop();
         throw error;
     }
 }

package/dist/commands/workspace/context-status.d.ts

@@ -0,0 +1,4 @@
+import { type WorkspaceContextState } from '../../core/workspace/index.js';
+import { WorkspaceStatus } from './types.js';
+export declare function collectWorkspaceContextStatuses(context: WorkspaceContextState | null): Promise<WorkspaceStatus[]>;
+//# sourceMappingURL=context-status.d.ts.map

package/dist/commands/workspace/context-status.js

@@ -0,0 +1,59 @@
+import { mountInitiativesCollection, readInitiative, } from '../../core/collections/initiatives/index.js';
+import { formatContextStoreBinding, formatContextStoreBindingSelector, resolveContextStoreBinding, } from '../../core/context-store/index.js';
+import { getWorkspaceContextInitiativeId, } from '../../core/workspace/index.js';
+import { asErrorMessage, makeStatus } from './types.js';
+function contextStoreBindingWarningToStatus(warning) {
+    return makeStatus('warning', warning.code, warning.message, {
+        target: warning.target ? `workspace.context.store.${warning.target}` : 'workspace.context.store',
+        ...(warning.fix ? { fix: warning.fix } : {}),
+    });
+}
+export async function collectWorkspaceContextStatuses(context) {
+    if (!context) {
+        return [];
+    }
+    const initiativeId = getWorkspaceContextInitiativeId(context);
+    const contextStoreLabel = formatContextStoreBinding(context.store);
+    const selector = formatContextStoreBindingSelector(context.store);
+    let resolvedStore;
+    try {
+        resolvedStore = await resolveContextStoreBinding(context.store);
+    }
+    catch (error) {
+        return [
+            makeStatus('error', 'workspace_context_store_unavailable', `Workspace context store '${contextStoreLabel}' could not be read: ${asErrorMessage(error)}`, {
+                target: 'workspace.context.store',
+                fix: context.store.selector.kind === 'registry'
+                    ? 'openspec context-store doctor'
+                    : `Check the path in workspace.yaml or run openspec initiative show ${initiativeId} ${selector}`,
+            }),
+        ];
+    }
+    const statuses = resolvedStore.warnings.map(contextStoreBindingWarningToStatus);
+    try {
+        const initiative = await readInitiative({
+            collection: mountInitiativesCollection(resolvedStore.root),
+            id: initiativeId,
+        });
+        if (!initiative) {
+            return [
+                ...statuses,
+                makeStatus('error', 'workspace_initiative_missing', `Workspace initiative '${contextStoreLabel}/${initiativeId}' was not found.`, {
+                    target: 'workspace.context.initiative',
+                    fix: `openspec initiative show ${initiativeId} ${selector}`,
+                }),
+            ];
+        }
+        return statuses;
+    }
+    catch (error) {
+        return [
+            ...statuses,
+            makeStatus('error', 'workspace_initiative_unavailable', `Workspace initiative '${contextStoreLabel}/${initiativeId}' could not be read: ${asErrorMessage(error)}`, {
+                target: 'workspace.context.initiative',
+                fix: `openspec initiative show ${initiativeId} ${selector}`,
+            }),
+        ];
+    }
+}
+//# sourceMappingURL=context-status.js.map

package/dist/commands/workspace/open-target-selection.d.ts

@@ -0,0 +1,13 @@
+import { type InitiativeViewReference } from '../../core/collections/initiatives/index.js';
+import { type SelectedWorkspace, type WorkspaceOpenOptions, type WorkspaceStatus } from './types.js';
+export type WorkspaceOpenTarget = {
+    kind: 'workspace';
+    selected: SelectedWorkspace;
+    status: WorkspaceStatus[];
+} | {
+    kind: 'initiative';
+    initiative: InitiativeViewReference;
+    status: WorkspaceStatus[];
+};
+export declare function selectWorkspaceOpenTarget(workspaceName: string | undefined, options: WorkspaceOpenOptions): Promise<WorkspaceOpenTarget>;
+//# sourceMappingURL=open-target-selection.d.ts.map

package/dist/commands/workspace/open-target-selection.js

@@ -0,0 +1,146 @@
+import { InitiativeResolutionError, initiativeDiagnosticFromError, listInitiativeViewReferences, } from '../../core/collections/initiatives/index.js';
+import { createRegisteredContextStoreBinding, sameContextStoreBinding, } from '../../core/context-store/index.js';
+import { findWorkspaceRoot, getWorkspaceContextInitiativeId, listKnownWorkspaceEntries, readWorkspaceViewState, } from '../../core/workspace/index.js';
+import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
+import { selectWorkspaceForCommand, selectedWorkspaceFromEntry, selectedWorkspaceFromRoot, } from './selection.js';
+import { WorkspaceCliError, } from './types.js';
+async function readKnownWorkspaceContexts(entries) {
+    return Promise.all(entries.map(async (entry) => {
+        try {
+            return (await readWorkspaceViewState(entry.workspaceRoot)).context;
+        }
+        catch {
+            // Broken workspaces are surfaced by list/doctor; open target selection
+            // should not hide otherwise openable initiatives behind unreadable views.
+            return null;
+        }
+    }));
+}
+function workspaceContextMatchesInitiative(context, initiative) {
+    return (context !== null &&
+        sameContextStoreBinding(context.store, createRegisteredContextStoreBinding(initiative.store)) &&
+        getWorkspaceContextInitiativeId(context) === initiative.id);
+}
+function initiativeHasKnownWorkspace(contexts, initiative) {
+    return contexts.some((context) => workspaceContextMatchesInitiative(context, initiative));
+}
+function initiativeDiagnosticToWorkspaceStatus(diagnostic) {
+    return {
+        severity: diagnostic.severity,
+        code: diagnostic.code,
+        message: diagnostic.message,
+        target: diagnostic.target,
+        fix: diagnostic.fix,
+        details: diagnostic.details,
+    };
+}
+async function listOpenableInitiatives(entries) {
+    try {
+        const [result, contexts] = await Promise.all([
+            listInitiativeViewReferences(),
+            readKnownWorkspaceContexts(entries),
+        ]);
+        const initiatives = [];
+        for (const initiative of result.initiatives) {
+            if (!initiativeHasKnownWorkspace(contexts, initiative)) {
+                initiatives.push(initiative);
+            }
+        }
+        return {
+            kind: 'listed',
+            initiatives,
+            status: result.status.map(initiativeDiagnosticToWorkspaceStatus),
+        };
+    }
+    catch (error) {
+        const diagnostic = error instanceof InitiativeResolutionError
+            ? initiativeDiagnosticFromError(error)
+            : {
+                severity: 'error',
+                code: 'initiative_discovery_failed',
+                message: error instanceof Error ? error.message : String(error),
+                target: 'initiative',
+                fix: 'openspec context-store doctor',
+            };
+        return {
+            kind: 'unavailable',
+            initiatives: [],
+            status: [initiativeDiagnosticToWorkspaceStatus(diagnostic)],
+            error: new WorkspaceCliError(diagnostic.message, diagnostic.code, {
+                target: diagnostic.target,
+                fix: diagnostic.fix,
+                details: diagnostic.details,
+            }),
+        };
+    }
+}
+export async function selectWorkspaceOpenTarget(workspaceName, options) {
+    if (workspaceName ||
+        options.json ||
+        resolveNoInteractive(options) ||
+        !isInteractive(options)) {
+        return {
+            kind: 'workspace',
+            selected: await selectWorkspaceForCommand({
+                ...options,
+                workspace: workspaceName,
+            }, 'open', { preferPositionalName: true }),
+            status: [],
+        };
+    }
+    const entries = await listKnownWorkspaceEntries();
+    const currentWorkspaceRoot = await findWorkspaceRoot(process.cwd());
+    if (currentWorkspaceRoot) {
+        return {
+            kind: 'workspace',
+            selected: await selectedWorkspaceFromRoot(currentWorkspaceRoot, entries),
+            status: [],
+        };
+    }
+    const listed = await listOpenableInitiatives(entries);
+    if (listed.initiatives.length === 0) {
+        if (listed.kind === 'unavailable' && entries.length === 0) {
+            throw listed.error;
+        }
+        return {
+            kind: 'workspace',
+            selected: await selectWorkspaceForCommand(options, 'open', {
+                preferPositionalName: true,
+            }),
+            status: listed.status,
+        };
+    }
+    const { select } = await import('@inquirer/prompts');
+    const selected = await select({
+        message: 'Select workspace or initiative:',
+        choices: [
+            ...entries.map((entry) => ({
+                name: `Workspace: ${entry.name} (${entry.workspaceRoot})`,
+                value: {
+                    kind: 'workspace',
+                    entry,
+                },
+            })),
+            ...listed.initiatives.map((initiative) => ({
+                name: `Initiative: ${initiative.store}/${initiative.id} - ${initiative.title} (create local workspace view)`,
+                value: {
+                    kind: 'initiative',
+                    initiative,
+                },
+            })),
+        ],
+    });
+    if (selected.kind === 'workspace') {
+        return {
+            kind: 'workspace',
+            selected: selectedWorkspaceFromEntry(selected.entry),
+            status: listed.status,
+        };
+    }
+    return {
+        kind: 'initiative',
+        initiative: selected.initiative,
+        status: listed.status,
+    };
+}
+//# sourceMappingURL=open-target-selection.js.map