@superkou/openspec 1.4.1

package/dist/commands/workspace/open-view.js

@@ -0,0 +1,249 @@
+import { InitiativeResolutionError, resolveInitiativeViewReference, resolveSelectedInitiativeViewReference, } from '../../core/collections/initiatives/index.js';
+import { createPathContextStoreBinding, createRegisteredContextStoreBinding, formatContextStoreBinding, resolveContextStoreBinding, } from '../../core/context-store/index.js';
+import { createWorkspaceInitiativeContext, getWorkspaceContextInitiativeId, getWorkspaceOpenerLabel, } from '../../core/workspace/index.js';
+import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
+import { assertWorkspaceOpenerAvailable, buildWorkspaceOpenCommandForState, readWorkspaceOpenState, } from './open.js';
+import { selectOrCreateWorkspaceForInitiativeOpen, } from './operations.js';
+import { selectWorkspaceOpenTarget } from './open-target-selection.js';
+import { WorkspaceCliError, asErrorMessage, } from './types.js';
+import { resolveWorkspaceOpenOpener, resolveWorkspaceOpenOpenerOverride, } from './opener-selection.js';
+import { promptSetupLinks } from './setup-prompts.js';
+export function assertWorkspaceOpenSupportedOptions(options) {
+    if (!options.initiative && (options.store || options.storePath)) {
+        throw new WorkspaceCliError('workspace open accepts --store or --store-path only with --initiative.', 'workspace_open_store_without_initiative', {
+            target: 'workspace.initiative',
+            fix: 'Use openspec workspace open --initiative <id> --store <store>.',
+        });
+    }
+    if (options.prepareOnly) {
+        throw new WorkspaceCliError('workspace open supports launching through a selected opener; preview output is reserved for a future context/query surface.', 'workspace_open_prepare_only_unsupported', {
+            target: 'workspace.open',
+            fix: 'Run openspec workspace open with --agent <tool> or --editor.',
+        });
+    }
+    if (options.change) {
+        throw new WorkspaceCliError('workspace open currently supports root workspace open only; change-scoped open belongs to future workspace change planning.', 'workspace_open_change_unsupported', {
+            target: 'workspace.change',
+            fix: 'Open the root workspace, then start implementation from an explicit change workflow.',
+        });
+    }
+}
+function resolveOpenWorkspaceName(positionalName, options) {
+    if (positionalName && options.workspace && positionalName !== options.workspace) {
+        throw new WorkspaceCliError(`Conflicting workspace selectors: positional '${positionalName}' and --workspace '${options.workspace}'.`, 'workspace_selection_conflict', {
+            target: 'workspace.name',
+            fix: 'Use either the positional workspace name or --workspace with the same value.',
+        });
+    }
+    return positionalName ?? options.workspace;
+}
+function initiativeErrorAsWorkspaceError(error) {
+    if (error instanceof InitiativeResolutionError) {
+        return new WorkspaceCliError(error.message, error.code, {
+            target: error.target,
+            fix: error.fix,
+            details: error.details,
+        });
+    }
+    return new WorkspaceCliError(asErrorMessage(error), 'initiative_error');
+}
+async function resolveWorkspaceOpenInitiative(options) {
+    if (!options.initiative) {
+        return null;
+    }
+    try {
+        return await resolveInitiativeViewReference(options.initiative, {
+            store: options.store,
+            storePath: options.storePath,
+        });
+    }
+    catch (error) {
+        throw initiativeErrorAsWorkspaceError(error);
+    }
+}
+async function resolveStoredWorkspaceInitiative(context) {
+    const initiativeId = getWorkspaceContextInitiativeId(context);
+    try {
+        const resolvedStore = await resolveContextStoreBinding(context.store);
+        const selected = {
+            id: resolvedStore.id,
+            root: resolvedStore.root,
+            source: resolvedStore.source,
+        };
+        const initiative = await resolveSelectedInitiativeViewReference(selected, initiativeId);
+        return {
+            initiative,
+            warnings: resolvedStore.warnings.map(contextStoreBindingWarningToStatus),
+        };
+    }
+    catch (error) {
+        if (error instanceof InitiativeResolutionError) {
+            throw initiativeErrorAsWorkspaceError(error);
+        }
+        throw new WorkspaceCliError(`Workspace context store '${formatContextStoreBinding(context.store)}' could not be read: ${asErrorMessage(error)}`, 'workspace_context_store_unavailable', {
+            target: 'workspace.context.store',
+            fix: context.store.selector.kind === 'registry'
+                ? 'openspec context-store doctor'
+                : 'Check the path in .openspec-workspace/view.yaml.',
+        });
+    }
+}
+function contextStoreBindingWarningToStatus(warning) {
+    return {
+        severity: 'warning',
+        code: warning.code,
+        message: warning.message,
+        target: warning.target ? `workspace.context.store.${warning.target}` : 'workspace.context.store',
+        ...(warning.fix ? { fix: warning.fix } : {}),
+    };
+}
+function contextStoreBindingFromInitiative(initiative) {
+    return initiative.storeSource === 'path'
+        ? createPathContextStoreBinding({
+            id: initiative.store,
+            path: initiative.storeRoot,
+        })
+        : createRegisteredContextStoreBinding(initiative.store);
+}
+function toWorkspaceOpenResolvedContext(initiative) {
+    return {
+        contextStore: {
+            id: initiative.store,
+            root: initiative.storeRoot,
+        },
+        initiative: {
+            id: initiative.id,
+            title: initiative.title,
+            root: initiative.root,
+            metadataPath: initiative.metadataPath,
+            storePath: initiative.storePath,
+        },
+    };
+}
+function buildSkippedRootWarnings(skipped) {
+    return skipped.map((link) => {
+        const location = link.path ?? '(no local path recorded)';
+        return {
+            severity: 'warning',
+            code: 'workspace_open_link_skipped',
+            message: `Skipped linked repo or folder '${link.name}' because ${location} is not available.`,
+            target: `links.${link.name}.path`,
+            fix: `openspec workspace relink ${link.name} /path/to/${link.name}`,
+        };
+    });
+}
+export async function prepareWorkspaceOpen(positionalName, options) {
+    assertWorkspaceOpenSupportedOptions(options);
+    const workspaceName = resolveOpenWorkspaceName(positionalName, options);
+    const openerOverride = resolveWorkspaceOpenOpenerOverride(options);
+    const requestedInitiative = await resolveWorkspaceOpenInitiative(options);
+    const target = requestedInitiative
+        ? { kind: 'initiative', initiative: requestedInitiative, status: [] }
+        : await selectWorkspaceOpenTarget(workspaceName, options);
+    const interactiveCreate = target.kind === 'initiative'
+        && !options.json
+        && !resolveNoInteractive(options)
+        && isInteractive(options);
+    const baseSelected = target.kind === 'initiative'
+        ? (await selectOrCreateWorkspaceForInitiativeOpen({
+            workspaceName,
+            context: createWorkspaceInitiativeContext(contextStoreBindingFromInitiative(target.initiative), target.initiative.id),
+            preferredOpener: openerOverride,
+            linksForNewWorkspace: interactiveCreate
+                ? () => promptSetupLinks({
+                    heading: 'Link repos or folders for this workspace',
+                    intro: 'Choose local repos or folders to include when opening this initiative, or create the view without links for now.',
+                    allowEmpty: true,
+                    emptyName: 'Create without linked repos',
+                    emptyShort: 'Create without links',
+                    emptyDescription: 'Create the local workspace view and add repos or folders later',
+                    finishName: 'Create and open workspace',
+                    finishShort: 'Create and open',
+                    finishDescription: 'Create the local workspace view and continue opening it',
+                })
+                : undefined,
+        })).selected
+        : target.selected;
+    const selected = {
+        ...baseSelected,
+        status: [...baseSelected.status, ...target.status],
+    };
+    const state = await readWorkspaceOpenState(selected);
+    const stored = target.kind === 'workspace' && state.viewState.context
+        ? await resolveStoredWorkspaceInitiative(state.viewState.context)
+        : null;
+    const initiative = target.kind === 'initiative' ? target.initiative : stored?.initiative ?? null;
+    const resolvedContext = initiative ? toWorkspaceOpenResolvedContext(initiative) : null;
+    const opener = await resolveWorkspaceOpenOpener(state.viewState, options);
+    assertWorkspaceOpenerAvailable(opener, state.codeWorkspacePath);
+    const buildResult = await buildWorkspaceOpenCommandForState(opener, selected.root, state, resolvedContext);
+    return {
+        ...buildResult,
+        selected,
+        opener,
+        initiative,
+        workspaceContext: state.viewState.context,
+        warnings: [
+            ...selected.status,
+            ...(stored?.warnings ?? []),
+            ...buildSkippedRootWarnings(buildResult.skipped),
+        ],
+    };
+}
+export function buildWorkspaceOpenJsonPayload(prepared) {
+    const linkedEditRoots = prepared.openedRoots
+        .filter((root) => root.kind === 'link')
+        .map((root) => root.path);
+    return {
+        schema_version: 1,
+        workspace: {
+            name: prepared.selected.name,
+            root: prepared.selected.root,
+        },
+        context: prepared.initiative
+            ? {
+                context_store: {
+                    id: prepared.initiative.store,
+                    root: prepared.initiative.storeRoot,
+                    ...(prepared.workspaceContext
+                        ? { selector: prepared.workspaceContext.store.selector }
+                        : {}),
+                },
+                initiative: {
+                    id: prepared.initiative.id,
+                    title: prepared.initiative.title,
+                    root: prepared.initiative.root,
+                    metadata_path: prepared.initiative.metadataPath,
+                    store_path: prepared.initiative.storePath,
+                },
+            }
+            : null,
+        generated_files: {
+            agents: prepared.generated.agentsPath,
+            code_workspace: prepared.generated.codeWorkspacePath,
+        },
+        opened_roots: prepared.openedRoots,
+        skipped_roots: prepared.skipped.map((link) => ({
+            kind: 'link',
+            name: link.name,
+            path: link.path,
+            reason: link.reason,
+        })),
+        advisory_edit_boundaries: {
+            allowed_edit_roots: linkedEditRoots,
+            coordination_roots: prepared.initiative ? [prepared.initiative.root] : [],
+            enforcement: 'advisory',
+        },
+        opener: {
+            ...prepared.opener,
+            label: getWorkspaceOpenerLabel(prepared.opener),
+        },
+        launch: {
+            attempted: true,
+            status: 'succeeded',
+        },
+        warnings: prepared.warnings,
+        status: [],
+    };
+}
+//# sourceMappingURL=open-view.js.map

