gmc-openspec 1.1.0 → 1.4.2

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,6 +14,7 @@ export interface ApplyInstructions {
     changeName: string;
     changeDir: string;
     schemaName: string;
+    initiative?: InitiativeLink;
     contextFiles: Record<string, string[]>;
     progress: {
         total: number;

package/dist/commands/workflow/status.js

@@ -61,6 +61,9 @@ 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})` : ''}`

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

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

@@ -0,0 +1,62 @@
+import { InitiativeViewReference } from '../../core/collections/initiatives/index.js';
+import { type ContextStoreBinding } from '../../core/context-store/index.js';
+import { WorkspaceContextState, WorkspacePreferredOpener } from '../../core/workspace/index.js';
+import { type WorkspaceOpenCommandBuildResult } from './open.js';
+import { SelectedWorkspace, WorkspaceOpenOptions, WorkspaceStatus } from './types.js';
+export interface PreparedWorkspaceOpen extends WorkspaceOpenCommandBuildResult {
+    selected: SelectedWorkspace;
+    opener: WorkspacePreferredOpener;
+    initiative: InitiativeViewReference | null;
+    workspaceContext: WorkspaceContextState | null;
+    warnings: WorkspaceStatus[];
+}
+export interface WorkspaceOpenJsonPayload {
+    schema_version: 1;
+    workspace: {
+        name: string;
+        root: string;
+    };
+    context: {
+        context_store: {
+            id: string;
+            root: string;
+            selector?: ContextStoreBinding['selector'];
+        };
+        initiative: {
+            id: string;
+            title: string;
+            root: string;
+            metadata_path: string;
+            store_path: string;
+        };
+    } | null;
+    generated_files: {
+        agents: string;
+        code_workspace: string;
+    };
+    opened_roots: PreparedWorkspaceOpen['openedRoots'];
+    skipped_roots: Array<{
+        kind: 'link';
+        name: string;
+        path: string | null;
+        reason: PreparedWorkspaceOpen['skipped'][number]['reason'];
+    }>;
+    advisory_edit_boundaries: {
+        allowed_edit_roots: string[];
+        coordination_roots: string[];
+        enforcement: 'advisory';
+    };
+    opener: PreparedWorkspaceOpen['opener'] & {
+        label: string;
+    };
+    launch: {
+        attempted: true;
+        status: 'succeeded';
+    };
+    warnings: WorkspaceStatus[];
+    status: WorkspaceStatus[];
+}
+export declare function assertWorkspaceOpenSupportedOptions(options: WorkspaceOpenOptions): void;
+export declare function prepareWorkspaceOpen(positionalName: string | undefined, options: WorkspaceOpenOptions): Promise<PreparedWorkspaceOpen>;
+export declare function buildWorkspaceOpenJsonPayload(prepared: PreparedWorkspaceOpen): WorkspaceOpenJsonPayload;
+//# sourceMappingURL=open-view.d.ts.map

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 workspace.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