@fission-ai/openspec 1.4.1 → 1.5.0

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

@@ -1,9 +1,12 @@
+import { STORE_SELECTION_GUIDANCE } from './store-selection.js';
 export function getVerifyChangeSkillTemplate() {
     return {
         name: 'openspec-verify-change',
         description: 'Verify implementation matches change artifacts. Use when the user wants to validate that implementation is complete, correct, and coherent before archiving.',
         instructions: `Verify that an implementation matches the change artifacts (specs, tasks, design).
 
+${STORE_SELECTION_GUIDANCE}
+
 **Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
 
 **Steps**
@@ -27,8 +30,6 @@ export function getVerifyChangeSkillTemplate() {
    - \`planningHome\`, \`changeRoot\`, \`artifactPaths\`, and \`actionContext\`: path and scope context
    - Which artifacts exist for this change
 
-   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
@@ -175,6 +176,8 @@ export function getOpsxVerifyCommandTemplate() {
         tags: ['workflow', 'verify', 'experimental'],
         content: `Verify that an implementation matches the change artifacts (specs, tasks, design).
 
+${STORE_SELECTION_GUIDANCE}
+
 **Input**: Optionally specify a change name after \`/opsx:verify\` (e.g., \`/opsx:verify add-auth\`). If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
 
 **Steps**
@@ -198,8 +201,6 @@ export function getOpsxVerifyCommandTemplate() {
    - \`planningHome\`, \`changeRoot\`, \`artifactPaths\`, and \`actionContext\`: path and scope context
    - Which artifacts exist for this change
 
-   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

package/dist/core/working-set.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Working-set assembly (slice 4.1): the full set a root's declarations
+ * describe — the OpenSpec root and its referenced stores — as an
+ * agent-consumable brief. A local convenience
+ * computed from declared relationships, never a planning system; no
+ * clone/sync/launch machinery. Unresolvable members are reported, not
+ * guessed.
+ */
+import type { StoreDiagnostic } from './store/errors.js';
+import { type ReferenceIndexEntry } from './references.js';
+import { type ResolvedOpenSpecRoot } from './root-selection.js';
+export type WorkingSetRole = 'referenced_store';
+export interface WorkingSetMember {
+    role: WorkingSetRole;
+    id: string;
+    path?: string;
+    remote?: string;
+    fetch?: string;
+    status: StoreDiagnostic[];
+}
+export interface WorkingSet {
+    root: {
+        path: string;
+        source: ResolvedOpenSpecRoot['source'];
+        store_id?: string;
+        role: 'openspec_root';
+    };
+    members: WorkingSetMember[];
+    status: StoreDiagnostic[];
+}
+export interface AssembleWorkingSetInput {
+    root: ResolvedOpenSpecRoot;
+    referenceEntries: ReferenceIndexEntry[];
+    /** The composition's top-level status; the working set keeps only
+     * the registry-unreadable degradation (selected by code, never by
+     * position). */
+    topLevelStatus?: StoreDiagnostic[];
+}
+/** AVAILABLE = path present AND per-entry status empty. */
+export declare function isAvailableMember(member: WorkingSetMember): boolean;
+export declare function assembleWorkingSet(input: AssembleWorkingSetInput): WorkingSet;
+/**
+ * Pure builder for the `.code-workspace` editor view — one consumer of
+ * assembly, not the feature. Available members only.
+ */
+export declare function buildCodeWorkspaceJson(workingSet: WorkingSet, rootName: string): string;
+//# sourceMappingURL=working-set.d.ts.map

package/dist/core/working-set.js

@@ -0,0 +1,43 @@
+import { fetchRecipe } from './references.js';
+import { toRootOutput } from './root-selection.js';
+/** AVAILABLE = path present AND per-entry status empty. */
+export function isAvailableMember(member) {
+    return member.path !== undefined && member.status.length === 0;
+}
+export function assembleWorkingSet(input) {
+    const members = [];
+    for (const entry of input.referenceEntries) {
+        members.push({
+            role: 'referenced_store',
+            id: entry.store_id,
+            ...(entry.root !== undefined ? { path: entry.root } : {}),
+            ...(entry.root !== undefined && entry.status.length === 0
+                ? { fetch: fetchRecipe(entry.store_id) }
+                : {}),
+            status: entry.status,
+        });
+    }
+    const status = (input.topLevelStatus ?? []).filter((entry) => entry.code === 'relationship_registry_unreadable');
+    return {
+        root: { ...toRootOutput(input.root), role: 'openspec_root' },
+        members,
+        status,
+    };
+}
+/**
+ * Pure builder for the `.code-workspace` editor view — one consumer of
+ * assembly, not the feature. Available members only.
+ */
+export function buildCodeWorkspaceJson(workingSet, rootName) {
+    const folders = [
+        { name: rootName, path: workingSet.root.path },
+    ];
+    for (const member of workingSet.members) {
+        if (!isAvailableMember(member)) {
+            continue;
+        }
+        folders.push({ name: `ref:${member.id}`, path: member.path });
+    }
+    return JSON.stringify({ folders }, null, 2) + '\n';
+}
+//# sourceMappingURL=working-set.js.map

package/dist/core/worksets.d.ts

@@ -0,0 +1,75 @@
+import { StoreError } from './store/errors.js';
+/**
+ * Personal worksets (slice 7.1): purely local, manually composed,
+ * named working views. The whole feature's state lives under
+ * <globalDataDir>/worksets/ - the saved-views file plus the generated
+ * .code-workspace files - so deleting that one directory removes
+ * every trace. Nothing here is committed, shared, or derived from
+ * declarations, and nothing is ever written into a member folder.
+ */
+export declare const WORKSETS_DIR_NAME = "worksets";
+export declare const WORKSETS_FILE_NAME = "worksets.yaml";
+export interface WorksetPathOptions {
+    globalDataDir?: string;
+}
+export interface WorksetMember {
+    /** Display label; the .code-workspace folder name. */
+    name: string;
+    /** Absolute path to the member directory. */
+    path: string;
+}
+export interface Workset {
+    name: string;
+    /** Preferred opener id; validated only at open time. */
+    tool?: string;
+    /** Ordered; the first member is the primary (session cwd). */
+    members: WorksetMember[];
+}
+export interface WorksetsState {
+    version: 1;
+    worksets: Record<string, {
+        tool?: string;
+        members: WorksetMember[];
+    }>;
+}
+export declare function getWorksetsDir(options?: WorksetPathOptions): string;
+export declare function getWorksetsFilePath(options?: WorksetPathOptions): string;
+export declare function getWorksetCodeWorkspacePath(name: string, options?: WorksetPathOptions): string;
+export declare function validateWorksetName(name: string): string;
+/**
+ * Returns a problem description for a member list, or null when valid.
+ * Shared by the file parser (wrapping as invalid_workset_file) and the
+ * compose flow (wrapping as workset_member_invalid).
+ */
+export declare function memberListProblem(members: WorksetMember[]): string | null;
+export declare function memberLabelProblem(label: string): string | null;
+export declare function parseWorksetsState(content: string, options?: WorksetPathOptions): WorksetsState;
+export declare function serializeWorksetsState(state: WorksetsState, options?: WorksetPathOptions): string;
+/** Absent file reads as the empty state; a corrupt file throws. */
+export declare function readWorksetsState(options?: WorksetPathOptions): Promise<WorksetsState>;
+export declare function updateWorksetsState(updater: (state: WorksetsState) => WorksetsState | Promise<WorksetsState>, options?: WorksetPathOptions): Promise<WorksetsState>;
+/**
+ * Lock-scoped read without a write-back of the saved-views file.
+ * `open` uses this to read the state and regenerate the derived
+ * .code-workspace coherently; the lock is released before any spawn.
+ */
+export declare function withWorksetsLock<T>(fn: (state: WorksetsState) => T | Promise<T>, options?: WorksetPathOptions): Promise<T>;
+export declare function worksetNotFoundError(name: string, state: WorksetsState): StoreError;
+export declare function withWorkset(state: WorksetsState, workset: Workset): WorksetsState;
+export declare function withoutWorkset(state: WorksetsState, name: string): WorksetsState;
+/**
+ * Removes a saved workset and its derived .code-workspace under one
+ * lock. The derived-file cleanup runs AFTER the durable write (a
+ * failed write must not have already destroyed the artifact); a
+ * never-opened workset has no file - ENOENT is fine.
+ */
+export declare function removeWorkset(name: string, options?: WorksetPathOptions): Promise<void>;
+export declare function listWorksets(state: WorksetsState): Workset[];
+export declare function getWorkset(state: WorksetsState, name: string): Workset | null;
+/**
+ * The generated .code-workspace content: members in saved order with
+ * their saved names, absolute paths, two-space JSON, trailing newline
+ * (the working-set builder's conventions).
+ */
+export declare function buildWorksetCodeWorkspaceJson(members: WorksetMember[]): string;
+//# sourceMappingURL=worksets.d.ts.map

package/dist/core/worksets.js

@@ -0,0 +1,245 @@
+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 { FileSystemUtils } from '../utils/file-system.js';
+import { acquireFileLock, makeLockErrorFactory, pathIsFile, releaseFileLock, writeFileAtomically, } from './file-state.js';
+import { StoreError } from './store/errors.js';
+import { folderStyleNameProblem, isKebabId, KEBAB_ID_DESCRIPTION, KEBAB_ID_FIX, } from './id.js';
+import { formatZodIssues } from './zod-issues.js';
+const fs = nodeFs.promises;
+/**
+ * Personal worksets (slice 7.1): purely local, manually composed,
+ * named working views. The whole feature's state lives under
+ * <globalDataDir>/worksets/ - the saved-views file plus the generated
+ * .code-workspace files - so deleting that one directory removes
+ * every trace. Nothing here is committed, shared, or derived from
+ * declarations, and nothing is ever written into a member folder.
+ */
+export const WORKSETS_DIR_NAME = 'worksets';
+export const WORKSETS_FILE_NAME = 'worksets.yaml';
+const CODE_WORKSPACE_EXTENSION = '.code-workspace';
+export function getWorksetsDir(options = {}) {
+    return FileSystemUtils.joinPath(options.globalDataDir ?? getGlobalDataDir(), WORKSETS_DIR_NAME);
+}
+export function getWorksetsFilePath(options = {}) {
+    return FileSystemUtils.joinPath(getWorksetsDir(options), WORKSETS_FILE_NAME);
+}
+export function getWorksetCodeWorkspacePath(name, options = {}) {
+    return FileSystemUtils.joinPath(getWorksetsDir(options), `${name}${CODE_WORKSPACE_EXTENSION}`);
+}
+export function validateWorksetName(name) {
+    if (!isKebabId(name)) {
+        throw new StoreError(`Workset name '${name}' ${KEBAB_ID_DESCRIPTION}.`, 'invalid_workset_name', {
+            target: 'workset.name',
+            fix: KEBAB_ID_FIX,
+        });
+    }
+    return name;
+}
+/**
+ * Returns a problem description for a member list, or null when valid.
+ * Shared by the file parser (wrapping as invalid_workset_file) and the
+ * compose flow (wrapping as workset_member_invalid).
+ */
+export function memberListProblem(members) {
+    if (members.length === 0) {
+        return 'members must not be empty';
+    }
+    const seen = new Set();
+    for (const member of members) {
+        const labelProblem = memberLabelProblem(member.name);
+        if (labelProblem !== null) {
+            return labelProblem;
+        }
+        if (seen.has(member.name)) {
+            return `duplicate member name '${member.name}' (use the name=path form to label members distinctly)`;
+        }
+        seen.add(member.name);
+        if (!path.isAbsolute(member.path)) {
+            return `member path '${member.path}' must be absolute`;
+        }
+    }
+    return null;
+}
+export function memberLabelProblem(label) {
+    return folderStyleNameProblem(label, 'member name');
+}
+const WorksetMemberSchema = z
+    .object({
+    name: z.string(),
+    path: z.string(),
+})
+    .strict();
+const WorksetEntrySchema = z
+    .object({
+    tool: z.string().min(1).optional(),
+    members: z.array(WorksetMemberSchema),
+})
+    .strict();
+const WorksetsStateSchema = z
+    .object({
+    version: z.literal(1),
+    worksets: z.record(z.string(), WorksetEntrySchema),
+})
+    .strict();
+function invalidWorksetsFileError(message, options) {
+    return new StoreError(`Invalid worksets file: ${message}`, 'invalid_workset_file', {
+        target: 'workset.file',
+        fix: `Repair or remove ${getWorksetsFilePath(options)}.`,
+    });
+}
+export function parseWorksetsState(content, options = {}) {
+    let raw;
+    try {
+        raw = parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw invalidWorksetsFileError(message, options);
+    }
+    const result = WorksetsStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw invalidWorksetsFileError(formatZodIssues(result.error), options);
+    }
+    for (const [name, entry] of Object.entries(result.data.worksets)) {
+        if (!isKebabId(name)) {
+            throw invalidWorksetsFileError(`workset name '${name}' ${KEBAB_ID_DESCRIPTION}`, options);
+        }
+        const problem = memberListProblem(entry.members);
+        if (problem !== null) {
+            throw invalidWorksetsFileError(`workset '${name}': ${problem}`, options);
+        }
+    }
+    return result.data;
+}
+export function serializeWorksetsState(state, options = {}) {
+    const result = WorksetsStateSchema.safeParse(state);
+    if (!result.success) {
+        throw invalidWorksetsFileError(formatZodIssues(result.error), options);
+    }
+    // The strict schema already guarantees the entry shape; the sort is
+    // the only real work here.
+    return stringifyYaml({
+        version: 1,
+        worksets: Object.fromEntries(Object.entries(result.data.worksets).sort(([a], [b]) => a.localeCompare(b))),
+    });
+}
+/** Absent file reads as the empty state; a corrupt file throws. */
+export async function readWorksetsState(options = {}) {
+    const filePath = getWorksetsFilePath(options);
+    if (!(await pathIsFile(filePath))) {
+        return { version: 1, worksets: {} };
+    }
+    return parseWorksetsState(await fs.readFile(filePath, 'utf-8'), options);
+}
+const worksetsLockError = makeLockErrorFactory({
+    createSubject: 'the worksets lock file',
+    busyMessage: 'The worksets file is busy.',
+    code: 'workset_file_busy',
+    target: 'workset.file',
+});
+export async function updateWorksetsState(updater, options = {}) {
+    return withWorksetsLock(async (state) => {
+        const next = await updater(state);
+        await writeFileAtomically(getWorksetsFilePath(options), serializeWorksetsState(next, options));
+        return next;
+    }, options);
+}
+/**
+ * Lock-scoped read without a write-back of the saved-views file.
+ * `open` uses this to read the state and regenerate the derived
+ * .code-workspace coherently; the lock is released before any spawn.
+ */
+export async function withWorksetsLock(fn, options = {}) {
+    const lockPath = `${getWorksetsFilePath(options)}.lock`;
+    const lock = await acquireFileLock({
+        lockPath,
+        errorFor: worksetsLockError,
+    });
+    try {
+        return await fn(await readWorksetsState(options));
+    }
+    finally {
+        await releaseFileLock(lock, lockPath);
+    }
+}
+export function worksetNotFoundError(name, state) {
+    const savedNames = Object.keys(state.worksets).sort((a, b) => a.localeCompare(b));
+    return new StoreError(`Workset '${name}' is not saved on this machine.`, 'workset_not_found', {
+        target: 'workset.name',
+        fix: savedNames.length > 0
+            ? `Saved worksets: ${savedNames.join(', ')}. See them with: openspec workset list`
+            : `Create it first: openspec workset create ${name}`,
+    });
+}
+export function withWorkset(state, workset) {
+    if (state.worksets[workset.name] !== undefined) {
+        throw new StoreError(`Workset '${workset.name}' already exists.`, 'workset_exists', {
+            target: 'workset.name',
+            fix: `Choose another name, or remove it first: openspec workset remove ${workset.name}`,
+        });
+    }
+    return {
+        version: 1,
+        worksets: {
+            ...state.worksets,
+            [workset.name]: {
+                ...(workset.tool !== undefined ? { tool: workset.tool } : {}),
+                members: workset.members,
+            },
+        },
+    };
+}
+export function withoutWorkset(state, name) {
+    if (state.worksets[name] === undefined) {
+        throw worksetNotFoundError(name, state);
+    }
+    const remaining = { ...state.worksets };
+    delete remaining[name];
+    return { version: 1, worksets: remaining };
+}
+/**
+ * Removes a saved workset and its derived .code-workspace under one
+ * lock. The derived-file cleanup runs AFTER the durable write (a
+ * failed write must not have already destroyed the artifact); a
+ * never-opened workset has no file - ENOENT is fine.
+ */
+export async function removeWorkset(name, options = {}) {
+    await withWorksetsLock(async (state) => {
+        const next = withoutWorkset(state, name);
+        await writeFileAtomically(getWorksetsFilePath(options), serializeWorksetsState(next, options));
+        await fs.rm(getWorksetCodeWorkspacePath(name, options), { force: true });
+    }, options);
+}
+function toWorkset(name, entry) {
+    return {
+        name,
+        ...(entry.tool !== undefined ? { tool: entry.tool } : {}),
+        members: entry.members,
+    };
+}
+export function listWorksets(state) {
+    return Object.entries(state.worksets)
+        .map(([name, entry]) => toWorkset(name, entry))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getWorkset(state, name) {
+    const entry = state.worksets[name];
+    return entry === undefined ? null : toWorkset(name, entry);
+}
+/**
+ * The generated .code-workspace content: members in saved order with
+ * their saved names, absolute paths, two-space JSON, trailing newline
+ * (the working-set builder's conventions).
+ */
+export function buildWorksetCodeWorkspaceJson(members) {
+    return (JSON.stringify({
+        folders: members.map((member) => ({
+            name: member.name,
+            path: member.path,
+        })),
+    }, null, 2) + '\n');
+}
+//# sourceMappingURL=worksets.js.map

package/dist/core/zod-issues.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+/** One rendering for zod issues across every state/config parser. */
+export declare function formatZodIssues(error: z.ZodError, fallbackLocation?: string): string;
+//# sourceMappingURL=zod-issues.d.ts.map

package/dist/core/zod-issues.js

@@ -0,0 +1,10 @@
+/** One rendering for zod issues across every state/config parser. */
+export function formatZodIssues(error, fallbackLocation = 'root') {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.length > 0 ? issue.path.join('.') : fallbackLocation;
+        return `${location}: ${issue.message}`;
+    })
+        .join('; ');
+}
+//# sourceMappingURL=zod-issues.js.map

package/dist/utils/change-metadata.d.ts

@@ -1,4 +1,5 @@
 import { type ChangeMetadata } from '../core/change-metadata/index.js';
+export declare const METADATA_FILENAME = ".openspec.yaml";
 /**
  * Error thrown when change metadata validation fails.
  */

package/dist/utils/change-metadata.js

@@ -4,7 +4,7 @@ import * as yaml from 'yaml';
 import { ChangeMetadataSchema } from '../core/change-metadata/index.js';
 import { listSchemas } from '../core/artifact-graph/resolver.js';
 import { readProjectConfig } from '../core/project-config.js';
-const METADATA_FILENAME = '.openspec.yaml';
+export const METADATA_FILENAME = '.openspec.yaml';
 /**
  * Error thrown when change metadata validation fails.
  */

package/dist/utils/change-utils.js

@@ -109,8 +109,23 @@ export async function createChange(projectRoot, name, options = {}) {
     if (await FileSystemUtils.directoryExists(changeDir)) {
         throw new Error(`Change '${name}' already exists at ${changeDir}`);
     }
+    // Creating a change may scaffold or complete the root itself (an
+    // implicit root, or a config-only/incomplete clone). Never leave a
+    // half-root behind that doctor immediately calls unhealthy: ensure
+    // specs/ and changes/archive/ exist, and write a config only when
+    // none exists. The config records the PROJECT default schema, never
+    // a one-change --schema override.
+    const openspecDir = path.join(projectRoot, 'openspec');
     // Create the directory (including parent directories if needed)
     await FileSystemUtils.createDirectory(changeDir);
+    await FileSystemUtils.createDirectory(path.join(openspecDir, 'specs'));
+    await FileSystemUtils.createDirectory(path.join(openspecDir, 'changes', 'archive'));
+    const configPath = path.join(openspecDir, 'config.yaml');
+    const configYmlPath = path.join(openspecDir, 'config.yml');
+    if (!(await FileSystemUtils.fileExists(configPath)) &&
+        !(await FileSystemUtils.fileExists(configYmlPath))) {
+        await FileSystemUtils.writeFile(configPath, `schema: ${defaultSchema}\n`);
+    }
     // Write metadata file with schema and creation date
     const today = new Date().toISOString().split('T')[0];
     writeChangeMetadata(changeDir, {

package/dist/utils/file-system.js

@@ -2,6 +2,36 @@ import * as nodeFs from 'fs';
 import path from 'path';
 const fs = nodeFs.promises;
 const { constants: fsConstants } = nodeFs;
+function hasOwnerGroupOrOtherWriteBit(stats) {
+    return (stats.mode & 0o222) !== 0;
+}
+function hasOwnerGroupOrOtherExecuteBit(stats) {
+    return (stats.mode & 0o111) !== 0;
+}
+async function hasWritableModeAndAccess(targetPath) {
+    try {
+        const stats = await fs.stat(targetPath);
+        // POSIX root can often write despite mode bits, but OpenSpec should respect
+        // explicit read-only file/directory modes when deciding whether an install
+        // path is user-writable. This also keeps permission checks deterministic in
+        // root-run CI containers. On Windows, chmod mode bits are not authoritative,
+        // so rely on fs.access below.
+        if (process.platform !== 'win32' && !hasOwnerGroupOrOtherWriteBit(stats)) {
+            return false;
+        }
+        if (process.platform !== 'win32' && stats.isDirectory() && !hasOwnerGroupOrOtherExecuteBit(stats)) {
+            return false;
+        }
+        const accessMode = stats.isDirectory()
+            ? fsConstants.W_OK | fsConstants.X_OK
+            : fsConstants.W_OK;
+        await fs.access(targetPath, accessMode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function isMarkerOnOwnLine(content, markerIndex, markerLength) {
     let leftIndex = markerIndex - 1;
     while (leftIndex >= 0 && content[leftIndex] !== '\n') {
@@ -131,18 +161,13 @@ export class FileSystemUtils {
     static async canWriteFile(filePath) {
         try {
             const stats = await fs.stat(filePath);
-            if (!stats.isFile()) {
-                return true;
+            if (stats.isDirectory()) {
+                return hasWritableModeAndAccess(filePath);
             }
-            // On Windows, stats.mode doesn't reliably indicate write permissions.
-            // Use fs.access with W_OK to check actual write permissions cross-platform.
-            try {
-                await fs.access(filePath, fsConstants.W_OK);
+            if (!stats.isFile()) {
                 return true;
             }
-            catch {
-                return false;
-            }
+            return hasWritableModeAndAccess(filePath);
         }
         catch (error) {
             if (error.code === 'ENOENT') {
@@ -153,14 +178,8 @@ export class FileSystemUtils {
                     // No existing parent directory found (edge case)
                     return false;
                 }
-                // Check if the existing parent directory is writable
-                try {
-                    await fs.access(existingDir, fsConstants.W_OK);
-                    return true;
-                }
-                catch {
-                    return false;
-                }
+                // Check if the existing parent directory is writable.
+                return hasWritableModeAndAccess(existingDir);
             }
             console.debug(`Unable to determine write permissions for ${filePath}: ${error.message}`);
             return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fission-ai/openspec",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "openspec",
@@ -45,15 +45,15 @@
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.27.7",
     "@types/node": "^24.2.0",
-    "@vitest/ui": "^3.2.4",
+    "@vitest/ui": "^3.2.6",
     "eslint": "^9.39.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.50.1",
-    "vitest": "^3.2.4"
+    "typescript-eslint": "^8.62.0",
+    "vitest": "^3.2.6"
   },
   "dependencies": {
-    "@inquirer/core": "^10.2.2",
-    "@inquirer/prompts": "^7.8.0",
+    "@inquirer/core": "^10.3.2",
+    "@inquirer/prompts": "^7.10.1",
     "chalk": "^5.5.0",
     "commander": "^14.0.0",
     "cross-spawn": "7.0.6",

package/dist/commands/context-store.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare function registerContextStoreCommand(program: Command): void;
-//# sourceMappingURL=context-store.d.ts.map