package/dist/commands/workspace/open.d.ts

@@ -0,0 +1,37 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { WorkspacePreferredOpener, WorkspaceViewState, WorkspaceOpenResolvedContext, WorkspaceOpenSurfaceGeneration, WorkspaceSkippedOpenLink } from '../../core/workspace/index.js';
+import { SelectedWorkspace } from './types.js';
+export declare const WORKSPACE_OPEN_MINIMAL_PROMPT = "Open this OpenSpec workspace.";
+export interface WorkspaceOpenState {
+    viewState: WorkspaceViewState;
+    codeWorkspacePath: string;
+}
+export interface WorkspaceOpenLaunchCommand {
+    executable: string;
+    args: string[];
+    cwd: string;
+    openerLabel: string;
+}
+export type WorkspaceOpenedRoot = {
+    kind: 'workspace' | 'initiative' | 'link';
+    name?: string;
+    path: string;
+};
+export interface WorkspaceOpenCommandBuildResult {
+    command: WorkspaceOpenLaunchCommand;
+    skipped: WorkspaceSkippedOpenLink[];
+    generated: WorkspaceOpenSurfaceGeneration;
+    openedRoots: WorkspaceOpenedRoot[];
+}
+export type WorkspaceOpenSpawn = typeof nodeSpawn;
+export interface WorkspaceOpenLaunchOptions {
+    spawn?: WorkspaceOpenSpawn;
+    isExecutableAvailable?: (executable: string) => boolean;
+    stdio?: 'inherit' | 'ignore';
+}
+export declare function readWorkspaceOpenState(selected: SelectedWorkspace): Promise<WorkspaceOpenState>;
+export declare function buildWorkspaceOpenLaunchCommand(opener: WorkspacePreferredOpener, workspaceRoot: string, codeWorkspacePath: string, attachedPaths: string[]): WorkspaceOpenLaunchCommand;
+export declare function assertWorkspaceOpenerAvailable(opener: WorkspacePreferredOpener, codeWorkspacePath: string, isExecutableAvailable?: (executable: string) => boolean): void;
+export declare function buildWorkspaceOpenCommandForState(opener: WorkspacePreferredOpener, workspaceRoot: string, state: WorkspaceOpenState, resolvedContext?: WorkspaceOpenResolvedContext | null): Promise<WorkspaceOpenCommandBuildResult>;
+export declare function launchWorkspaceOpenCommand(command: WorkspaceOpenLaunchCommand, options?: WorkspaceOpenLaunchOptions): Promise<void>;
+//# sourceMappingURL=open.d.ts.map

