gmc-openspec 1.1.0 → 1.4.2

package/dist/commands/workspace/operations.js

@@ -1,29 +1,11 @@
 import * as nodeFs from 'node:fs';
 import * as path from 'node:path';
-import { getManagedWorkspaceRoot, hasWorkspaceSkillProfileDrift, getWorkspaceChangesDir, isWorkspaceRoot, parseWorkspaceSetupLinkInput, readOptionalWorkspaceLocalState, readWorkspaceRegistryState, readWorkspaceSharedState, syncWorkspaceOpenSurface, validateWorkspaceLinkName, validateWorkspaceName, writeWorkspaceLocalState, writeWorkspaceRegistryState, writeWorkspaceSharedState, } from '../../core/workspace/index.js';
+import { getWorkspaceContextInitiativeId, getWorkspaceContextStoreId, getManagedWorkspaceRoot, hasWorkspaceSkillProfileDrift, getWorkspaceChangesDir, getWorkspaceViewStatePath, isWorkspaceRoot, listKnownWorkspaceEntries, parseWorkspaceSetupLinkInput, readWorkspaceViewState, syncWorkspaceOpenSurface, validateWorkspaceLinkName, validateWorkspaceName, writeWorkspaceViewState, } from '../../core/workspace/index.js';
+import { formatContextStoreBinding, sameContextStoreBinding, } from '../../core/context-store/index.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { WorkspaceCliError, asErrorMessage, makeStatus, } from './types.js';
+import { collectWorkspaceContextStatuses } from './context-status.js';
 const fs = nodeFs.promises;
