@fission-ai/openspec 1.4.1 → 1.6.0-beta.1

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/dist/utils/task-progress.d.ts

@@ -3,6 +3,15 @@ export interface TaskProgress {
     completed: number;
 }
 export declare function countTasksFromContent(content: string): TaskProgress;
-export declare function getTaskProgressForChange(changesDir: string, changeName: string): Promise<TaskProgress>;
+/**
+ * Computes a change's task progress by resolving its tracked-tasks artifact and
+ * counting checkboxes across every file matched by that artifact's `generates`
+ * glob — the same file-resolution `openspec status` uses to detect the tasks
+ * artifact (`resolveArtifactOutputs`) — so progress is no longer blind to nested
+ * `tasks.md` files (#1202). Falls back to a single top-level `tasks.md` (exactly
+ * as before) when the schema is unresolvable, no tracked-tasks artifact is found,
+ * or the glob matches no file. Never throws.
+ */
+export declare function getTaskProgressForChange(changesDir: string, changeName: string, projectRoot: string): Promise<TaskProgress>;
 export declare function formatTaskStatus(progress: TaskProgress): string;
 //# sourceMappingURL=task-progress.d.ts.map

package/dist/utils/task-progress.js

@@ -1,5 +1,7 @@
 import { promises as fs } from 'fs';
 import path from 'path';
+import { resolveArtifactOutputs, resolveSchema } from '../core/artifact-graph/index.js';
+import { resolveSchemaForChange } from './change-metadata.js';
 const TASK_PATTERN = /^[-*]\s+\[[\sx]\]/i;
 const COMPLETED_TASK_PATTERN = /^[-*]\s+\[x\]/i;
 export function countTasksFromContent(content) {
@@ -16,8 +18,37 @@ export function countTasksFromContent(content) {
     }
     return { total, completed };
 }
-export async function getTaskProgressForChange(changesDir, changeName) {
-    const tasksPath = path.join(changesDir, changeName, 'tasks.md');
+/**
+ * Identifies the change's tracked-tasks artifact: the artifact whose `generates`
+ * equals the schema's `apply.tracks` value, falling back to the artifact with id
+ * `tasks` when no `apply` block declares what it tracks. (`apply.tracks` is a
+ * filename that *selects* the artifact; the glob is that artifact's `generates`.)
+ */
+function findTrackedTasksArtifact(schema) {
+    const tracks = schema.apply?.tracks;
+    if (tracks != null) {
+        return schema.artifacts.find((a) => a.generates === tracks);
+    }
+    return schema.artifacts.find((a) => a.id === 'tasks');
+}
+/**
+ * Resolves the tracked-tasks artifact's output glob for a change, or undefined
+ * when the schema cannot be resolved or no tracked-tasks artifact exists.
+ * `resolveSchema` throws on an unresolvable/misnamed schema; we swallow that so
+ * the caller falls back to a single top-level `tasks.md` and never crashes.
+ */
+function resolveTrackedTasksGlob(changeDir, projectRoot) {
+    try {
+        const schemaName = resolveSchemaForChange(changeDir, undefined, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        return findTrackedTasksArtifact(schema)?.generates;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function countSingleTopLevelTasksFile(changeDir) {
+    const tasksPath = path.join(changeDir, 'tasks.md');
     try {
         const content = await fs.readFile(tasksPath, 'utf-8');
         return countTasksFromContent(content);
@@ -26,6 +57,39 @@ export async function getTaskProgressForChange(changesDir, changeName) {
         return { total: 0, completed: 0 };
     }
 }
+/**
+ * Computes a change's task progress by resolving its tracked-tasks artifact and
+ * counting checkboxes across every file matched by that artifact's `generates`
+ * glob — the same file-resolution `openspec status` uses to detect the tasks
+ * artifact (`resolveArtifactOutputs`) — so progress is no longer blind to nested
+ * `tasks.md` files (#1202). Falls back to a single top-level `tasks.md` (exactly
+ * as before) when the schema is unresolvable, no tracked-tasks artifact is found,
+ * or the glob matches no file. Never throws.
+ */
+export async function getTaskProgressForChange(changesDir, changeName, projectRoot) {
+    const changeDir = path.join(changesDir, changeName);
+    const generates = resolveTrackedTasksGlob(changeDir, projectRoot);
+    if (generates) {
+        const files = resolveArtifactOutputs(changeDir, generates);
+        if (files.length > 0) {
+            let total = 0;
+            let completed = 0;
+            for (const file of files) {
+                try {
+                    const content = await fs.readFile(file, 'utf-8');
+                    const progress = countTasksFromContent(content);
+                    total += progress.total;
+                    completed += progress.completed;
+                }
+                catch {
+                    // Swallow files that vanish between glob and read, as before.
+                }
+            }
+            return { total, completed };
+        }
+    }
+    return countSingleTopLevelTasksFile(changeDir);
+}
 export function formatTaskStatus(progress) {
     if (progress.total === 0)
         return 'No tasks';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fission-ai/openspec",
-  "version": "1.4.1",
+  "version": "1.6.0-beta.1",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "openspec",
@@ -17,6 +17,7 @@
   "license": "MIT",
   "author": "OpenSpec Contributors",
   "type": "module",
+  "packageManager": "pnpm@9.15.9",
   "publishConfig": {
     "access": "public"
   },
@@ -38,6 +39,24 @@
     "!dist/**/__tests__",
     "!dist/**/*.map"
   ],
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "node build.js",
+    "dev": "tsc --watch",
+    "dev:cli": "pnpm build && node bin/openspec.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "test:postinstall": "node scripts/postinstall.js",
+    "prepare": "pnpm run build",
+    "prepublishOnly": "pnpm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "check:pack-version": "node scripts/pack-version-check.mjs",
+    "release": "pnpm run release:ci",
+    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
+    "changeset": "changeset"
+  },
   "engines": {
     "node": ">=20.19.0"
   },
@@ -45,15 +64,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",
@@ -62,21 +81,5 @@
     "posthog-node": "^5.20.0",
     "yaml": "^2.8.2",
     "zod": "^4.0.17"
-  },
-  "scripts": {
-    "lint": "eslint src/",
-    "build": "node build.js",
-    "dev": "tsc --watch",
-    "dev:cli": "pnpm build && node bin/openspec.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "test:postinstall": "node scripts/postinstall.js",
-    "postinstall": "node scripts/postinstall.js",
-    "check:pack-version": "node scripts/pack-version-check.mjs",
-    "release": "pnpm run release:ci",
-    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
-    "changeset": "changeset"
   }
-}
+}

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