@fission-ai/openspec 1.3.1 → 1.4.1

package/dist/core/templates/workflows/verify-change.js

@@ -24,9 +24,12 @@ export function getVerifyChangeSkillTemplate() {
    \`\`\`
    Parse the JSON to understand:
    - \`schemaName\`: The workflow being used (e.g., "spec-driven")
+   - \`planningHome\`, \`changeRoot\`, \`artifactPaths\`, and \`actionContext\`: path and scope context
    - Which artifacts exist for this change
 
-3. **Get the change directory and load artifacts**
+   If status reports \`actionContext.mode: "workspace-planning"\`, explain that full workspace implementation verification is not supported in this slice and STOP. Do not infer repo-local implementation ownership or edit linked repos.
+
+3. **Get planning context and load artifacts**
 
    \`\`\`bash
    openspec instructions apply --change "<name>" --json
@@ -54,7 +57,7 @@ export function getVerifyChangeSkillTemplate() {
      - Recommendation: "Complete task: <description>" or "Mark as done if already implemented"
 
    **Spec Coverage**:
-   - If delta specs exist in \`openspec/changes/<name>/specs/\`:
+   - If delta specs exist in \`contextFiles.specs\`:
      - Extract all requirements (marked with "### Requirement:")
      - For each requirement:
        - Search codebase for keywords related to the requirement
@@ -192,9 +195,12 @@ export function getOpsxVerifyCommandTemplate() {
    \`\`\`
    Parse the JSON to understand:
    - \`schemaName\`: The workflow being used (e.g., "spec-driven")
+   - \`planningHome\`, \`changeRoot\`, \`artifactPaths\`, and \`actionContext\`: path and scope context
    - Which artifacts exist for this change
 
-3. **Get the change directory and load artifacts**
+   If status reports \`actionContext.mode: "workspace-planning"\`, explain that full workspace implementation verification is not supported in this slice and STOP. Do not infer repo-local implementation ownership or edit linked repos.
+
+3. **Get planning context and load artifacts**
 
    \`\`\`bash
    openspec instructions apply --change "<name>" --json
@@ -222,7 +228,7 @@ export function getOpsxVerifyCommandTemplate() {
      - Recommendation: "Complete task: <description>" or "Mark as done if already implemented"
 
    **Spec Coverage**:
-   - If delta specs exist in \`openspec/changes/<name>/specs/\`:
+   - If delta specs exist in \`contextFiles.specs\`:
      - Extract all requirements (marked with "### Requirement:")
      - For each requirement:
        - Search codebase for keywords related to the requirement

package/dist/core/update.d.ts

@@ -38,6 +38,11 @@ export declare class UpdateCommand {
      * Displays a note about extra workflows installed that aren't in the current profile.
      */
     private displayExtraWorkflowsNote;
+    /**
+     * Suggest opting back into core when a custom profile still matches the old
+     * pre-sync core set. Keep custom profiles user-owned; do not mutate them.
+     */
+    private displayOldCoreCustomProfileNote;
     /**
      * Removes skill directories for workflows when delivery changed to commands-only.
      * Returns the number of directories removed.

package/dist/core/update.js

@@ -23,6 +23,7 @@ import { WORKFLOW_TO_SKILL_DIR, getCommandConfiguredTools, getConfiguredToolsFor
 import { scanInstalledWorkflows as scanInstalledWorkflowsShared, migrateIfNeeded as migrateIfNeededShared, } from './migration.js';
 const require = createRequire(import.meta.url);
 const { version: OPENSPEC_VERSION } = require('../../package.json');
+const OLD_CORE_WORKFLOWS = ['propose', 'explore', 'apply', 'archive'];
 /**
  * Scans installed workflow artifacts (skills and managed commands) across all configured tools.
  * Returns the union of detected workflow IDs that match ALL_WORKFLOWS.
@@ -95,6 +96,7 @@ export class UpdateCommand {
             // Still check for new tool directories and extra workflows
             this.detectNewTools(resolvedProjectPath, configuredTools);
             this.displayExtraWorkflowsNote(resolvedProjectPath, configuredTools, desiredWorkflows);
+            this.displayOldCoreCustomProfileNote(profile, globalConfig.workflows);
             return;
         }
         // 8. Display update plan
@@ -201,6 +203,7 @@ export class UpdateCommand {
         this.detectNewTools(resolvedProjectPath, configuredAndNewTools);
         // 14. Display note about extra workflows not in profile
         this.displayExtraWorkflowsNote(resolvedProjectPath, configuredAndNewTools, desiredWorkflows);
+        this.displayOldCoreCustomProfileNote(profile, globalConfig.workflows);
         // 15. List affected tools
         if (updatedTools.length > 0) {
             const toolDisplayNames = updatedTools;
@@ -264,6 +267,23 @@ export class UpdateCommand {
             console.log(chalk.dim(`Note: ${extraWorkflows.length} extra workflows not in profile (use \`openspec config profile\` to manage)`));
         }
     }