-function emptyRegistry() {
-    return { version: 1, workspaces: {} };
-}
-function emptyLocalState() {
-    return { version: 1, paths: {} };
-}
-export async function readRegistry() {
-    return (await readWorkspaceRegistryState()) ?? emptyRegistry();
-}
-async function recordWorkspaceInRegistry(name, workspaceRoot) {
-    const registry = await readRegistry();
-    const recordedWorkspaceRoot = normalizeExistingPathForStorage(workspaceRoot);
-    await writeWorkspaceRegistryState({
-        version: 1,
-        workspaces: {
-            ...registry.workspaces,
-            [name]: recordedWorkspaceRoot,
-        },
-    });
-}
 export async function directoryExists(dirPath) {
     try {
         return (await fs.stat(dirPath)).isDirectory();
@@ -33,9 +15,7 @@ export async function directoryExists(dirPath) {
     }
 }
 function normalizeExistingPathForStorage(existingPath) {
-    return process.platform === 'win32'
-        ? FileSystemUtils.canonicalizeExistingPath(existingPath)
-        : existingPath;
+    return FileSystemUtils.canonicalizeExistingPath(existingPath);
 }
 export async function resolveExistingDirectory(inputPath, cwd = process.cwd()) {
     if (inputPath.length === 0) {
@@ -58,15 +38,25 @@ export async function resolveExistingDirectory(inputPath, cwd = process.cwd()) {
 export function inferLinkName(absolutePath) {
     return path.basename(absolutePath);
 }
-function normalizeLinksForOutput(sharedState, localState) {
-    return Object.keys(sharedState.links)
+function normalizeLinksForOutput(viewState) {
+    return Object.keys(viewState.links)
         .sort((a, b) => a.localeCompare(b))
         .map((name) => ({
         name,
-        path: localState?.paths[name] ?? null,
+        path: viewState.links[name] ?? null,
         status: [],
     }));
 }
+function workspaceContextToOutput(context) {
+    if (!context) {
+        return null;
+    }
+    return {
+        store: getWorkspaceContextStoreId(context),
+        initiative: getWorkspaceContextInitiativeId(context),
+        store_selector: context.store.selector,
+    };
+}
 function formatDuplicateLinkMessage(linkName, existingPath, replacementPath) {
     return [
         `Cannot use link name '${linkName}' because another link already uses that name.`,
@@ -86,6 +76,9 @@ function duplicateLinkError(linkName, existingPath, replacementPath) {
         fix: `Choose a different link name or run 'openspec workspace relink ${linkName} ${replacementPath}'.`,
     });
 }
+function hasWorkspaceLink(links, linkName) {
+    return Object.prototype.hasOwnProperty.call(links, linkName);
+}
 function duplicateSetupLinkError(linkName, existingPath, replacementPath) {
     return new WorkspaceCliError([
         `Cannot use link name '${linkName}' because another setup link already uses that name.`,
@@ -121,7 +114,7 @@ export function validateLinkNameForCommand(name) {
 function localStateInvalidStatus(error) {
     return makeStatus('error', 'workspace_local_state_invalid', `Machine-local paths could not be read: ${asErrorMessage(error)}`, {
         target: 'workspace.local_state',
-        fix: 'Repair or remove .openspec-workspace/local.yaml, then run openspec workspace relink <name> <path> for affected links.',
+        fix: 'Repair workspace.yaml, then run openspec workspace relink <name> <path> for affected links.',
     });
 }
 function workspaceSkillDriftStatus(workspaceName) {
@@ -130,62 +123,41 @@ function workspaceSkillDriftStatus(workspaceName) {
         fix: `openspec workspace update --workspace ${workspaceName}`,
     });
 }
-function appendWorkspaceSkillDriftStatus(statuses, workspaceName, localState) {
-    if (hasWorkspaceSkillProfileDrift(localState)) {
+function appendWorkspaceSkillDriftStatus(statuses, workspaceName, viewState) {
+    if (hasWorkspaceSkillProfileDrift(viewState)) {
         statuses.push(workspaceSkillDriftStatus(workspaceName));
     }
 }
-async function readLocalStateForMutation(workspaceRoot) {
-    try {
-        return (await readOptionalWorkspaceLocalState(workspaceRoot)) ?? emptyLocalState();
-    }
-    catch (error) {
-        const status = localStateInvalidStatus(error);
-        throw new WorkspaceCliError(status.message, status.code, {
-            target: status.target,
-            fix: status.fix,
-        });
-    }
-}
-export async function createManagedWorkspace(name, links, preferredOpener) {
+export async function createManagedWorkspace(name, links, preferredOpener, context = null, tools) {
     const workspaceName = validateWorkspaceNameForSetup(name);
-    const workspaceRoot = getManagedWorkspaceRoot(workspaceName);
-    const registry = await readRegistry();
-    if (registry.workspaces[workspaceName]) {
-        throw new WorkspaceCliError(`Workspace '${workspaceName}' is already recorded in the local workspace registry at ${registry.workspaces[workspaceName]}.`, 'workspace_already_exists', {
+    const targetWorkspaceRoot = getManagedWorkspaceRoot(workspaceName);
+    let workspaceRoot = targetWorkspaceRoot;
+    if (await directoryExists(targetWorkspaceRoot)) {
+        throw new WorkspaceCliError(`Workspace '${workspaceName}' already exists at ${targetWorkspaceRoot}.`, 'workspace_already_exists', {
             target: 'workspace.name',
         });
     }
-    if (await directoryExists(workspaceRoot)) {
-        throw new WorkspaceCliError(`Workspace '${workspaceName}' already exists at ${workspaceRoot}.`, 'workspace_already_exists', {
-            target: 'workspace.root',
-        });
-    }
     let createdWorkspaceRoot = false;
     try {
-        await FileSystemUtils.createDirectory(path.dirname(workspaceRoot));
-        await fs.mkdir(workspaceRoot);
+        await FileSystemUtils.createDirectory(path.dirname(targetWorkspaceRoot));
+        await fs.mkdir(targetWorkspaceRoot);
         createdWorkspaceRoot = true;
-        await FileSystemUtils.createDirectory(getWorkspaceChangesDir(workspaceRoot));
-        const sharedState = {
+        workspaceRoot = FileSystemUtils.canonicalizeExistingPath(targetWorkspaceRoot);
+        const viewState = {
             version: 1,
             name: workspaceName,
-            links: Object.fromEntries(Object.keys(links).map((linkName) => [linkName, {}])),
-        };
-        const localState = {
-            version: 1,
-            paths: links,
+            context,
+            links,
             ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
+            ...(tools ? { tools } : {}),
         };
-        await writeWorkspaceSharedState(workspaceRoot, sharedState);
-        await writeWorkspaceLocalState(workspaceRoot, localState);
-        await syncWorkspaceOpenSurface(workspaceRoot, sharedState, localState);
-        await recordWorkspaceInRegistry(workspaceName, workspaceRoot);
+        await writeWorkspaceViewState(workspaceRoot, viewState);
+        await syncWorkspaceOpenSurface(workspaceRoot, viewState);
     }
     catch (error) {
         if (createdWorkspaceRoot) {
             try {
-                await fs.rm(workspaceRoot, { recursive: true, force: true });
+                await fs.rm(targetWorkspaceRoot, { recursive: true, force: true });
             }
             catch {
                 // Preserve the original creation failure; callers can retry or inspect the path.
@@ -199,6 +171,8 @@ export async function createManagedWorkspace(name, links, preferredOpener) {
         name: workspaceName,
         root: workspaceRoot,
         planning_path: getWorkspaceChangesDir(workspaceRoot),
+        state_path: getWorkspaceViewStatePath(workspaceRoot),
+        context: workspaceContextToOutput(context),
         links: Object.entries(links)
             .sort(([a], [b]) => a.localeCompare(b))
             .map(([linkName, linkPath]) => ({
@@ -228,24 +202,25 @@ export async function loadWorkspaceForList(entry) {
         return {
             name: entry.name,
             root: entry.workspaceRoot,
+            context: null,
             links: [],
             status: [
                 makeStatus('error', 'workspace_root_missing', 'Workspace location does not exist.', {
                     target: 'workspace.root',
-                    fix: 'Remove or repair the local registry record.',
+                    fix: 'Remove or repair the local workspace view.',
                 }),
             ],
         };
     }
-    let sharedState;
-    let localState = null;
+    let viewState;
     try {
-        sharedState = await readWorkspaceSharedState(entry.workspaceRoot);
+        viewState = await readWorkspaceViewState(entry.workspaceRoot);
     }
     catch (error) {
         return {
             name: entry.name,
             root: entry.workspaceRoot,
+            context: null,
             links: [],
             status: [
                 makeStatus('error', 'workspace_state_invalid', `Workspace state could not be read: ${asErrorMessage(error)}`, {
@@ -255,17 +230,13 @@ export async function loadWorkspaceForList(entry) {
             ],
         };
     }
-    try {
-        localState = await readOptionalWorkspaceLocalState(entry.workspaceRoot);
-    }
-    catch (error) {
-        workspaceStatus.push(localStateInvalidStatus(error));
-    }
-    appendWorkspaceSkillDriftStatus(workspaceStatus, sharedState.name, localState);
+    appendWorkspaceSkillDriftStatus(workspaceStatus, viewState.name, viewState);
+    workspaceStatus.push(...(await collectWorkspaceContextStatuses(viewState.context)));
     return {
-        name: sharedState.name,
+        name: viewState.name,
         root: entry.workspaceRoot,
-        links: normalizeLinksForOutput(sharedState, localState),
+        context: workspaceContextToOutput(viewState.context),
+        links: normalizeLinksForOutput(viewState),
         status: workspaceStatus,
     };
 }
@@ -279,22 +250,22 @@ export async function loadWorkspaceForDoctor(selected) {
                 name: selected.name,
                 root: selected.root,
                 planning_path: planningPath,
+                state_path: getWorkspaceViewStatePath(selected.root),
+                context: null,
                 links: [],
                 status: [
                     makeStatus('error', 'selected_workspace_root_missing', 'Selected workspace location does not exist or is not a valid workspace.', {
                         target: 'workspace.root',
-                        fix: 'Repair the local workspace registry record or choose another workspace.',
+                        fix: 'Repair the local workspace view or choose another workspace.',
                     }),
                 ],
             },
             status: commandStatus,
         };
     }
-    let sharedState;
-    let localState;
-    let localStateInvalid = false;
+    let viewState;
     try {
-        sharedState = await readWorkspaceSharedState(selected.root);
+        viewState = await readWorkspaceViewState(selected.root);
     }
     catch (error) {
         return {
@@ -302,6 +273,8 @@ export async function loadWorkspaceForDoctor(selected) {
                 name: selected.name,
                 root: selected.root,
                 planning_path: planningPath,
+                state_path: getWorkspaceViewStatePath(selected.root),
+                context: null,
                 links: [],
                 status: [
                     makeStatus('error', 'workspace_state_invalid', `Workspace state could not be read: ${asErrorMessage(error)}`, {
@@ -313,45 +286,15 @@ export async function loadWorkspaceForDoctor(selected) {
             status: commandStatus,
         };
     }
-    try {
-        const optionalLocalState = await readOptionalWorkspaceLocalState(selected.root);
-        localState = optionalLocalState ?? emptyLocalState();
-        if (!optionalLocalState) {
-            workspaceStatus.push(makeStatus('warning', 'workspace_local_state_missing', 'Machine-local paths are not recorded yet.', {
-                target: 'workspace.local_state',
-                fix: 'Run openspec workspace relink <name> <path> for each linked repo or folder on this machine.',
-            }));
-        }
-    }
-    catch (error) {
-        localState = emptyLocalState();
-        localStateInvalid = true;
-        workspaceStatus.push(localStateInvalidStatus(error));
-    }
-    if (!localStateInvalid) {
-        appendWorkspaceSkillDriftStatus(workspaceStatus, sharedState.name, localState);
-    }
-    if (!(await directoryExists(planningPath))) {
-        workspaceStatus.push(makeStatus('error', 'workspace_planning_path_missing', 'Workspace planning path does not exist.', {
-            target: 'workspace.planning_path',
-            fix: `Create ${planningPath} or recreate the workspace with openspec workspace setup.`,
-        }));
-    }
-    const sharedNames = new Set(Object.keys(sharedState.links));
-    const localNames = new Set(Object.keys(localState.paths));
-    const linkNames = [...new Set([...sharedNames, ...localNames])].sort((a, b) => a.localeCompare(b));
+    appendWorkspaceSkillDriftStatus(workspaceStatus, viewState.name, viewState);
+    workspaceStatus.push(...(await collectWorkspaceContextStatuses(viewState.context)));
+    const linkNames = Object.keys(viewState.links).sort((a, b) => a.localeCompare(b));
     const links = [];
     for (const linkName of linkNames) {
         const linkStatus = [];
-        const localPath = localState.paths[linkName] ?? null;
+        const localPath = viewState.links[linkName] ?? null;
         let repoSpecsPath = null;
-        if (!sharedNames.has(linkName)) {
-            linkStatus.push(makeStatus('warning', 'local_path_without_shared_link', 'Local path is recorded without a shared workspace link.', {
-                target: `links.${linkName}`,
-                fix: `Add a shared link with openspec workspace link ${linkName} ${localPath ?? '/path/to/folder'} or remove the local-only path from .openspec-workspace/local.yaml.`,
-            }));
-        }
-        if (sharedNames.has(linkName) && !localPath && !localStateInvalid) {
+        if (!localPath) {
             linkStatus.push(makeStatus('error', 'linked_path_missing_from_local_state', 'Shared link does not have a local path on this machine.', {
                 target: `links.${linkName}.path`,
                 fix: `openspec workspace relink ${linkName} /path/to/${linkName}`,
@@ -378,39 +321,46 @@ export async function loadWorkspaceForDoctor(selected) {
     }
     return {
         workspace: {
-            name: sharedState.name,
+            name: viewState.name,
             root: selected.root,
             planning_path: planningPath,
+            state_path: getWorkspaceViewStatePath(selected.root),
+            context: workspaceContextToOutput(viewState.context),
             links,
             status: workspaceStatus,
         },
         status: commandStatus,
     };
 }
-export async function readWorkspaceForMutation(selected) {
+async function readWorkspaceViewForMutation(selected) {
     if (!(await directoryExists(selected.root)) || !(await isWorkspaceRoot(selected.root))) {
         throw new WorkspaceCliError(`Workspace location does not exist for '${selected.name}': ${selected.root}`, 'selected_workspace_root_missing', {
             target: 'workspace.root',
             fix: 'Run openspec workspace list to inspect known workspaces.',
         });
     }
-    return {
-        sharedState: await readWorkspaceSharedState(selected.root),
-        localState: await readLocalStateForMutation(selected.root),
-    };
-}
-export async function recordSelectedWorkspaceAfterMutation(selected) {
-    if (selected.unregisteredCurrentWorkspace) {
-        await recordWorkspaceInRegistry(selected.name, selected.root);
+    try {
+        return await readWorkspaceViewState(selected.root);
     }
+    catch (error) {
+        throw new WorkspaceCliError(`Workspace state could not be read: ${asErrorMessage(error)}`, 'workspace_state_invalid', {
+            target: 'workspace.state',
+            fix: 'Repair workspace.yaml before using this workspace.',
+        });
+    }
+}
+export async function readWorkspaceForMutation(selected) {
+    return readWorkspaceViewForMutation(selected);
 }
-function buildLinkMutationPayload(selected, sharedState, localState, linkName, linkPath) {
+function buildLinkMutationPayload(selected, viewState, linkName, linkPath) {
     return {
         workspace: {
-            name: sharedState.name,
+            name: viewState.name,
             root: selected.root,
             planning_path: getWorkspaceChangesDir(selected.root),
-            links: normalizeLinksForOutput(sharedState, localState),
+            state_path: getWorkspaceViewStatePath(selected.root),
+            context: workspaceContextToOutput(viewState.context),
+            links: normalizeLinksForOutput(viewState),
             status: [],
         },
         link: {
@@ -426,50 +376,168 @@ export async function addWorkspaceLink(selected, nameOrPath, linkPath) {
     const pathInput = linkPath ?? nameOrPath;
     const resolvedPath = await resolveExistingDirectory(pathInput);
     const linkName = validateLinkNameForCommand(explicitName ?? inferLinkName(resolvedPath));
-    const { sharedState, localState } = await readWorkspaceForMutation(selected);
-    if (sharedState.links[linkName]) {
-        throw duplicateLinkError(linkName, localState.paths[linkName] ?? null, resolvedPath);
+    const viewState = await readWorkspaceViewForMutation(selected);
+    if (hasWorkspaceLink(viewState.links, linkName)) {
+        throw duplicateLinkError(linkName, viewState.links[linkName] ?? null, resolvedPath);
     }
-    const updatedSharedState = {
-        ...sharedState,
+    const updatedViewState = {
+        ...viewState,
         links: {
-            ...sharedState.links,
-            [linkName]: {},
-        },
-    };
-    const updatedLocalState = {
-        ...localState,
-        paths: {
-            ...localState.paths,
+            ...viewState.links,
             [linkName]: resolvedPath,
         },
     };
-    await writeWorkspaceSharedState(selected.root, updatedSharedState);
-    await writeWorkspaceLocalState(selected.root, updatedLocalState);
-    await syncWorkspaceOpenSurface(selected.root, updatedSharedState, updatedLocalState);
-    await recordSelectedWorkspaceAfterMutation(selected);
-    return buildLinkMutationPayload(selected, updatedSharedState, updatedLocalState, linkName, resolvedPath);
+    await writeWorkspaceViewState(selected.root, updatedViewState);
+    await syncWorkspaceOpenSurface(selected.root, updatedViewState);
+    return buildLinkMutationPayload(selected, updatedViewState, linkName, resolvedPath);
 }
 export async function updateWorkspaceLink(selected, linkNameInput, linkPath) {
     const linkName = validateLinkNameForCommand(linkNameInput);
     const resolvedPath = await resolveExistingDirectory(linkPath);
-    const { sharedState, localState } = await readWorkspaceForMutation(selected);
-    if (!sharedState.links[linkName]) {
+    const viewState = await readWorkspaceViewForMutation(selected);
+    if (!hasWorkspaceLink(viewState.links, linkName)) {
         throw new WorkspaceCliError(`Unknown workspace link '${linkName}'.`, 'unknown_link_name', {
             target: `links.${linkName}`,
             fix: 'Run openspec workspace doctor to see linked repos or folders.',
         });
     }
-    const updatedLocalState = {
-        ...localState,
-        paths: {
-            ...localState.paths,
+    const updatedViewState = {
+        ...viewState,
+        links: {
+            ...viewState.links,
             [linkName]: resolvedPath,
         },
     };
-    await writeWorkspaceLocalState(selected.root, updatedLocalState);
-    await syncWorkspaceOpenSurface(selected.root, sharedState, updatedLocalState);
-    await recordSelectedWorkspaceAfterMutation(selected);
-    return buildLinkMutationPayload(selected, sharedState, updatedLocalState, linkName, resolvedPath);
+    await writeWorkspaceViewState(selected.root, updatedViewState);
+    await syncWorkspaceOpenSurface(selected.root, updatedViewState);
+    return buildLinkMutationPayload(selected, updatedViewState, linkName, resolvedPath);
+}
+function sameWorkspaceContext(left, right) {
+    return (left !== null &&
+        sameContextStoreBinding(left.store, right.store) &&
+        getWorkspaceContextInitiativeId(left) === getWorkspaceContextInitiativeId(right));
+}
+function formatWorkspaceContext(context) {
+    return context
+        ? `${formatContextStoreBinding(context.store)}/${getWorkspaceContextInitiativeId(context)}`
+        : 'no initiative context';
+}
+export function deriveWorkspaceNameForInitiative(initiativeId) {
+    return validateWorkspaceNameForSetup(initiativeId);
+}
+async function readExistingManagedWorkspaceView(workspaceName) {
+    const workspaceRoot = getManagedWorkspaceRoot(workspaceName);
+    if (!(await directoryExists(workspaceRoot))) {
+        return null;
+    }
+    if (!(await isWorkspaceRoot(workspaceRoot))) {
+        throw new WorkspaceCliError(`Workspace name '${workspaceName}' collides with a non-workspace directory at ${workspaceRoot}.`, 'workspace_name_collision', {
+            target: 'workspace.name',
+            fix: 'Choose an explicit unused workspace name.',
+        });
+    }
+    return {
+        root: workspaceRoot,
+        state: await readWorkspaceViewState(workspaceRoot),
+    };
+}
+function selectedWorkspaceFromManagedView(root, state) {
+    return {
+        name: state.name,
+        root,
+        status: [],
+        unregisteredCurrentWorkspace: false,
+    };
+}
+export async function selectOrCreateWorkspaceForInitiativeOpen(input) {
+    if (input.workspaceName) {
+        const workspaceName = validateWorkspaceNameForSetup(input.workspaceName);
+        const existing = await readExistingManagedWorkspaceView(workspaceName);
+        if (!existing) {
+            const links = input.linksForNewWorkspace ? await input.linksForNewWorkspace() : {};
+            const workspace = await createManagedWorkspace(workspaceName, links, input.preferredOpener, input.context);
+            return {
+                selected: {
+                    name: workspace.name,
+                    root: workspace.root,
+                    status: [],
+                    unregisteredCurrentWorkspace: false,
+                },
+                created: true,
+                state: await readWorkspaceViewState(workspace.root),
+            };
+        }
+        if (sameWorkspaceContext(existing.state.context, input.context)) {
+            return {
+                selected: selectedWorkspaceFromManagedView(existing.root, existing.state),
+                created: false,
+                state: existing.state,
+            };
+        }
+        if (!existing.state.context) {
+            throw new WorkspaceCliError(`Workspace '${workspaceName}' is not bound to an initiative.`, 'workspace_context_bind_required', {
+                target: 'workspace.context',
+                fix: 'Choose a new workspace name for this initiative or use a future workspace rebind/update surface.',
+            });
+        }
+        throw new WorkspaceCliError(`Workspace '${workspaceName}' is already bound to ${formatWorkspaceContext(existing.state.context)}.`, 'workspace_context_conflict', {
+            target: 'workspace.context',
+            fix: 'Choose a different workspace name or open the initiative already bound to this workspace.',
+        });
+    }
+    const matches = [];
+    for (const entry of await listKnownWorkspaceEntries()) {
+        try {
+            const state = await readWorkspaceViewState(entry.workspaceRoot);
+            if (sameWorkspaceContext(state.context, input.context)) {
+                matches.push({ root: entry.workspaceRoot, state });
+            }
+        }
+        catch {
+            // Broken workspaces are surfaced by list/doctor; initiative open should not
+            // guess through unreadable local view records.
+        }
+    }
+    if (matches.length === 1) {
+        const [match] = matches;
+        return {
+            selected: selectedWorkspaceFromManagedView(match.root, match.state),
+            created: false,
+            state: match.state,
+        };
+    }
+    if (matches.length > 1) {
+        const names = matches.map((match) => match.state.name).sort((a, b) => a.localeCompare(b));
+        throw new WorkspaceCliError(`Multiple workspaces are already bound to ${formatWorkspaceContext(input.context)}: ${names.join(', ')}.`, 'workspace_initiative_selection_ambiguous', {
+            target: 'workspace.name',
+            fix: 'Retry with an explicit workspace name.',
+        });
+    }
+    const derivedName = deriveWorkspaceNameForInitiative(getWorkspaceContextInitiativeId(input.context));
+    const existingDerived = await readExistingManagedWorkspaceView(derivedName);
+    if (existingDerived) {
+        if (sameWorkspaceContext(existingDerived.state.context, input.context)) {
+            return {
+                selected: selectedWorkspaceFromManagedView(existingDerived.root, existingDerived.state),
+                created: false,
+                state: existingDerived.state,
+            };
+        }
+        throw new WorkspaceCliError(`Default workspace name '${derivedName}' is already used by a workspace with ${formatWorkspaceContext(existingDerived.state.context)}.`, 'workspace_name_collision', {
+            target: 'workspace.name',
+            fix: `Retry with an explicit workspace name: openspec workspace open <name> --initiative ${getWorkspaceContextStoreId(input.context)}/${getWorkspaceContextInitiativeId(input.context)}`,
+        });
+    }
+    const workspace = await createManagedWorkspace(derivedName, input.linksForNewWorkspace ? await input.linksForNewWorkspace() : {}, input.preferredOpener, input.context);
+    return {
+        selected: {
+            name: workspace.name,
+            root: workspace.root,
+            status: [],
+            unregisteredCurrentWorkspace: false,
+        },
+        created: true,
+        state: await readWorkspaceViewState(workspace.root),
+    };
 }
 //# sourceMappingURL=operations.js.map

package/dist/commands/workspace/prompt-theme.d.ts

@@ -0,0 +1,29 @@
+export declare const workspacePromptTheme: {
+    prefix: string;
+    style: {
+        answer: (text: string) => string;
+        defaultAnswer: (text: string) => string;
+        error: (text: string) => string;
+        help: (text: string) => string;
+        highlight: (text: string) => string;
+        key: (text: string) => string;
+        message: (text: string) => string;
+    };
+};
+export declare const workspaceSelectTheme: {
+    icon: {
+        cursor: string;
+    };
+    style: {
+        keysHelpTip: (keys: [key: string, action: string][]) => string;
+        answer: (text: string) => string;
+        defaultAnswer: (text: string) => string;
+        error: (text: string) => string;
+        help: (text: string) => string;
+        highlight: (text: string) => string;
+        key: (text: string) => string;
+        message: (text: string) => string;
+    };
+    prefix: string;
+};
+//# sourceMappingURL=prompt-theme.d.ts.map

package/dist/commands/workspace/prompt-theme.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+export const workspacePromptTheme = {
+    prefix: '',
+    style: {
+        answer: (text) => chalk.cyan(text),
+        defaultAnswer: (text) => chalk.dim(text),
+        error: (text) => chalk.red(text),
+        help: (text) => chalk.dim(text),
+        highlight: (text) => chalk.cyan(text),
+        key: (text) => chalk.cyan(text),
+        message: (text) => chalk.bold(text),
+    },
+};
+export const workspaceSelectTheme = {
+    ...workspacePromptTheme,
+    icon: {
+        cursor: chalk.cyan('>'),
+    },
+    style: {
+        ...workspacePromptTheme.style,
+        keysHelpTip: (keys) => chalk.dim(keys.map(([key, action]) => `${key}: ${action}`).join(' | ')),
+    },
+};
+//# sourceMappingURL=prompt-theme.js.map

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

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { WorkspaceLinkOptions, WorkspaceListOptions, WorkspaceOpenOptions, WorkspaceSetupOptions, WorkspaceUpdateOptions } from './types.js';
+export interface WorkspaceCommandActions {
+    setup(options: WorkspaceSetupOptions): Promise<void>;
+    list(options: WorkspaceListOptions): Promise<void>;
+    link(nameOrPath: string | undefined, linkPath: string | undefined, options: WorkspaceLinkOptions): Promise<void>;
+    relink(linkNameInput: string | undefined, linkPath: string | undefined, options: WorkspaceLinkOptions): Promise<void>;
+    doctor(options: WorkspaceLinkOptions): Promise<void>;
+    update(positionalName: string | undefined, options: WorkspaceUpdateOptions): Promise<void>;
+    open(positionalName: string | undefined, options: WorkspaceOpenOptions): Promise<void>;
+}
+export declare function registerWorkspaceCommandWith(program: Command, workspaceCommand: WorkspaceCommandActions): void;
+//# sourceMappingURL=registration.d.ts.map