@codewalla_india/openspec 1.0.1

package/dist/core/list.js

@@ -0,0 +1,185 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { MarkdownParser } from './parsers/markdown-parser.js';
+/**
+ * Get the most recent modification time of any file in a directory (recursive).
+ * Falls back to the directory's own mtime if no files are found.
+ */
+async function getLastModified(dirPath) {
+    let latest = null;
+    async function walk(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else {
+                const stat = await fs.stat(fullPath);
+                if (latest === null || stat.mtime > latest) {
+                    latest = stat.mtime;
+                }
+            }
+        }
+    }
+    await walk(dirPath);
+    // If no files found, use the directory's own modification time
+    if (latest === null) {
+        const dirStat = await fs.stat(dirPath);
+        return dirStat.mtime;
+    }
+    return latest;
+}
+/**
+ * Format a date as relative time (e.g., "2 hours ago", "3 days ago")
+ */
+function formatRelativeTime(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffDays > 30) {
+        return date.toLocaleDateString();
+    }
+    else if (diffDays > 0) {
+        return `${diffDays}d ago`;
+    }
+    else if (diffHours > 0) {
+        return `${diffHours}h ago`;
+    }
+    else if (diffMins > 0) {
+        return `${diffMins}m ago`;
+    }
+    else {
+        return 'just now';
+    }
+}
+export class ListCommand {
+    async execute(targetPath = '.', mode = 'changes', options = {}) {
+        const { sort = 'recent', json = false, root } = options;
+        if (mode === 'changes') {
+            const changesDir = path.join(targetPath, 'openspec', 'changes');
+            // Check if changes directory exists
+            try {
+                await fs.access(changesDir);
+            }
+            catch {
+                throw new Error("No OpenSpec changes directory found. Run 'openspec init' first.");
+            }
+            // Get all directories in changes (excluding archive)
+            const entries = await fs.readdir(changesDir, { withFileTypes: true });
+            const changeDirs = entries
+                .filter(entry => entry.isDirectory() && entry.name !== 'archive')
+                .map(entry => entry.name);
+            if (changeDirs.length === 0) {
+                if (json) {
+                    console.log(JSON.stringify({ changes: [], ...(root ? { root } : {}) }, null, 2));
+                }
+                else {
+                    console.log('No active changes found.');
+                }
+                return;
+            }
+            // Collect information about each change
+            const changes = [];
+            for (const changeDir of changeDirs) {
+                const progress = await getTaskProgressForChange(changesDir, changeDir);
+                const changePath = path.join(changesDir, changeDir);
+                const lastModified = await getLastModified(changePath);
+                changes.push({
+                    name: changeDir,
+                    completedTasks: progress.completed,
+                    totalTasks: progress.total,
+                    lastModified
+                });
+            }
+            // Sort by preference (default: recent first)
+            if (sort === 'recent') {
+                changes.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+            }
+            else {
+                changes.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            // JSON output for programmatic use
+            if (json) {
+                const jsonOutput = changes.map(c => ({
+                    name: c.name,
+                    completedTasks: c.completedTasks,
+                    totalTasks: c.totalTasks,
+                    lastModified: c.lastModified.toISOString(),
+                    status: c.totalTasks === 0 ? 'no-tasks' : c.completedTasks === c.totalTasks ? 'complete' : 'in-progress'
+                }));
+                console.log(JSON.stringify({ changes: jsonOutput, ...(root ? { root } : {}) }, null, 2));
+                return;
+            }
+            // Display results
+            console.log('Changes:');
+            const padding = '  ';
+            const nameWidth = Math.max(...changes.map(c => c.name.length));
+            for (const change of changes) {
+                const paddedName = change.name.padEnd(nameWidth);
+                const status = formatTaskStatus({ total: change.totalTasks, completed: change.completedTasks });
+                const timeAgo = formatRelativeTime(change.lastModified);
+                console.log(`${padding}${paddedName}     ${status.padEnd(12)}  ${timeAgo}`);
+            }
+            return;
+        }
+        // specs mode
+        const specsDir = path.join(targetPath, 'openspec', 'specs');
+        try {
+            await fs.access(specsDir);
+        }
+        catch {
+            if (json) {
+                console.log(JSON.stringify({ specs: [], ...(root ? { root } : {}) }, null, 2));
+            }
+            else {
+                console.log('No specs found.');
+            }
+            return;
+        }
+        const entries = await fs.readdir(specsDir, { withFileTypes: true });
+        const specDirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+        if (specDirs.length === 0) {
+            if (json) {
+                console.log(JSON.stringify({ specs: [], ...(root ? { root } : {}) }, null, 2));
+            }
+            else {
+                console.log('No specs found.');
+            }
+            return;
+        }
+        const specs = [];
+        for (const id of specDirs) {
+            const specPath = join(specsDir, id, 'spec.md');
+            try {
+                const content = readFileSync(specPath, 'utf-8');
+                const parser = new MarkdownParser(content);
+                const spec = parser.parseSpec(id);
+                specs.push({ id, requirementCount: spec.requirements.length });
+            }
+            catch {
+                // If spec cannot be read or parsed, include with 0 count
+                specs.push({ id, requirementCount: 0 });
+            }
+        }
+        specs.sort((a, b) => a.id.localeCompare(b.id));
+        if (json) {
+            console.log(JSON.stringify({ specs, ...(root ? { root } : {}) }, null, 2));
+            return;
+        }
+        console.log('Specs:');
+        const padding = '  ';
+        const nameWidth = Math.max(...specs.map(s => s.id.length));
+        for (const spec of specs) {
+            const padded = spec.id.padEnd(nameWidth);
+            console.log(`${padding}${padded}     requirements ${spec.requirementCount}`);
+        }
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/core/migration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Migration Utilities
+ *
+ * One-time migration logic for existing projects when profile system is introduced.
+ * Called by both init and update commands before profile resolution.
+ */
+import type { AIToolOption } from './config.js';
+/**
+ * Scans installed workflow files across all detected tools and returns
+ * the union of installed workflow IDs.
+ */
+export declare function scanInstalledWorkflows(projectPath: string, tools: AIToolOption[]): string[];
+/**
+ * Performs one-time migration if the global config does not yet have a profile field.
+ * Called by both init and update before profile resolution.
+ *
+ * - If no profile field exists and workflows are installed: sets profile to 'custom'
+ *   with the detected workflows, preserving the user's existing setup.
+ * - If no profile field exists and no workflows are installed: no-op (defaults apply).
+ * - If profile field already exists: no-op.
+ */
+export declare function migrateIfNeeded(projectPath: string, tools: AIToolOption[]): void;
+//# sourceMappingURL=migration.d.ts.map

package/dist/core/migration.js

@@ -0,0 +1,108 @@
+/**
+ * Migration Utilities
+ *
+ * One-time migration logic for existing projects when profile system is introduced.
+ * Called by both init and update commands before profile resolution.
+ */
+import { getGlobalConfig, getGlobalConfigPath, saveGlobalConfig } from './global-config.js';
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { WORKFLOW_TO_SKILL_DIR } from './profile-sync-drift.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import path from 'path';
+import * as fs from 'fs';
+function scanInstalledWorkflowArtifacts(projectPath, tools) {
+    const installed = new Set();
+    let hasSkills = false;
+    let hasCommands = false;
+    for (const tool of tools) {
+        if (!tool.skillsDir)
+            continue;
+        const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+        for (const workflowId of ALL_WORKFLOWS) {
+            const skillDirName = WORKFLOW_TO_SKILL_DIR[workflowId];
+            const skillFile = path.join(skillsDir, skillDirName, 'SKILL.md');
+            if (fs.existsSync(skillFile)) {
+                installed.add(workflowId);
+                hasSkills = true;
+            }
+        }
+        const adapter = CommandAdapterRegistry.get(tool.value);
+        if (!adapter)
+            continue;
+        for (const workflowId of ALL_WORKFLOWS) {
+            const commandPath = adapter.getFilePath(workflowId);
+            const fullPath = path.isAbsolute(commandPath)
+                ? commandPath
+                : path.join(projectPath, commandPath);
+            if (fs.existsSync(fullPath)) {
+                installed.add(workflowId);
+                hasCommands = true;
+            }
+        }
+    }
+    return {
+        workflows: ALL_WORKFLOWS.filter((workflowId) => installed.has(workflowId)),
+        hasSkills,
+        hasCommands,
+    };
+}
+/**
+ * Scans installed workflow files across all detected tools and returns
+ * the union of installed workflow IDs.
+ */
+export function scanInstalledWorkflows(projectPath, tools) {
+    return scanInstalledWorkflowArtifacts(projectPath, tools).workflows;
+}
+function inferDelivery(artifacts) {
+    if (artifacts.hasSkills && artifacts.hasCommands) {
+        return 'both';
+    }
+    if (artifacts.hasCommands) {
+        return 'commands';
+    }
+    return 'skills';
+}
+/**
+ * Performs one-time migration if the global config does not yet have a profile field.
+ * Called by both init and update before profile resolution.
+ *
+ * - If no profile field exists and workflows are installed: sets profile to 'custom'
+ *   with the detected workflows, preserving the user's existing setup.
+ * - If no profile field exists and no workflows are installed: no-op (defaults apply).
+ * - If profile field already exists: no-op.
+ */
+export function migrateIfNeeded(projectPath, tools) {
+    const config = getGlobalConfig();
+    // Check raw config file for profile field presence
+    const configPath = getGlobalConfigPath();
+    let rawConfig = {};
+    try {
+        if (fs.existsSync(configPath)) {
+            rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+    }
+    catch {
+        return; // Can't read config, skip migration
+    }
+    // If profile is already explicitly set, no migration needed
+    if (rawConfig.profile !== undefined) {
+        return;
+    }
+    // Scan for installed workflows
+    const artifacts = scanInstalledWorkflowArtifacts(projectPath, tools);
+    const installedWorkflows = artifacts.workflows;
+    if (installedWorkflows.length === 0) {
+        // No workflows installed, new user — defaults will apply
+        return;
+    }
+    // Migrate: set profile to custom with detected workflows
+    config.profile = 'custom';
+    config.workflows = installedWorkflows;
+    if (rawConfig.delivery === undefined) {
+        config.delivery = inferDelivery(artifacts);
+    }
+    saveGlobalConfig(config);
+    console.log(`Migrated: custom profile with ${installedWorkflows.length} workflows`);
+    console.log("New in this version: /opsx:propose. Try 'openspec config profile core' for the streamlined experience.");
+}
+//# sourceMappingURL=migration.js.map

package/dist/core/openers.d.ts

@@ -0,0 +1,77 @@
+import type { WorksetMember } from './worksets.js';
+/**
+ * The workset opener table (slice 7.1). Supporting a new tool is
+ * configuration, not code: every tool is an instance of one of exactly
+ * two launch styles - 'workspace-file' (invoke with the generated
+ * .code-workspace) or 'attach-dirs' (pre-args plus one attach flag per
+ * member; no positional, ever - agent sessions open clean). Users add
+ * tools or adjust parameters under the global config file's `openers`
+ * key (the git difftool/mergetool pattern).
+ */
+export type OpenerStyle = 'workspace-file' | 'attach-dirs';
+export interface OpenerDefinition {
+    id: string;
+    label: string;
+    style: OpenerStyle;
+    command: string;
+    /** Pre-args before any attach flags or the workspace-file path. */
+    args: string[];
+    /** attach-dirs only; one flag + path pair per member. */
+    attachFlag: string;
+}
+/**
+ * Temporary kill-switch (2026-06): worksets open only in IDE-style
+ * ('workspace-file') tools while the CLI-agent ('attach-dirs') open flow
+ * is reworked. The agents (Claude Code, codex) launch in a single primary
+ * cwd rather than a true combined multi-root view, which makes "where does
+ * my change land?" ambiguous. Default off; set
+ * OPENSPEC_ENABLE_CLI_AGENT_OPENERS=1 to restore them (internal rollback seam).
+ */
+export declare function isCliAgentOpenersEnabled(): boolean;
+/** Whether a tool can be opened right now (CLI-agent styles are gated). */
+export declare function isOpenerEnabled(opener: OpenerDefinition): boolean;
+export declare const BUILTIN_OPENERS: readonly OpenerDefinition[];
+export declare function mergeOpenerTable(rawOpeners: unknown, configPath: string): OpenerDefinition[];
+export interface OpenerScanOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    /** Stat seam for tests (win32 candidate paths on posix hosts). */
+    isExecutableFile?: (candidatePath: string) => boolean;
+}
+/**
+ * PATH availability scan (ported from the deleted workspace openers
+ * at f858c19^, sharpened for injectability: the path module is keyed
+ * by the injected platform, and a command already carrying a known
+ * executable extension matches as-is).
+ */
+export declare function isOpenerCommandAvailable(command: string, options?: OpenerScanOptions): boolean;
+export interface OpenerChoice {
+    opener: OpenerDefinition;
+    available: boolean;
+    /** `(<command> not found on PATH)` when unavailable. */
+    note: string | null;
+}
+/** Table order preserved, available tools first (stable sort). */
+export declare function listOpenerChoices(table: OpenerDefinition[], options?: OpenerScanOptions): OpenerChoice[];
+export declare function findOpener(table: OpenerDefinition[], id: string): OpenerDefinition | null;
+export interface LaunchCommand {
+    executable: string;
+    args: string[];
+    /** The surviving primary member's path. */
+    cwd: string;
+    label: string;
+    style: OpenerStyle;
+}
+/**
+ * Pure argv builder. workspace-file: pre-args + the generated file's
+ * absolute path (which also defuses the cursor shim's `agent`
+ * first-arg hijack). attach-dirs: pre-args + one attach flag + path
+ * pair per surviving member, the primary included (the locked "one
+ * attach flag per member"); never a trailing positional - both agent
+ * CLIs would read one as a starter prompt, which 7.1 locks out.
+ */
+export declare function buildLaunchCommand(opener: OpenerDefinition, input: {
+    members: WorksetMember[];
+    codeWorkspacePath: string;
+}): LaunchCommand;
+//# sourceMappingURL=openers.d.ts.map

package/dist/core/openers.js

@@ -0,0 +1,251 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { z } from 'zod';
+import { StoreError } from './store/errors.js';
+import { formatZodIssues } from './zod-issues.js';
+const DEFAULT_ATTACH_FLAG = '--add-dir';
+/**
+ * Temporary kill-switch (2026-06): worksets open only in IDE-style
+ * ('workspace-file') tools while the CLI-agent ('attach-dirs') open flow
+ * is reworked. The agents (Claude Code, codex) launch in a single primary
+ * cwd rather than a true combined multi-root view, which makes "where does
+ * my change land?" ambiguous. Default off; set
+ * OPENSPEC_ENABLE_CLI_AGENT_OPENERS=1 to restore them (internal rollback seam).
+ */
+export function isCliAgentOpenersEnabled() {
+    return process.env.OPENSPEC_ENABLE_CLI_AGENT_OPENERS === '1';
+}
+/** Whether a tool can be opened right now (CLI-agent styles are gated). */
+export function isOpenerEnabled(opener) {
+    return isCliAgentOpenersEnabled() || opener.style !== 'attach-dirs';
+}
+export const BUILTIN_OPENERS = [
+    {
+        id: 'code',
+        label: 'VS Code',
+        style: 'workspace-file',
+        command: 'code',
+        args: [],
+        attachFlag: DEFAULT_ATTACH_FLAG,
+    },
+    {
+        id: 'cursor',
+        label: 'Cursor',
+        style: 'workspace-file',
+        command: 'cursor',
+        args: [],
+        attachFlag: DEFAULT_ATTACH_FLAG,
+    },
+    {
+        id: 'claude',
+        label: 'Claude Code',
+        style: 'attach-dirs',
+        command: 'claude',
+        args: [],
+        attachFlag: DEFAULT_ATTACH_FLAG,
+    },
+    {
+        id: 'codex',
+        label: 'codex',
+        style: 'attach-dirs',
+        command: 'codex',
+        args: ['--sandbox', 'workspace-write'],
+        attachFlag: DEFAULT_ATTACH_FLAG,
+    },
+];
+const OPENER_STYLES = ['workspace-file', 'attach-dirs'];
+const OpenerConfigRowSchema = z
+    .object({
+    style: z.enum(OPENER_STYLES).optional(),
+    label: z.string().min(1).optional(),
+    command: z.string().min(1).optional(),
+    args: z.array(z.string()).optional(),
+    attach_flag: z.string().min(1).optional(),
+})
+    .strict();
+const OpenersConfigSchema = z.record(z.string(), OpenerConfigRowSchema);
+function invalidOpenerConfigError(message, configPath) {
+    return new StoreError(`Invalid openers config: ${message}`, 'invalid_opener_config', {
+        target: 'openers.config',
+        fix: `Each entry under "openers" in ${configPath} may set style ('workspace-file' or 'attach-dirs'), label, command, args, and attach_flag; new tools must set style.`,
+    });
+}
+/**
+ * Merges the global config file's raw `openers` value over the
+ * built-in table. A row keyed by a built-in id overrides only the
+ * fields it sets; a new id adds a tool (style required, command and
+ * label default to the id). Malformed rows fail typed - never
+ * silently ignored.
+ */
+function cloneOpener(opener) {
+    return { ...opener, args: [...opener.args] };
+}
+export function mergeOpenerTable(rawOpeners, configPath) {
+    if (rawOpeners === undefined || rawOpeners === null) {
+        return BUILTIN_OPENERS.map(cloneOpener);
+    }
+    const result = OpenersConfigSchema.safeParse(rawOpeners);
+    if (!result.success) {
+        throw invalidOpenerConfigError(formatZodIssues(result.error, 'openers'), configPath);
+    }
+    const table = BUILTIN_OPENERS.map(cloneOpener);
+    for (const [id, row] of Object.entries(result.data)) {
+        const builtinIndex = table.findIndex((opener) => opener.id === id);
+        if (builtinIndex >= 0) {
+            const builtin = table[builtinIndex];
+            table[builtinIndex] = {
+                ...builtin,
+                ...(row.style !== undefined ? { style: row.style } : {}),
+                ...(row.label !== undefined ? { label: row.label } : {}),
+                ...(row.command !== undefined ? { command: row.command } : {}),
+                ...(row.args !== undefined ? { args: row.args } : {}),
+                ...(row.attach_flag !== undefined
+                    ? { attachFlag: row.attach_flag }
+                    : {}),
+            };
+            continue;
+        }
+        if (row.style === undefined) {
+            throw invalidOpenerConfigError(`'${id}' adds a new tool and must set style ('workspace-file' or 'attach-dirs')`, configPath);
+        }
+        table.push({
+            id,
+            label: row.label ?? id,
+            style: row.style,
+            command: row.command ?? id,
+            args: row.args ?? [],
+            attachFlag: row.attach_flag ?? DEFAULT_ATTACH_FLAG,
+        });
+    }
+    return table;
+}
+function getPathValue(env) {
+    return env.PATH ?? env.Path ?? env.path ?? '';
+}
+function getPathExtensions(platform, env) {
+    if (platform !== 'win32') {
+        return [''];
+    }
+    return (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map((extension) => extension.trim())
+        .filter((extension) => extension.length > 0);
+}
+function defaultIsExecutableFile(candidatePath, platform) {
+    try {
+        if (!nodeFs.statSync(candidatePath).isFile()) {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+    if (platform === 'win32') {
+        return true;
+    }
+    try {
+        nodeFs.accessSync(candidatePath, nodeFs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * PATH availability scan (ported from the deleted workspace openers
+ * at f858c19^, sharpened for injectability: the path module is keyed
+ * by the injected platform, and a command already carrying a known
+ * executable extension matches as-is).
+ */
+export function isOpenerCommandAvailable(command, options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? os.platform();
+    const pathModule = platform === 'win32' ? path.win32 : path.posix;
+    const isExecutable = options.isExecutableFile ??
+        ((candidate) => defaultIsExecutableFile(candidate, platform));
+    const extensions = getPathExtensions(platform, env);
+    const lowerCommand = command.toLowerCase();
+    const carriesKnownExtension = extensions.some((extension) => extension.length > 0 && lowerCommand.endsWith(extension.toLowerCase()));
+    // One suffix policy: a command already carrying a known executable
+    // extension matches as-is and never gets a second extension appended
+    // - agreeing with spawn-time resolution.
+    const suffixes = carriesKnownExtension ? [''] : extensions;
+    if (/[\\/]/u.test(command)) {
+        // Direct paths additionally match bare even on win32 (the spawn
+        // call receives the literal path).
+        const directSuffixes = Array.from(new Set(['', ...suffixes]));
+        return directSuffixes.some((suffix) => isExecutable(command + suffix));
+    }
+    for (const directory of getPathValue(env).split(pathModule.delimiter)) {
+        if (directory.length === 0) {
+            continue;
+        }
+        if (suffixes.some((suffix) => isExecutable(pathModule.join(directory, command + suffix)))) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Table order preserved, available tools first (stable sort). */
+export function listOpenerChoices(table, options = {}) {
+    return table
+        .filter((opener) => isOpenerEnabled(opener))
+        .map((opener) => {
+        const available = isOpenerCommandAvailable(opener.command, options);
+        return {
+            opener,
+            available,
+            note: available ? null : `(${opener.command} not found on PATH)`,
+        };
+    })
+        .sort((a, b) => {
+        if (a.available === b.available) {
+            return 0;
+        }
+        return a.available ? -1 : 1;
+    });
+}
+export function findOpener(table, id) {
+    return table.find((opener) => opener.id === id) ?? null;
+}
+/**
+ * Pure argv builder. workspace-file: pre-args + the generated file's
+ * absolute path (which also defuses the cursor shim's `agent`
+ * first-arg hijack). attach-dirs: pre-args + one attach flag + path
+ * pair per surviving member, the primary included (the locked "one
+ * attach flag per member"); never a trailing positional - both agent
+ * CLIs would read one as a starter prompt, which 7.1 locks out.
+ */
+export function buildLaunchCommand(opener, input) {
+    if (input.members.length === 0) {
+        throw new Error('buildLaunchCommand requires at least one member.');
+    }
+    // The no-hijack and no-positional guarantees lean on absolute paths
+    // (the child resolves relative argv against its own cwd) - keep the
+    // invariant local instead of three modules away.
+    if (!path.isAbsolute(input.codeWorkspacePath)) {
+        throw new Error(`buildLaunchCommand requires an absolute workspace-file path (got '${input.codeWorkspacePath}').`);
+    }
+    const cwd = input.members[0].path;
+    if (opener.style === 'workspace-file') {
+        return {
+            executable: opener.command,
+            args: [...opener.args, input.codeWorkspacePath],
+            cwd,
+            label: opener.label,
+            style: opener.style,
+        };
+    }
+    return {
+        executable: opener.command,
+        args: [
+            ...opener.args,
+            ...input.members.flatMap((member) => [opener.attachFlag, member.path]),
+        ],
+        cwd,
+        label: opener.label,
+        style: opener.style,
+    };
+}
+//# sourceMappingURL=openers.js.map

package/dist/core/openspec-root.d.ts

@@ -0,0 +1,45 @@
+import { type StoreDiagnostic } from './store/errors.js';
+export declare const OPENSPEC_ROOT_DIR = "openspec";
+export declare const OPENSPEC_CONFIG_YAML = "openspec/config.yaml";
+export declare const OPENSPEC_CONFIG_YML = "openspec/config.yml";
+export declare const OPENSPEC_SPECS_DIR = "openspec/specs";
+export declare const OPENSPEC_CHANGES_DIR = "openspec/changes";
+export declare const OPENSPEC_ARCHIVE_DIR = "openspec/changes/archive";
+export declare const DEFAULT_OPENSPEC_SCHEMA = "spec-driven";
+export declare const DIRECTORY_ANCHOR_FILE_NAME = ".gitkeep";
+export declare const ANCHORED_OPENSPEC_DIRS: readonly ["openspec/specs", "openspec/changes/archive"];
+export interface CreatedPathLedgerEntry {
+    relativePath: string;
+    absolutePath: string;
+    kind: 'directory' | 'file';
+}
+export interface OpenSpecRootInspection {
+    present: boolean | null;
+    config: {
+        present: boolean | null;
+        path?: string;
+    };
+    specs: {
+        present: boolean | null;
+    };
+    changes: {
+        present: boolean | null;
+    };
+    archive: {
+        present: boolean | null;
+    };
+    healthy: boolean;
+    diagnostics: StoreDiagnostic[];
+}
+export interface EnsureOpenSpecRootResult {
+    inspection: OpenSpecRootInspection;
+    createdArtifacts: string[];
+    createdPaths: CreatedPathLedgerEntry[];
+}
+export declare function inspectOpenSpecRoot(storeRoot: string): Promise<OpenSpecRootInspection>;
+export interface EnsureOpenSpecRootOptions {
+    anchorEmptyDirectories?: boolean;
+}
+export declare function ensureOpenSpecRoot(storeRoot: string, options?: EnsureOpenSpecRootOptions): Promise<EnsureOpenSpecRootResult>;
+export declare function rollbackCreatedPaths(entries: CreatedPathLedgerEntry[]): Promise<void>;
+//# sourceMappingURL=openspec-root.d.ts.map