package/dist/commands/workspace/open.js

@@ -0,0 +1,110 @@
+import { createRequire } from 'node:module';
+import { getWorkspaceCodeWorkspacePath, getWorkspaceOpenerExecutable, getWorkspaceOpenerLabel, isWorkspaceExecutableAvailable, readWorkspaceViewState, syncWorkspaceOpenSurface, } from '../../core/workspace/index.js';
+import { WorkspaceCliError, asErrorMessage } from './types.js';
+export const WORKSPACE_OPEN_MINIMAL_PROMPT = 'Open this OpenSpec workspace.';
+const CODEX_CLI_WRITABLE_ROOT_SANDBOX_ARGS = ['--sandbox', 'workspace-write'];
+const require = createRequire(import.meta.url);
+const spawn = require('cross-spawn');
+function isCodexCliOpener(opener) {
+    const openerId = opener.id;
+    return opener.kind === 'agent' && (openerId === 'codex-cli' || openerId === 'codex');
+}
+export async function readWorkspaceOpenState(selected) {
+    const viewState = await readWorkspaceViewState(selected.root);
+    return {
+        viewState,
+        codeWorkspacePath: getWorkspaceCodeWorkspacePath(selected.root, viewState.name),
+    };
+}
+export function buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, codeWorkspacePath, attachedPaths) {
+    const executable = getWorkspaceOpenerExecutable(opener);
+    const openerLabel = getWorkspaceOpenerLabel(opener);
+    if (opener.kind === 'editor' || opener.id === 'github-copilot') {
+        return {
+            executable,
+            args: [codeWorkspacePath],
+            cwd: workspaceRoot,
+            openerLabel,
+        };
+    }
+    return {
+        executable,
+        args: [
+            ...(isCodexCliOpener(opener) && attachedPaths.length > 0
+                ? CODEX_CLI_WRITABLE_ROOT_SANDBOX_ARGS
+                : []),
+            ...attachedPaths.flatMap((linkedPath) => ['--add-dir', linkedPath]),
+            WORKSPACE_OPEN_MINIMAL_PROMPT,
+        ],
+        cwd: workspaceRoot,
+        openerLabel,
+    };
+}
+export function assertWorkspaceOpenerAvailable(opener, codeWorkspacePath, isExecutableAvailable = isWorkspaceExecutableAvailable) {
+    const executable = getWorkspaceOpenerExecutable(opener);
+    if (isExecutableAvailable(executable)) {
+        return;
+    }
+    const openerLabel = getWorkspaceOpenerLabel(opener);
+    const manualPath = executable === 'code'
+        ? ` You can open the workspace file manually: ${codeWorkspacePath}`
+        : '';
+    throw new WorkspaceCliError(`${openerLabel} requires '${executable}', but '${executable}' was not found on PATH.${manualPath}`, 'workspace_opener_unavailable', {
+        target: 'workspace.opener',
+        fix: `Install '${executable}' or choose another opener.`,
+    });
+}
+export async function buildWorkspaceOpenCommandForState(opener, workspaceRoot, state, resolvedContext) {
+    const openSurface = await syncWorkspaceOpenSurface(workspaceRoot, state.viewState, resolvedContext);
+    const openedRoots = [
+        { kind: 'workspace', path: workspaceRoot },
+        ...(resolvedContext
+            ? [
+                {
+                    kind: 'initiative',
+                    name: resolvedContext.initiative.id,
+                    path: resolvedContext.initiative.root,
+                },
+            ]
+            : []),
+        ...openSurface.links.map((link) => ({
+            kind: 'link',
+            name: link.name,
+            path: link.path,
+        })),
+    ];
+    return {
+        command: buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, state.codeWorkspacePath, openedRoots
+            .filter((root) => root.kind !== 'workspace')
+            .map((root) => root.path)),
+        skipped: openSurface.skipped,
+        generated: openSurface.generated,
+        openedRoots,
+    };
+}
+export async function launchWorkspaceOpenCommand(command, options = {}) {
+    const spawnCommand = options.spawn ?? spawn;
+    await new Promise((resolve, reject) => {
+        const child = spawnCommand(command.executable, command.args, {
+            cwd: command.cwd,
+            stdio: options.stdio ?? 'inherit',
+            shell: false,
+        });
+        child.on('error', (error) => {
+            reject(new WorkspaceCliError(`Could not launch ${command.openerLabel}: ${asErrorMessage(error)}`, 'workspace_opener_launch_failed', {
+                target: 'workspace.opener',
+            }));
+        });
+        child.on('close', (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+            reject(new WorkspaceCliError(`${command.openerLabel} exited with ${reason}.`, 'workspace_opener_launch_failed', {
+                target: 'workspace.opener',
+            }));
+        });
+    });
+}
+//# sourceMappingURL=open.js.map