+    /**
+     * Suggest opting back into core when a custom profile still matches the old
+     * pre-sync core set. Keep custom profiles user-owned; do not mutate them.
+     */
+    displayOldCoreCustomProfileNote(profile, workflows) {
+        if (profile !== 'custom' || !workflows) {
+            return;
+        }
+        const workflowSet = new Set(workflows);
+        const matchesOldCore = workflowSet.size === OLD_CORE_WORKFLOWS.length &&
+            OLD_CORE_WORKFLOWS.every((workflow) => workflowSet.has(workflow));
+        if (!matchesOldCore) {
+            return;
+        }
+        console.log(chalk.dim('Note: The core profile now includes sync. Your custom profile is preserving the old core workflow set.'));
+        console.log(chalk.dim('Run `openspec config profile core` and then `openspec update` to add sync.'));
+    }
     /**
      * Removes skill directories for workflows when delivery changed to commands-only.
      * Returns the number of directories removed.

package/dist/core/validation/validator.d.ts

@@ -27,6 +27,17 @@ export declare class Validator {
     isValid(report: ValidationReport): boolean;
     private extractRequirementText;
     private containsShallOrMust;
+    /**
+     * Build an error message for a requirement block whose body lacks SHALL/MUST.
+     *
+     * When the SHALL/MUST keyword already appears in the requirement header (e.g.
+     * `### Requirement: The system SHALL ...`) the original generic error
+     * ("must contain SHALL or MUST") is confusing because the keyword is visibly
+     * present in the spec. Per the OpenSpec conventions the keyword has to live
+     * on the requirement body line (the line right after the header), so we point
+     * the author at that exact fix when the keyword is found in the header only.
+     */
+    private buildMissingShallOrMustMessage;
     private countScenarios;
     private formatSectionList;
 }

package/dist/core/validation/validator.js

