gmc-openspec 1.0.0 → 1.4.1

package/dist/core/workspace/foundation.js

@@ -1,26 +1,19 @@
-import * as nodeFs from 'node:fs';
-import * as path from 'node:path';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { z } from 'zod';
-import { getGlobalDataDir } from '../global-config.js';
+import { normalizeContextStoreBinding, } from '../context-store/index.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
-const fs = nodeFs.promises;
 export const WORKSPACE_METADATA_DIR_NAME = '.openspec-workspace';
-export const WORKSPACE_SHARED_STATE_FILE_NAME = 'workspace.yaml';
-export const WORKSPACE_LOCAL_STATE_FILE_NAME = 'local.yaml';
+export const WORKSPACE_VIEW_STATE_FILE_NAME = 'workspace.yaml';
 export const WORKSPACE_CHANGES_DIR_NAME = 'changes';
-export const MANAGED_WORKSPACES_DIR_NAME = 'workspaces';
-export const WORKSPACE_REGISTRY_FILE_NAME = 'registry.yaml';
-export const WORKSPACE_LOCAL_STATE_IGNORE_PATTERN = `${WORKSPACE_METADATA_DIR_NAME}/${WORKSPACE_LOCAL_STATE_FILE_NAME}`;
 export const WORKSPACE_CODE_WORKSPACE_EXTENSION = '.code-workspace';
 export const WORKSPACE_SUPPORTED_OPENER_VALUES = [
-    'codex',
+    'codex-cli',
     'claude',
     'github-copilot',
     'editor',
 ];
 export const WORKSPACE_AGENT_OPENER_IDS = [
-    'codex',
+    'codex-cli',
     'claude',
     'github-copilot',
 ];