package/dist/commands/workspace/opener-selection.d.ts

@@ -0,0 +1,11 @@
+import { WorkspacePreferredOpener } from '../../core/workspace/index.js';
+import { WorkspaceOpenOptions } from './types.js';
+export declare function promptPreferredOpener(message: string, openerChoices?: import("../../core/workspace/openers.js").WorkspaceOpenerChoice[]): Promise<WorkspacePreferredOpener>;
+export declare function parseSetupOpenerOption(opener: string | undefined): WorkspacePreferredOpener | undefined;
+export declare function parseWorkspaceAgentOverride(agent: string): WorkspacePreferredOpener;
+export declare function getPreferredWorkspaceSkillAgentId(preferredOpener: WorkspacePreferredOpener | undefined): string | null;
+export declare function resolveWorkspaceOpenOpenerOverride(options: WorkspaceOpenOptions): WorkspacePreferredOpener | undefined;
+export declare function resolveWorkspaceOpenOpener(localState: {
+    preferred_opener?: WorkspacePreferredOpener;
+}, options: WorkspaceOpenOptions): Promise<WorkspacePreferredOpener>;
+//# sourceMappingURL=opener-selection.d.ts.map

package/dist/commands/workspace/opener-selection.js

@@ -0,0 +1,98 @@
+import { getDefaultWorkspaceOpenerChoiceValue, getWorkspaceSkillToolIds, listWorkspaceOpenerChoices, parseWorkspacePreferredOpenerValue, } from '../../core/workspace/index.js';
+import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
+import { WorkspaceCliError, asErrorMessage } from './types.js';
+import { workspaceSelectTheme } from './prompt-theme.js';
+function formatOpenerChoiceName(choice) {
+    return choice.unavailableNote ? `${choice.label} (${choice.unavailableNote})` : choice.label;
+}
+export async function promptPreferredOpener(message, openerChoices = listWorkspaceOpenerChoices()) {
+    const { select } = await import('@inquirer/prompts');
+    const selectedValue = await select({
+        message,
+        default: getDefaultWorkspaceOpenerChoiceValue(openerChoices),
+        choices: openerChoices.map((choice) => ({
+            name: formatOpenerChoiceName(choice),
+            short: choice.label,
+            value: choice.value,
+            description: choice.unavailableNote ?? `Use ${choice.label}`,
+        })),
+        theme: workspaceSelectTheme,
+    });
+    return parseWorkspacePreferredOpenerValue(selectedValue);
+}
+export function parseSetupOpenerOption(opener) {
+    if (!opener) {
+        return undefined;
+    }
+    try {
+        return parseWorkspacePreferredOpenerValue(opener);
+    }
+    catch (error) {
+        throw new WorkspaceCliError(asErrorMessage(error), 'unsupported_workspace_opener', {
+            target: 'workspace.opener',
+            fix: 'Use --opener codex-cli, --opener claude, --opener github-copilot, or --opener editor.',
+        });
+    }
+}
+export function parseWorkspaceAgentOverride(agent) {
+    let opener = null;
+    try {
+        opener = parseWorkspacePreferredOpenerValue(agent);
+    }
+    catch {
+        opener = null;
+    }
+    if (!opener || opener.kind !== 'agent') {
+        throw new WorkspaceCliError(`Unsupported workspace agent '${agent}'. Supported agents: codex-cli, claude, github-copilot.`, 'unsupported_workspace_agent', {
+            target: 'workspace.opener',
+            fix: 'Use --agent codex-cli, --agent claude, or --agent github-copilot.',
+        });
+    }
+    return opener;
+}
+export function getPreferredWorkspaceSkillAgentId(preferredOpener) {
+    if (!preferredOpener || preferredOpener.kind !== 'agent') {
+        return null;
+    }
+    const toolId = preferredOpener.id === 'codex-cli' ? 'codex' : preferredOpener.id;
+    return getWorkspaceSkillToolIds().includes(toolId) ? toolId : null;
+}
+export function resolveWorkspaceOpenOpenerOverride(options) {
+    if (options.agent && options.editor) {
+        throw new WorkspaceCliError('workspace open accepts either --agent <tool> or --editor, not both.', 'workspace_opener_conflict', {
+            target: 'workspace.opener',
+            fix: 'Choose one opener override.',
+        });
+    }
+    if (options.agent) {
+        return parseWorkspaceAgentOverride(options.agent);
+    }
+    if (options.editor) {
+        return parseWorkspacePreferredOpenerValue('editor');
+    }
+    return undefined;
+}
+export async function resolveWorkspaceOpenOpener(localState, options) {
+    const override = resolveWorkspaceOpenOpenerOverride(options);
+    if (override) {
+        return override;
+    }
+    if (localState.preferred_opener) {
+        return localState.preferred_opener;
+    }
+    if (!resolveNoInteractive(options) && isInteractive(options)) {
+        const openerChoices = listWorkspaceOpenerChoices().filter((choice) => choice.available);
+        if (openerChoices.length === 0) {
+            throw new WorkspaceCliError('No supported workspace opener is available on PATH.', 'workspace_no_available_openers', {
+                target: 'workspace.opener',
+                fix: "Install VS Code ('code'), codex-cli ('codex'), or Claude ('claude'), then retry.",
+            });
+        }
+        return promptPreferredOpener('Open with:', openerChoices);
+    }
+    throw new WorkspaceCliError('This workspace does not have a preferred opener yet.', 'workspace_opener_unset', {
+        target: 'workspace.opener',
+        fix: 'Pass --agent <tool> or --editor, or run workspace setup interactively to choose a default opener.',
+    });
+}
+//# sourceMappingURL=opener-selection.js.map