@@ -150,7 +150,7 @@ export class Validator {
                         issues.push({ level: 'ERROR', path: entryPath, message: `ADDED "${block.name}" is missing requirement text` });
                     }
                     else if (!this.containsShallOrMust(requirementText)) {
-                        issues.push({ level: 'ERROR', path: entryPath, message: `ADDED "${block.name}" must contain SHALL or MUST` });
+                        issues.push({ level: 'ERROR', path: entryPath, message: this.buildMissingShallOrMustMessage('ADDED', block.name) });
                     }
                     const scenarioCount = this.countScenarios(block.raw);
                     if (scenarioCount < 1) {
@@ -172,7 +172,7 @@ export class Validator {
                         issues.push({ level: 'ERROR', path: entryPath, message: `MODIFIED "${block.name}" is missing requirement text` });
                     }
                     else if (!this.containsShallOrMust(requirementText)) {
-                        issues.push({ level: 'ERROR', path: entryPath, message: `MODIFIED "${block.name}" must contain SHALL or MUST` });
+                        issues.push({ level: 'ERROR', path: entryPath, message: this.buildMissingShallOrMustMessage('MODIFIED', block.name) });
                     }
                     const scenarioCount = this.countScenarios(block.raw);
                     if (scenarioCount < 1) {
@@ -401,6 +401,23 @@ export class Validator {
     containsShallOrMust(text) {
         return /\b(SHALL|MUST)\b/.test(text);
     }
+    /**
+     * Build an error message for a requirement block whose body lacks SHALL/MUST.
+     *
+     * When the SHALL/MUST keyword already appears in the requirement header (e.g.
+     * `### Requirement: The system SHALL ...`) the original generic error
+     * ("must contain SHALL or MUST") is confusing because the keyword is visibly
+     * present in the spec. Per the OpenSpec conventions the keyword has to live
+     * on the requirement body line (the line right after the header), so we point
+     * the author at that exact fix when the keyword is found in the header only.
+     */
+    buildMissingShallOrMustMessage(action, blockName) {
+        const base = `${action} "${blockName}" must contain SHALL or MUST`;
+        if (this.containsShallOrMust(blockName)) {
+            return `${base} in the requirement body, not only in the header. Move the SHALL/MUST statement to the line immediately after the "### Requirement: ..." header.`;
+        }
+        return base;
+    }
     countScenarios(blockRaw) {
         const matches = blockRaw.match(/^####\s+/gm);
         return matches ? matches.length : 0;

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

@@ -0,0 +1,67 @@
+import { type ContextStoreBinding, type ContextStoreSelector } from '../context-store/index.js';
+export declare const WORKSPACE_METADATA_DIR_NAME = ".openspec-workspace";
+export declare const WORKSPACE_VIEW_STATE_FILE_NAME = "view.yaml";
+export declare const WORKSPACE_CHANGES_DIR_NAME = "changes";
+export declare const WORKSPACE_CODE_WORKSPACE_EXTENSION = ".code-workspace";
+export declare const WORKSPACE_SUPPORTED_OPENER_VALUES: readonly ["codex-cli", "claude", "github-copilot", "editor"];
+export declare const WORKSPACE_AGENT_OPENER_IDS: readonly ["codex-cli", "claude", "github-copilot"];
+export declare const WORKSPACE_EDITOR_OPENER_IDS: readonly ["vscode"];
+export type WorkspaceSupportedOpenerValue = typeof WORKSPACE_SUPPORTED_OPENER_VALUES[number];
+export type WorkspaceAgentOpenerId = typeof WORKSPACE_AGENT_OPENER_IDS[number];
+export type WorkspaceEditorOpenerId = typeof WORKSPACE_EDITOR_OPENER_IDS[number];
+export type WorkspacePreferredOpener = {
+    kind: 'agent';
+    id: WorkspaceAgentOpenerId;
+} | {
+    kind: 'editor';
+    id: WorkspaceEditorOpenerId;
+};
+export interface WorkspaceContextState {
+    kind: 'initiative';
+    store: ContextStoreBinding;
+    initiative: {
+        id: string;
+    };
+}
+export interface WorkspaceViewState {
+    version: 1;
+    name: string;
+    context: WorkspaceContextState | null;
+    links: Record<string, string | null>;
+    preferred_opener?: WorkspacePreferredOpener;
+    tools?: string[];
+    workspace_skills?: WorkspaceSkillState;
+}
+export interface WorkspaceSkillState {
+    selected_agents: string[];
+    last_applied_profile?: 'core' | 'custom';
+    last_applied_delivery?: 'both' | 'skills' | 'commands';
+    last_applied_workflow_ids?: string[];
+    last_applied_at?: string;
+}
+export declare function getWorkspaceMetadataDir(workspaceRoot: string): string;
+export declare function getWorkspaceViewStatePath(workspaceRoot: string): string;
+export declare function getWorkspaceChangesDir(workspaceRoot: string): string;
+export declare function getWorkspaceCodeWorkspaceFileName(workspaceName: string): string;
+export declare function getWorkspaceCodeWorkspacePath(workspaceRoot: string, workspaceName: string): string;
+/**
+ * @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 declare function getWorkspacePortableIgnorePatterns(_workspaceName?: string): string[];
+export declare function validateWorkspaceName(name: string): string;
+export declare function validateWorkspaceLinkName(name: string): string;
+export declare function isValidWorkspaceName(name: string): boolean;
+export declare function isValidWorkspaceLinkName(name: string): boolean;
+export declare function isWorkspaceAgentOpenerId(value: string): value is WorkspaceAgentOpenerId;
+export declare function isWorkspaceSupportedOpenerValue(value: string): value is WorkspaceSupportedOpenerValue;
+export declare function parseWorkspacePreferredOpenerValue(value: string): WorkspacePreferredOpener;
+export declare function validateWorkspacePreferredOpener(opener: WorkspacePreferredOpener): WorkspacePreferredOpener;
+export declare function createWorkspaceInitiativeContext(store: ContextStoreBinding, initiativeId: string): WorkspaceContextState;
+export declare function getWorkspaceContextStoreId(context: WorkspaceContextState): string;
+export declare function getWorkspaceContextStoreSelector(context: WorkspaceContextState): ContextStoreSelector;
+export declare function getWorkspaceContextInitiativeId(context: WorkspaceContextState): string;
+export declare function parseWorkspaceViewState(content: string): WorkspaceViewState;
+export declare function serializeWorkspaceViewState(state: WorkspaceViewState): string;
+//# sourceMappingURL=foundation.d.ts.map

package/dist/core/workspace/foundation.js

@@ -0,0 +1,295 @@
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+import { normalizeContextStoreBinding, } from '../context-store/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+export const WORKSPACE_METADATA_DIR_NAME = '.openspec-workspace';
+export const WORKSPACE_VIEW_STATE_FILE_NAME = 'view.yaml';
+export const WORKSPACE_CHANGES_DIR_NAME = 'changes';
+export const WORKSPACE_CODE_WORKSPACE_EXTENSION = '.code-workspace';
+export const WORKSPACE_SUPPORTED_OPENER_VALUES = [
+    'codex-cli',
+    'claude',
+    'github-copilot',
+    'editor',
+];
+export const WORKSPACE_AGENT_OPENER_IDS = [
+    'codex-cli',
+    'claude',
+    'github-copilot',
+];
+export const WORKSPACE_EDITOR_OPENER_IDS = ['vscode'];
+function joinWorkspacePath(basePath, ...segments) {
+    return FileSystemUtils.joinPath(basePath, ...segments);
+}
+export function getWorkspaceMetadataDir(workspaceRoot) {
+    return joinWorkspacePath(workspaceRoot, WORKSPACE_METADATA_DIR_NAME);
+}
+export function getWorkspaceViewStatePath(workspaceRoot) {
+    return joinWorkspacePath(getWorkspaceMetadataDir(workspaceRoot), WORKSPACE_VIEW_STATE_FILE_NAME);
+}
+export function getWorkspaceChangesDir(workspaceRoot) {
+    return joinWorkspacePath(workspaceRoot, WORKSPACE_CHANGES_DIR_NAME);
+}
+export function getWorkspaceCodeWorkspaceFileName(workspaceName) {
+    validateWorkspaceName(workspaceName);
+    return `${workspaceName}${WORKSPACE_CODE_WORKSPACE_EXTENSION}`;
+}
+export function getWorkspaceCodeWorkspacePath(workspaceRoot, workspaceName) {
+    return joinWorkspacePath(workspaceRoot, getWorkspaceCodeWorkspaceFileName(workspaceName));
+}
+/**
+ * @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) {
+        throw new Error(`${label} must not be empty`);
+    }
+    if (name === '.' || name === '..') {
+        throw new Error(`${label} must not be '${name}'`);
+    }
+    if (/[\\/]/u.test(name)) {
+        throw new Error(`${label} must not contain path separators`);
+    }
+    return name;
+}
+export function validateWorkspaceName(name) {
+    validateFolderStyleName(name, 'Workspace name');
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name)) {
+        throw new Error('Workspace name must be kebab-case with lowercase letters, numbers, and single hyphen separators');
+    }
+    return name;
+}
+export function validateWorkspaceLinkName(name) {
+    return validateFolderStyleName(name, 'Workspace link name');
+}
+export function isValidWorkspaceName(name) {
+    try {
+        validateWorkspaceName(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isValidWorkspaceLinkName(name) {
+    try {
+        validateWorkspaceLinkName(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const ContextStoreSelectorSchema = z.union([
+    z
+        .object({
+        kind: z.literal('registry'),
+        id: z.string(),
+    })
+        .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({
+        id: z.string(),
+    })
+        .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),
+    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) => {
+        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 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);
+}
+export function isWorkspaceSupportedOpenerValue(value) {
+    return WORKSPACE_SUPPORTED_OPENER_VALUES.includes(value);
+}
+export function parseWorkspacePreferredOpenerValue(value) {
+    if (value === 'editor') {
+        return {
+            kind: 'editor',
+            id: 'vscode',
+        };
+    }
+    const agentId = normalizeWorkspaceAgentOpenerId(value);
+    if (agentId) {
+        return {
+            kind: 'agent',
+            id: agentId,
+        };
+    }
+    throw new Error(`Unsupported workspace opener '${value}'. Supported values: ${formatSupportedOpenerValues()}`);
+}
+export function validateWorkspacePreferredOpener(opener) {
+    if (opener.kind === 'editor' && opener.id === 'vscode') {
+        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()}`);
+}
+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.');
+    }
+    return {
+        kind: 'initiative',
+        store: normalizeContextStoreBinding(store),
+        initiative: {
+            id: initiativeId,
+        },
+    };
+}
+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 state: ${formatZodIssues(result.error)}`);
+    }
+    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,
+        name: result.data.name,
+        context: normalizeOptionalWorkspaceContextState(result.data.context),
+        links: result.data.links,
+        ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
+        ...(result.data.tools ? { tools: result.data.tools } : {}),
+        ...(result.data.workspace_skills
+            ? { workspace_skills: result.data.workspace_skills }
+            : {}),
+    };
+}
+export function serializeWorkspaceViewState(state) {
+    validateWorkspaceName(state.name);
+    assertValidMapKeys(Object.keys(state.links), validateWorkspaceLinkName, 'workspace link name');
+    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
+        ? validateWorkspacePreferredOpener(state.preferred_opener)
+        : undefined;
+    return stringifyYaml({
+        version: 1,
+        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 } : {}),
+    });
+}
+//# sourceMappingURL=foundation.js.map

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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