@@ -31,25 +24,12 @@ function joinWorkspacePath(basePath, ...segments) {
 export function getWorkspaceMetadataDir(workspaceRoot) {
     return joinWorkspacePath(workspaceRoot, WORKSPACE_METADATA_DIR_NAME);
 }
-export function getWorkspaceSharedStatePath(workspaceRoot) {
-    return joinWorkspacePath(getWorkspaceMetadataDir(workspaceRoot), WORKSPACE_SHARED_STATE_FILE_NAME);
-}
-export function getWorkspaceLocalStatePath(workspaceRoot) {
-    return joinWorkspacePath(getWorkspaceMetadataDir(workspaceRoot), WORKSPACE_LOCAL_STATE_FILE_NAME);
+export function getWorkspaceViewStatePath(workspaceRoot) {
+    return joinWorkspacePath(workspaceRoot, WORKSPACE_VIEW_STATE_FILE_NAME);
 }
 export function getWorkspaceChangesDir(workspaceRoot) {
     return joinWorkspacePath(workspaceRoot, WORKSPACE_CHANGES_DIR_NAME);
 }
-export function getManagedWorkspacesDir(options = {}) {
-    return joinWorkspacePath(options.globalDataDir ?? getGlobalDataDir(), MANAGED_WORKSPACES_DIR_NAME);
-}
-export function getManagedWorkspaceRoot(workspaceName, options = {}) {
-    validateWorkspaceName(workspaceName);
-    return joinWorkspacePath(getManagedWorkspacesDir(options), workspaceName);
-}
-export function getWorkspaceRegistryPath(options = {}) {
-    return joinWorkspacePath(getManagedWorkspacesDir(options), WORKSPACE_REGISTRY_FILE_NAME);
-}
 export function getWorkspaceCodeWorkspaceFileName(workspaceName) {
     validateWorkspaceName(workspaceName);
     return `${workspaceName}${WORKSPACE_CODE_WORKSPACE_EXTENSION}`;
@@ -57,10 +37,13 @@ export function getWorkspaceCodeWorkspaceFileName(workspaceName) {
 export function getWorkspaceCodeWorkspacePath(workspaceRoot, workspaceName) {
     return joinWorkspacePath(workspaceRoot, getWorkspaceCodeWorkspaceFileName(workspaceName));
 }
-export function getWorkspacePortableIgnorePatterns(workspaceName) {
-    return workspaceName
-        ? [WORKSPACE_LOCAL_STATE_IGNORE_PATTERN, getWorkspaceCodeWorkspaceFileName(workspaceName)]
-        : [WORKSPACE_LOCAL_STATE_IGNORE_PATTERN];
+/**
+ * @deprecated Managed workspaces no longer create portable ignore rules.
+ * This compatibility shim remains for callers that still ask which ignore
+ * patterns OpenSpec owns for workspace-local generated files.
+ */
+export function getWorkspacePortableIgnorePatterns(_workspaceName) {
+    return [];
 }
 function validateFolderStyleName(name, label) {
     if (name.length === 0) {
@@ -102,86 +85,65 @@ export function isValidWorkspaceLinkName(name) {
         return false;
     }
 }
-async function pathIsFile(filePath) {
-    try {
-        return (await fs.stat(filePath)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function pathIsDirectory(dirPath) {
-    try {
-        return (await fs.stat(dirPath)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export async function isWorkspaceRoot(candidateRoot) {
-    return pathIsFile(getWorkspaceSharedStatePath(candidateRoot));
-}
-async function getSearchStartDirectory(startPath) {
-    const resolvedStart = path.resolve(startPath);
-    try {
-        const stats = await fs.stat(resolvedStart);
-        return stats.isDirectory() ? resolvedStart : path.dirname(resolvedStart);
-    }
-    catch {
-        return resolvedStart;
-    }
-}
-export async function findWorkspaceRoot(startPath = process.cwd()) {
-    let currentDir = await getSearchStartDirectory(startPath);
-    while (true) {
-        if (await isWorkspaceRoot(currentDir)) {
-            return process.platform === 'win32'
-                ? FileSystemUtils.canonicalizeExistingPath(currentDir)
-                : currentDir;
-        }
-        const parentDir = path.dirname(currentDir);
-        if (parentDir === currentDir) {
-            return null;
-        }
-        currentDir = parentDir;
-    }
-}
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-const PlainObjectSchema = z.custom(isPlainObject, {
-    message: 'must be an object',
-});
-const SharedStateSchema = z.object({
-    version: z.literal(1),
-    name: z.string(),
-    links: z.record(z.string(), PlainObjectSchema),
-}).strict();
-const LocalStateSchema = z.object({
-    version: z.literal(1),
-    paths: z.record(z.string(), z.string()),
-    preferred_opener: z
+const ContextStoreSelectorSchema = z.union([
+    z
         .object({
-        kind: z.enum(['agent', 'editor']),
+        kind: z.literal('registry'),
         id: z.string(),
     })
-        .strict()
-        .optional(),
-    workspace_skills: z
+        .strict(),
+    z
+        .object({
+        kind: z.literal('path'),
+        path: z.string(),
+        observed_id: z.string().optional(),
+    })
+        .strict(),
+]);
+const ContextStoreBindingSchema = z
+    .object({
+    id: z.string(),
+    selector: ContextStoreSelectorSchema,
+})
+    .strict();
+const WorkspaceInitiativeContextSchema = z
+    .object({
+    kind: z.literal('initiative'),
+    store: ContextStoreBindingSchema,
+    initiative: z
         .object({
-        selected_agents: z.array(z.string()),
-        last_applied_profile: z.enum(['core', 'custom']).optional(),
-        last_applied_delivery: z.enum(['both', 'skills', 'commands']).optional(),
-        last_applied_workflow_ids: z.array(z.string()).optional(),
-        last_applied_at: z.string().optional(),
+        id: z.string(),
     })
-        .strict()
-        .optional(),
-}).strict();
-const RegistryStateSchema = z.object({
+        .strict(),
+})
+    .strict();
+const WorkspaceContextSchema = WorkspaceInitiativeContextSchema;
+const WorkspaceSkillStateSchema = z
+    .object({
+    selected_agents: z.array(z.string()),
+    last_applied_profile: z.enum(['core', 'custom']).optional(),
+    last_applied_delivery: z.enum(['both', 'skills', 'commands']).optional(),
+    last_applied_workflow_ids: z.array(z.string()).optional(),
+    last_applied_at: z.string().optional(),
+})
+    .strict();
+const PreferredOpenerSchema = z
+    .object({
+    kind: z.enum(['agent', 'editor']),
+    id: z.string(),
+})
+    .strict();
+const ViewStateSchema = z
+    .object({
     version: z.literal(1),
-    workspaces: z.record(z.string(), z.string()),
-}).strict();
+    name: z.string(),
+    context: WorkspaceContextSchema.nullable(),
+    links: z.record(z.string(), z.string().nullable()),
+    preferred_opener: PreferredOpenerSchema.optional(),
+    tools: z.array(z.string()).optional(),
+    workspace_skills: WorkspaceSkillStateSchema.optional(),
+})
+    .strict();
 function formatZodIssues(error) {
     return error.issues
         .map((issue) => {
@@ -213,6 +175,15 @@ function assertValidMapKeys(keys, validator, label) {
 function formatSupportedOpenerValues() {
     return WORKSPACE_SUPPORTED_OPENER_VALUES.join(', ');
 }
+function normalizeWorkspaceAgentOpenerId(value) {
+    if (value === 'codex') {
+        return 'codex-cli';
+    }
+    if (isWorkspaceAgentOpenerId(value)) {
+        return value;
+    }
+    return null;
+}
 export function isWorkspaceAgentOpenerId(value) {
     return WORKSPACE_AGENT_OPENER_IDS.includes(value);
 }
@@ -226,10 +197,11 @@ export function parseWorkspacePreferredOpenerValue(value) {
             id: 'vscode',
         };
     }
-    if (isWorkspaceAgentOpenerId(value)) {
+    const agentId = normalizeWorkspaceAgentOpenerId(value);
+    if (agentId) {
         return {
             kind: 'agent',
-            id: value,
+            id: agentId,
         };
     }
     throw new Error(`Unsupported workspace opener '${value}'. Supported values: ${formatSupportedOpenerValues()}`);
@@ -238,73 +210,73 @@ export function validateWorkspacePreferredOpener(opener) {
     if (opener.kind === 'editor' && opener.id === 'vscode') {
         return opener;
     }
-    if (opener.kind === 'agent' && isWorkspaceAgentOpenerId(opener.id)) {
-        return opener;
+    if (opener.kind === 'agent') {
+        const agentId = normalizeWorkspaceAgentOpenerId(opener.id);
+        if (agentId) {
+            return {
+                kind: 'agent',
+                id: agentId,
+            };
+        }
     }
     throw new Error(`Unsupported workspace opener '${opener.kind}:${opener.id}'. Supported values: ${formatSupportedOpenerValues()}`);
 }
-export function parseWorkspaceSharedState(content) {
-    const raw = parseYamlObject(content, 'workspace shared state');
-    const result = SharedStateSchema.safeParse(raw);
-    if (!result.success) {
-        throw new Error(`Invalid workspace shared state: ${formatZodIssues(result.error)}`);
+function normalizeWorkspaceContextState(context) {
+    return createWorkspaceInitiativeContext(normalizeContextStoreBinding(context.store), context.initiative.id);
+}
+function normalizeOptionalWorkspaceContextState(context) {
+    return context ? normalizeWorkspaceContextState(context) : null;
+}
+export function createWorkspaceInitiativeContext(store, initiativeId) {
+    if (initiativeId.length === 0) {
+        throw new Error('Workspace initiative id must not be empty.');
     }
-    validateWorkspaceName(result.data.name);
-    assertValidMapKeys(Object.keys(result.data.links), validateWorkspaceLinkName, 'workspace link name');
     return {
-        version: 1,
-        name: result.data.name,
-        links: result.data.links,
+        kind: 'initiative',
+        store: normalizeContextStoreBinding(store),
+        initiative: {
+            id: initiativeId,
+        },
     };
 }
-export function parseWorkspaceLocalState(content) {
-    const raw = parseYamlObject(content, 'workspace local state');
-    const result = LocalStateSchema.safeParse(raw);
+export function getWorkspaceContextStoreId(context) {
+    return context.store.id;
+}
+export function getWorkspaceContextStoreSelector(context) {
+    return context.store.selector;
+}
+export function getWorkspaceContextInitiativeId(context) {
+    return context.initiative.id;
+}
+export function parseWorkspaceViewState(content) {
+    const raw = parseYamlObject(content, 'workspace state');
+    const result = ViewStateSchema.safeParse(raw);
     if (!result.success) {
-        throw new Error(`Invalid workspace local state: ${formatZodIssues(result.error)}`);
+        throw new Error(`Invalid workspace state: ${formatZodIssues(result.error)}`);
     }
-    assertValidMapKeys(Object.keys(result.data.paths), validateWorkspaceLinkName, 'workspace local path name');
+    validateWorkspaceName(result.data.name);
+    assertValidMapKeys(Object.keys(result.data.links), validateWorkspaceLinkName, 'workspace link name');
     const preferredOpener = result.data.preferred_opener
         ? validateWorkspacePreferredOpener(result.data.preferred_opener)
         : undefined;
     return {
         version: 1,
-        paths: result.data.paths,
+        name: result.data.name,
+        context: normalizeOptionalWorkspaceContextState(result.data.context),
+        links: result.data.links,
         ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
-        ...(result.data.workspace_skills ? { workspace_skills: result.data.workspace_skills } : {}),
-    };
-}
-export function parseWorkspaceRegistryState(content) {
-    const raw = parseYamlObject(content, 'workspace registry state');
-    const result = RegistryStateSchema.safeParse(raw);
-    if (!result.success) {
-        throw new Error(`Invalid workspace registry state: ${formatZodIssues(result.error)}`);
-    }
-    assertValidMapKeys(Object.keys(result.data.workspaces), validateWorkspaceName, 'workspace registry name');
-    return {
-        version: 1,
-        workspaces: result.data.workspaces,
+        ...(result.data.tools ? { tools: result.data.tools } : {}),
+        ...(result.data.workspace_skills
+            ? { workspace_skills: result.data.workspace_skills }
+            : {}),
     };
 }
-export function serializeWorkspaceSharedState(state) {
+export function serializeWorkspaceViewState(state) {
     validateWorkspaceName(state.name);
     assertValidMapKeys(Object.keys(state.links), validateWorkspaceLinkName, 'workspace link name');
-    for (const [linkName, linkState] of Object.entries(state.links)) {
-        if (!isPlainObject(linkState)) {
-            throw new Error(`Invalid workspace link '${linkName}': link state must be an object`);
-        }
-    }
-    return stringifyYaml({
-        version: 1,
-        name: state.name,
-        links: state.links,
-    });
-}
-export function serializeWorkspaceLocalState(state) {
-    assertValidMapKeys(Object.keys(state.paths), validateWorkspaceLinkName, 'workspace local path name');
-    for (const [linkName, localPath] of Object.entries(state.paths)) {
-        if (typeof localPath !== 'string') {
-            throw new Error(`Invalid workspace local path '${linkName}': path must be a string`);
+    for (const [linkName, localPath] of Object.entries(state.links)) {
+        if (localPath !== null && typeof localPath !== 'string') {
+            throw new Error(`Invalid workspace link '${linkName}': path must be a string or null`);
         }
     }
     const preferredOpener = state.preferred_opener
@@ -312,68 +284,12 @@ export function serializeWorkspaceLocalState(state) {
         : undefined;
     return stringifyYaml({
         version: 1,
-        paths: state.paths,
+        name: state.name,
+        context: state.context ? normalizeWorkspaceContextState(state.context) : null,
+        links: state.links,
         ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
+        ...(state.tools ? { tools: state.tools } : {}),
         ...(state.workspace_skills ? { workspace_skills: state.workspace_skills } : {}),
     });
 }
-export function serializeWorkspaceRegistryState(state) {
-    assertValidMapKeys(Object.keys(state.workspaces), validateWorkspaceName, 'workspace registry name');
-    for (const [workspaceName, workspaceRoot] of Object.entries(state.workspaces)) {
-        if (typeof workspaceRoot !== 'string') {
-            throw new Error(`Invalid workspace registry entry '${workspaceName}': path must be a string`);
-        }
-    }
-    return stringifyYaml({
-        version: 1,
-        workspaces: state.workspaces,
-    });
-}
-export function listWorkspaceRegistryEntries(registry) {
-    return Object.entries(registry.workspaces)
-        .map(([name, workspaceRoot]) => ({ name, workspaceRoot }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-}
-export async function readWorkspaceSharedState(workspaceRoot) {
-    return parseWorkspaceSharedState(await fs.readFile(getWorkspaceSharedStatePath(workspaceRoot), 'utf-8'));
-}
-export async function readWorkspaceLocalState(workspaceRoot) {
-    return parseWorkspaceLocalState(await fs.readFile(getWorkspaceLocalStatePath(workspaceRoot), 'utf-8'));
-}
-function isFileNotFoundError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        error.code === 'ENOENT');
-}
-export async function readOptionalWorkspaceLocalState(workspaceRoot) {
-    try {
-        return await readWorkspaceLocalState(workspaceRoot);
-    }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            return null;
-        }
-        throw error;
-    }
-}
-export async function writeWorkspaceSharedState(workspaceRoot, state) {
-    await FileSystemUtils.writeFile(getWorkspaceSharedStatePath(workspaceRoot), serializeWorkspaceSharedState(state));
-}
-export async function writeWorkspaceLocalState(workspaceRoot, state) {
-    await FileSystemUtils.writeFile(getWorkspaceLocalStatePath(workspaceRoot), serializeWorkspaceLocalState(state));
-}
-export async function readWorkspaceRegistryState(options = {}) {
-    const registryPath = getWorkspaceRegistryPath(options);
-    if (!(await pathIsFile(registryPath))) {
-        return null;
-    }
-    return parseWorkspaceRegistryState(await fs.readFile(registryPath, 'utf-8'));
-}
-export async function writeWorkspaceRegistryState(state, options = {}) {
-    await FileSystemUtils.writeFile(getWorkspaceRegistryPath(options), serializeWorkspaceRegistryState(state));
-}
-export async function workspaceChangesDirExists(workspaceRoot) {
-    return pathIsDirectory(getWorkspaceChangesDir(workspaceRoot));
-}
 //# sourceMappingURL=foundation.js.map

package/dist/core/workspace/index.d.ts

@@ -2,5 +2,7 @@ export * from './foundation.js';
 export * from './link-input.js';
 export * from './openers.js';
 export * from './open-surface.js';
+export * from './registry.js';
 export * from './skills.js';
+export * from './state-io.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/workspace/index.js

@@ -2,5 +2,7 @@ export * from './foundation.js';
 export * from './link-input.js';
 export * from './openers.js';
 export * from './open-surface.js';
+export * from './registry.js';
 export * from './skills.js';
+export * from './state-io.js';
 //# sourceMappingURL=index.js.map

package/dist/core/workspace/legacy-state.d.ts

@@ -0,0 +1,28 @@
+import { type WorkspaceContextState, type WorkspacePreferredOpener, type WorkspaceSkillState, type WorkspaceViewState } from './foundation.js';
+export declare const WORKSPACE_LEGACY_SHARED_STATE_FILE_NAME = "workspace.yaml";
+export declare const WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME = "local.yaml";
+export declare const WORKSPACE_LEGACY_LOCAL_STATE_IGNORE_PATTERN = ".openspec-workspace/local.yaml";
+export type WorkspaceLinkState = Record<string, unknown>;
+export interface WorkspaceSharedState {
+    version: 1;
+    name: string;
+    context: WorkspaceContextState | null;
+    links: Record<string, WorkspaceLinkState>;
+}
+export interface WorkspaceLocalState {
+    version: 1;
+    paths: Record<string, string>;
+    preferred_opener?: WorkspacePreferredOpener;
+    tools?: string[];
+    workspace_skills?: WorkspaceSkillState;
+}
+export declare function getWorkspaceLegacySharedStatePath(workspaceRoot: string): string;
+export declare function getWorkspaceLegacyLocalStatePath(workspaceRoot: string): string;
+export declare function workspaceViewToSharedState(state: WorkspaceViewState): WorkspaceSharedState;
+export declare function workspaceViewToLocalState(state: WorkspaceViewState): WorkspaceLocalState;
+export declare function workspaceStatePartsToViewState(sharedState: WorkspaceSharedState, localState: WorkspaceLocalState | null): WorkspaceViewState;
+export declare function parseWorkspaceSharedState(content: string): WorkspaceSharedState;
+export declare function parseWorkspaceLocalState(content: string): WorkspaceLocalState;
+export declare function serializeWorkspaceSharedState(state: WorkspaceSharedState): string;
+export declare function serializeWorkspaceLocalState(state: WorkspaceLocalState): string;
+//# sourceMappingURL=legacy-state.d.ts.map

package/dist/core/workspace/legacy-state.js

@@ -0,0 +1,200 @@
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+import { WORKSPACE_METADATA_DIR_NAME, WORKSPACE_VIEW_STATE_FILE_NAME, getWorkspaceMetadataDir, parseWorkspaceViewState, validateWorkspaceLinkName, validateWorkspaceName, validateWorkspacePreferredOpener, } from './foundation.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+export const WORKSPACE_LEGACY_SHARED_STATE_FILE_NAME = WORKSPACE_VIEW_STATE_FILE_NAME;
+export const WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME = 'local.yaml';
+export const WORKSPACE_LEGACY_LOCAL_STATE_IGNORE_PATTERN = `${WORKSPACE_METADATA_DIR_NAME}/${WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME}`;
+function joinWorkspacePath(basePath, ...segments) {
+    return FileSystemUtils.joinPath(basePath, ...segments);
+}
+export function getWorkspaceLegacySharedStatePath(workspaceRoot) {
+    return joinWorkspacePath(getWorkspaceMetadataDir(workspaceRoot), WORKSPACE_LEGACY_SHARED_STATE_FILE_NAME);
+}
+export function getWorkspaceLegacyLocalStatePath(workspaceRoot) {
+    return joinWorkspacePath(getWorkspaceMetadataDir(workspaceRoot), WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME);
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+const PlainObjectSchema = z.custom(isPlainObject, {
+    message: 'must be an object',
+});
+const PreferredOpenerSchema = z
+    .object({
+    kind: z.enum(['agent', 'editor']),
+    id: z.string(),
+})
+    .strict();
+const WorkspaceSkillStateSchema = z
+    .object({
+    selected_agents: z.array(z.string()),
+    last_applied_profile: z.enum(['core', 'custom']).optional(),
+    last_applied_delivery: z.enum(['both', 'skills', 'commands']).optional(),
+    last_applied_workflow_ids: z.array(z.string()).optional(),
+    last_applied_at: z.string().optional(),
+})
+    .strict();
+const SharedStateSchema = z.object({
+    version: z.literal(1),
+    name: z.string(),
+    context: z.unknown().optional(),
+    links: z.record(z.string(), PlainObjectSchema),
+}).strict();
+const LocalStateSchema = z.object({
+    version: z.literal(1),
+    paths: z.record(z.string(), z.string()),
+    preferred_opener: PreferredOpenerSchema.optional(),
+    tools: z.array(z.string()).optional(),
+    workspace_skills: WorkspaceSkillStateSchema.optional(),
+}).strict();
+function formatZodIssues(error) {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `${location}: ${issue.message}`;
+    })
+        .join('; ');
+}
+function parseYamlObject(content, label) {
+    try {
+        return parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid ${label}: ${message}`);
+    }
+}
+function assertValidMapKeys(keys, validator, label) {
+    for (const key of keys) {
+        try {
+            validator(key);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid ${label} '${key}': ${message}`);
+        }
+    }
+}
+function normalizeLegacyWorkspaceContext(name, context) {
+    return parseWorkspaceViewState(stringifyYaml({
+        version: 1,
+        name,
+        context: context ?? null,
+        links: {},
+    })).context;
+}
+export function workspaceViewToSharedState(state) {
+    return {
+        version: 1,
+        name: state.name,
+        context: state.context,
+        links: Object.fromEntries(Object.keys(state.links).map((linkName) => [linkName, {}])),
+    };
+}
+export function workspaceViewToLocalState(state) {
+    return {
+        version: 1,
+        paths: Object.fromEntries(Object.entries(state.links).filter((entry) => typeof entry[1] === 'string')),
+        ...(state.preferred_opener ? { preferred_opener: state.preferred_opener } : {}),
+        ...(state.tools ? { tools: state.tools } : {}),
+        ...(state.workspace_skills ? { workspace_skills: state.workspace_skills } : {}),
+    };
+}
+export function workspaceStatePartsToViewState(sharedState, localState) {
+    const linkNames = new Set([
+        ...Object.keys(sharedState.links),
+        ...Object.keys(localState?.paths ?? {}),
+    ]);
+    const links = Object.fromEntries([...linkNames]
+        .sort((a, b) => a.localeCompare(b))
+        .map((linkName) => [linkName, localState?.paths[linkName] ?? null]));
+    return {
+        version: 1,
+        name: sharedState.name,
+        context: sharedState.context,
+        links,
+        ...(localState?.preferred_opener ? { preferred_opener: localState.preferred_opener } : {}),
+        ...(localState?.tools ? { tools: localState.tools } : {}),
+        ...(localState?.workspace_skills ? { workspace_skills: localState.workspace_skills } : {}),
+    };
+}
+export function parseWorkspaceSharedState(content) {
+    const raw = parseYamlObject(content, 'workspace shared state');
+    try {
+        return workspaceViewToSharedState(parseWorkspaceViewState(content));
+    }
+    catch {
+        // Fall through to the legacy shared schema.
+    }
+    const result = SharedStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid workspace shared state: ${formatZodIssues(result.error)}`);
+    }
+    validateWorkspaceName(result.data.name);
+    assertValidMapKeys(Object.keys(result.data.links), validateWorkspaceLinkName, 'workspace link name');
+    return {
+        version: 1,
+        name: result.data.name,
+        context: normalizeLegacyWorkspaceContext(result.data.name, result.data.context),
+        links: result.data.links,
+    };
+}
+export function parseWorkspaceLocalState(content) {
+    const raw = parseYamlObject(content, 'workspace local state');
+    try {
+        return workspaceViewToLocalState(parseWorkspaceViewState(content));
+    }
+    catch {
+        // Fall through to the legacy local schema.
+    }
+    const result = LocalStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid workspace local state: ${formatZodIssues(result.error)}`);
+    }
+    assertValidMapKeys(Object.keys(result.data.paths), validateWorkspaceLinkName, 'workspace local path name');
+    const preferredOpener = result.data.preferred_opener
+        ? validateWorkspacePreferredOpener(result.data.preferred_opener)
+        : undefined;
+    return {
+        version: 1,
+        paths: result.data.paths,
+        ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
+        ...(result.data.tools ? { tools: result.data.tools } : {}),
+        ...(result.data.workspace_skills ? { workspace_skills: result.data.workspace_skills } : {}),
+    };
+}
+export function serializeWorkspaceSharedState(state) {
+    validateWorkspaceName(state.name);
+    assertValidMapKeys(Object.keys(state.links), validateWorkspaceLinkName, 'workspace link name');
+    for (const [linkName, linkState] of Object.entries(state.links)) {
+        if (!isPlainObject(linkState)) {
+            throw new Error(`Invalid workspace link '${linkName}': link state must be an object`);
+        }
+    }
+    return stringifyYaml({
+        version: 1,
+        name: state.name,
+        context: state.context,
+        links: state.links,
+    });
+}
+export function serializeWorkspaceLocalState(state) {
+    assertValidMapKeys(Object.keys(state.paths), validateWorkspaceLinkName, 'workspace local path name');
+    for (const [linkName, localPath] of Object.entries(state.paths)) {
+        if (typeof localPath !== 'string') {
+            throw new Error(`Invalid workspace local path '${linkName}': path must be a string`);
+        }
+    }
+    const preferredOpener = state.preferred_opener
+        ? validateWorkspacePreferredOpener(state.preferred_opener)
+        : undefined;
+    return stringifyYaml({
+        version: 1,
+        paths: state.paths,
+        ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
+        ...(state.tools ? { tools: state.tools } : {}),
+        ...(state.workspace_skills ? { workspace_skills: state.workspace_skills } : {}),
+    });
+}
+//# sourceMappingURL=legacy-state.js.map