package/dist/commands/workspace/operations.d.ts

@@ -0,0 +1,29 @@
+import { WorkspacePreferredOpener, WorkspaceRegistryEntry, WorkspaceContextState, WorkspaceViewState } from '../../core/workspace/index.js';
+import { SelectedWorkspace, WorkspaceLinkMutationPayload, WorkspaceListOutput, WorkspaceOutput, WorkspaceStatus } from './types.js';
+export declare function directoryExists(dirPath: string): Promise<boolean>;
+export declare function resolveExistingDirectory(inputPath: string, cwd?: string): Promise<string>;
+export declare function inferLinkName(absolutePath: string): string;
+export declare function validateWorkspaceNameForSetup(name: string): string;
+export declare function validateLinkNameForCommand(name: string): string;
+export declare function createManagedWorkspace(name: string, links: Record<string, string>, preferredOpener?: WorkspacePreferredOpener, context?: WorkspaceContextState | null, tools?: string[]): Promise<WorkspaceOutput>;
+export declare function parseSetupLinks(linkInputs: string[] | undefined): Promise<Record<string, string>>;
+export declare function loadWorkspaceForList(entry: WorkspaceRegistryEntry): Promise<WorkspaceListOutput>;
+export declare function loadWorkspaceForDoctor(selected: SelectedWorkspace): Promise<{
+    workspace: WorkspaceOutput;
+    status: WorkspaceStatus[];
+}>;
+export declare function readWorkspaceForMutation(selected: SelectedWorkspace): Promise<WorkspaceViewState>;
+export declare function addWorkspaceLink(selected: SelectedWorkspace, nameOrPath: string, linkPath?: string): Promise<WorkspaceLinkMutationPayload>;
+export declare function updateWorkspaceLink(selected: SelectedWorkspace, linkNameInput: string, linkPath: string): Promise<WorkspaceLinkMutationPayload>;
+export declare function deriveWorkspaceNameForInitiative(initiativeId: string): string;
+export declare function selectOrCreateWorkspaceForInitiativeOpen(input: {
+    workspaceName?: string;
+    context: WorkspaceContextState;
+    preferredOpener?: WorkspacePreferredOpener;
+    linksForNewWorkspace?: () => Promise<Record<string, string>>;
+}): Promise<{
+    selected: SelectedWorkspace;
+    created: boolean;
+    state: WorkspaceViewState;
+}>;
+//# sourceMappingURL=operations.d.ts.map