@fission-ai/openspec 1.9.0 → 1.11.0

package/dist/core/available-tools.js

@@ -49,6 +49,21 @@ export function getAvailableTools(projectPath) {
         }
     });
     const activeProjectTools = new Set(reconcileSharedSkillTargets(projectPath, available.filter((tool) => tool.skillsDir)).map((tool) => tool.value));
-    return available.filter((tool) => tool.globalSkillsDir || activeProjectTools.has(tool.value));
+    const hasIndependentDetectionPath = (tool) => (tool.detectionPaths ?? []).some((detectionPath) => {
+        // Skill roots still go through managed-content reconciliation below;
+        // their mere existence is not an independent tool signal.
+        if (detectionPath.endsWith('/skills'))
+            return false;
+        try {
+            fs.statSync(path.join(projectPath, detectionPath));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    return available.filter((tool) => tool.globalSkillsDir ||
+        hasIndependentDetectionPath(tool) ||
+        activeProjectTools.has(tool.value));
 }
 //# sourceMappingURL=available-tools.js.map

package/dist/core/command-generation/adapters/antigravity.d.ts

@@ -6,7 +6,7 @@
 import type { ToolCommandAdapter } from '../types.js';
 /**
  * Antigravity adapter for command generation.
- * File path: .agent/workflows/opsx-<id>.md
+ * File path: .agents/workflows/opsx-<id>.md
  * Frontmatter: description
  */
 export declare const antigravityAdapter: ToolCommandAdapter;

package/dist/core/command-generation/adapters/antigravity.js

@@ -7,13 +7,13 @@ import path from 'path';
 import { escapeYamlValue } from '../yaml.js';
 /**
  * Antigravity adapter for command generation.
- * File path: .agent/workflows/opsx-<id>.md
+ * File path: .agents/workflows/opsx-<id>.md
  * Frontmatter: description
  */
 export const antigravityAdapter = {
     toolId: 'antigravity',
     getFilePath(commandId) {
-        return path.join('.agent', 'workflows', `opsx-${commandId}.md`);
+        return path.join('.agents', 'workflows', `opsx-${commandId}.md`);
     },
     formatFile(content) {
         return `---

package/dist/core/command-generation/adapters/opencode.d.ts

@@ -7,7 +7,8 @@ import type { ToolCommandAdapter } from '../types.js';
 /**
  * OpenCode adapter for command generation.
  * File path: .opencode/commands/opsx-<id>.md
- * Frontmatter: description
+ * Frontmatter: description. $ARGUMENTS is injected after the complete input
+ * contract because OpenCode only passes arguments through explicit placeholders.
  */
 export declare const opencodeAdapter: ToolCommandAdapter;
 //# sourceMappingURL=opencode.d.ts.map

package/dist/core/command-generation/adapters/opencode.js

@@ -5,10 +5,21 @@
  */
 import path from 'path';
 import { escapeYamlValue } from '../yaml.js';
+const OPENCODE_INPUT_BLOCK = /^\*\*Input\*\*:[^\r\n]*(?:\r?\n(?!\r?\n)[^\r\n]*)*/m;
+const OPENCODE_NO_INPUT = /^\*\*Input\*\*:\s*None required\b/im;
+const OPENCODE_ARGUMENT_PLACEHOLDER = /\$(?:ARGUMENTS\b|[1-9]\d*\b)/;
+function injectOpenCodeArgs(body) {
+    if (OPENCODE_ARGUMENT_PLACEHOLDER.test(body) || OPENCODE_NO_INPUT.test(body)) {
+        return body;
+    }
+    const eol = body.includes('\r\n') ? '\r\n' : '\n';
+    return body.replace(OPENCODE_INPUT_BLOCK, (input) => `${input}${eol}**Provided arguments**: $ARGUMENTS`);
+}
 /**
  * OpenCode adapter for command generation.
  * File path: .opencode/commands/opsx-<id>.md
- * Frontmatter: description
+ * Frontmatter: description. $ARGUMENTS is injected after the complete input
+ * contract because OpenCode only passes arguments through explicit placeholders.
  */
 export const opencodeAdapter = {
     toolId: 'opencode',
@@ -20,7 +31,7 @@ export const opencodeAdapter = {
 description: ${escapeYamlValue(content.description)}
 ---
 
-${content.body}
+${injectOpenCodeArgs(content.body)}
 `;
     },
 };

package/dist/core/completion-tip.d.ts

@@ -0,0 +1,15 @@
+export declare const COMPLETION_TIP_MESSAGE = "Tip: Run 'openspec completion install' for shell completions";
+export interface CompletionTipOptions {
+    /**
+     * Skip printing without marking the tip as seen, so it still appears on the
+     * user's first later run that can safely carry it. Used for runs nobody would
+     * read the tip from: JSON output, and stderr that is not a terminal.
+     */
+    silent?: boolean;
+}
+/**
+ * Print the completion tip once, the first time the CLI runs.
+ * Never throws — a hint must not break a command.
+ */
+export declare function maybeShowCompletionTip(options?: CompletionTipOptions): Promise<void>;
+//# sourceMappingURL=completion-tip.d.ts.map

package/dist/core/completion-tip.js

@@ -0,0 +1,133 @@
+/**
+ * First-run hint pointing users at opt-in shell completions.
+ *
+ * This hint used to be an npm `postinstall` script. Printing it from the CLI
+ * instead lets the package ship with no install scripts at all, so `npm install`
+ * no longer emits an `allow-scripts` warning. Completions stay opt-in: the tip
+ * only names the command, it never installs anything.
+ *
+ * The tip goes to stderr, never stdout, so it cannot contaminate piped command
+ * output.
+ *
+ * The tip is suppressed when:
+ * - CI is set (any value npm/telemetry would treat as CI)
+ * - OPENSPEC_NO_COMPLETIONS=1
+ * - completions are already installed, or the shell is one the installer would
+ *   reject
+ * - the caller passes `silent` — JSON runs, `openspec completion ...`, and
+ *   non-TTY runs, which are deferred rather than consumed (see `silent`)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getGlobalConfigPath } from './global-config.js';
+import { isCiEnvironment } from '../utils/ci.js';
+import { detectShell } from '../utils/shell-detection.js';
+import { CompletionFactory } from './completions/factory.js';
+export const COMPLETION_TIP_MESSAGE = "Tip: Run 'openspec completion install' for shell completions";
+function isSuppressedByEnv() {
+    // isCiEnvironment, not a CI==='true' string check: providers set CI to "True",
+    // "yes", "on", and the tip should be as quiet in those builds as telemetry is.
+    return isCiEnvironment() || process.env.OPENSPEC_NO_COMPLETIONS === '1';
+}
+/**
+ * Whether the tip is worth showing, once we know it is owed and readable.
+ *
+ * "retire" consumes the tip without printing: the user either already has
+ * completions, or is on a shell `openspec completion install` would refuse.
+ *
+ * Without the installed check the tip tells people to install completions they
+ * installed long ago — including on the run right after `completion install`,
+ * whose own run only defers the tip. An undetected or unsupported shell retires
+ * it too: `completion install` exits 1 for those users, so pointing them at it
+ * is a dead end, and this tip is the only message about completions they would
+ * ever get.
+ *
+ * Not free: detectShell() forks `ps` to read the parent process (except on
+ * Windows), so this costs a spawn plus a stat. It runs only on interactive runs
+ * that still owe the tip, which is normally exactly one — but a config that
+ * cannot be written never records the flag, and then every interactive run pays
+ * it. On any unexpected error we show the tip rather than swallow it.
+ */
+async function decideTip() {
+    try {
+        const { shell } = detectShell();
+        if (!shell) {
+            return 'retire';
+        }
+        return (await CompletionFactory.createInstaller(shell).isInstalled())
+            ? 'retire'
+            : 'show';
+    }
+    catch {
+        return 'show';
+    }
+}
+/**
+ * Read the global config exactly as it sits on disk.
+ *
+ * Deliberately NOT `getGlobalConfig()`: that merges in defaults, and writing the
+ * merged result back would stamp `profile`/`delivery` into a file the user never
+ * set them in. `migrateIfNeeded` treats a raw `profile` as "already migrated",
+ * so that stamp would permanently suppress the one-time profile migration and
+ * cost users their installed workflow skills.
+ *
+ * Returns null when the file exists but cannot be read or parsed — a config we
+ * cannot understand is left strictly alone rather than overwritten.
+ */
+function readRawConfig() {
+    const configPath = getGlobalConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+/**
+ * Record the flag, re-reading the config first and replacing the file by rename.
+ *
+ * Deciding whether to show the tip costs a `ps` spawn and a stat, and a sibling
+ * `openspec` process can write the same file in that window — on a first run
+ * that is exactly when telemetry mints `anonymousId`. Re-reading here keeps the
+ * write down to this one key, and the rename keeps a reader from ever seeing a
+ * half-written config.
+ */
+function markTipSeen() {
+    const configPath = getGlobalConfigPath();
+    const current = readRawConfig() ?? {};
+    const tempPath = `${configPath}.${process.pid}.tmp`;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(tempPath, JSON.stringify({ ...current, completionTipSeen: true }, null, 2) + '\n', 'utf-8');
+    fs.renameSync(tempPath, configPath);
+}
+/**
+ * Print the completion tip once, the first time the CLI runs.
+ * Never throws — a hint must not break a command.
+ */
+export async function maybeShowCompletionTip(options = {}) {
+    if (isSuppressedByEnv()) {
+        return;
+    }
+    try {
+        const raw = readRawConfig();
+        if (raw === null || raw.completionTipSeen === true) {
+            return;
+        }
+        if (options.silent) {
+            return;
+        }
+        const decision = await decideTip();
+        // Record before printing: if the flag cannot be persisted, staying quiet
+        // beats reprinting the tip on every future run.
+        markTipSeen();
+        if (decision === 'show') {
+            console.error(`\n${COMPLETION_TIP_MESSAGE}`);
+        }
+    }
+    catch {
+        // Silent failure - a hint should never break the CLI.
+    }
+}
+//# sourceMappingURL=completion-tip.js.map

package/dist/core/completions/command-registry.js

@@ -12,6 +12,11 @@ export const COMMAND_REGISTRY = [
                 description: 'Configure AI tools non-interactively (e.g., "all", "none", or comma-separated tool IDs)',
                 takesValue: true,
             },
+            {
+                name: 'language',
+                description: 'Write new OpenSpec artifacts in this language',
+                takesValue: true,
+            },
             {
                 name: 'force',
                 description: 'Auto-cleanup legacy files without prompting',
@@ -131,6 +136,10 @@ export const COMMAND_REGISTRY = [
                 name: 'requirements-only',
                 description: 'Alias for --deltas-only (deprecated, change-specific)',
             },
+            {
+                name: 'diff',
+                description: 'Show per-requirement diffs for delta specs (change-specific)',
+            },
             {
                 name: 'requirements',
                 description: 'Show only requirements, exclude scenarios (JSON only, spec-specific)',
@@ -184,6 +193,10 @@ export const COMMAND_REGISTRY = [
                 description: 'Change name to show status for',
                 takesValue: true,
             },
+            {
+                name: 'all',
+                description: 'Show status for all active changes',
+            },
             {
                 name: 'schema',
                 description: 'Schema override',
@@ -280,6 +293,7 @@ export const COMMAND_REGISTRY = [
                         name: 'path',
                         description: 'Directory to use for the store',
                         takesValue: true,
+                        completionType: 'path',
                     },
                     {
                         name: 'init-git',
@@ -372,6 +386,7 @@ export const COMMAND_REGISTRY = [
                 name: 'code-workspace',
                 description: 'Also write a VS Code workspace file for the set',
                 takesValue: true,
+                completionType: 'path',
             },
             {
                 name: 'force',
@@ -402,6 +417,7 @@ export const COMMAND_REGISTRY = [
                         name: 'member',
                         description: 'Member folder as <path> or <name>=<path>; repeatable, first is the primary',
                         takesValue: true,
+                        completionType: 'path',
                     },
                     {
                         name: 'tool',
@@ -483,6 +499,10 @@ export const COMMAND_REGISTRY = [
                         name: 'requirements-only',
                         description: 'Alias for --deltas-only (deprecated)',
                     },
+                    {
+                        name: 'diff',
+                        description: 'Show per-requirement diffs for delta specs',
+                    },
                     COMMON_FLAGS.noInteractive,
                 ],
             },

package/dist/core/completions/factory.d.ts

@@ -24,6 +24,17 @@ export interface CompletionInstaller {
         success: boolean;
         message: string;
     }>;
+    /**
+     * True when a completion script file is present at the install path.
+     *
+     * Deliberately just the script: bash and PowerShell also need a sourcing
+     * line in the user's profile, and `install()` adds that on a best-effort
+     * basis (it is skipped by OPENSPEC_NO_AUTO_CONFIG=1 or an unwritable
+     * profile, printing manual instructions instead). Someone in that state has
+     * already met the installer, so callers that use this to decide whether to
+     * *advertise* completions should not advertise again.
+     */
+    isInstalled(): Promise<boolean>;
 }
 /**
  * Factory for creating completion generators and installers

package/dist/core/completions/generators/fish-generator.d.ts

@@ -24,6 +24,18 @@ export declare class FishGenerator implements CompletionGenerator {
      * Generate positional argument completion
      */
     private generatePositionalCompletion;
+    /**
+     * Generate indexed positional completions.
+     */
+    private generateIndexedPositionalCompletions;
+    /**
+     * Collect the long and short names for flags that consume the next token.
+     */
+    private collectValueFlags;
+    /**
+     * Build a Fish condition that matches command words in their actual slots.
+     */
+    private commandPathCondition;
     /**
      * Escape description text for Fish
      */

package/dist/core/completions/generators/fish-generator.js

@@ -12,30 +12,26 @@ export class FishGenerator {
      * @returns Fish completion script as a string
      */
     generate(commands) {
-        // Build top-level commands using push() for loop clarity
         const topLevelLines = [];
         for (const cmd of commands) {
             topLevelLines.push(`# ${cmd.name} command`);
-            topLevelLines.push(`complete -c openspec -n '__fish_openspec_no_subcommand' -a '${cmd.name}' -d '${this.escapeDescription(cmd.description)}'`);
+            topLevelLines.push(`complete -c openspec -n '__fish_openspec_no_subcommand' -f -a '${cmd.name}' -d '${this.escapeDescription(cmd.description)}'`);
         }
         const topLevelCommands = topLevelLines.join('\n');
-        // Build command-specific completions using push() for loop clarity
         const commandCompletionLines = [];
         for (const cmd of commands) {
             commandCompletionLines.push(...this.generateCommandCompletions(cmd));
             commandCompletionLines.push('');
         }
         const commandCompletions = commandCompletionLines.join('\n');
-        // Static helper functions from template
         const helperFunctions = FISH_STATIC_HELPERS;
-        // Dynamic completion helpers from template
         const dynamicHelpers = FISH_DYNAMIC_HELPERS;
-        // Assemble final script with template literal
         return `# Fish completion script for OpenSpec CLI
 # Auto-generated - do not edit manually
 
 ${helperFunctions}
 ${dynamicHelpers}
+complete -c openspec -l no-color -f -d 'Disable color output'
 ${topLevelCommands}
 
 ${commandCompletions}`;
@@ -45,38 +41,45 @@ ${commandCompletions}`;
      */
     generateCommandCompletions(cmd) {
         const lines = [];
-        // If command has subcommands
         if (cmd.subcommands && cmd.subcommands.length > 0) {
-            // Add subcommand completions
+            const commandCondition = this.commandPathCondition([cmd.name]);
+            const parentValueFlags = this.collectValueFlags(cmd.flags);
+            const noSubcommandCondition = cmd.subcommands
+                .map((subcmd) => `not ${this.commandPathCondition([cmd.name, subcmd.name], parentValueFlags)}`)
+                .join('; and ');
             for (const subcmd of cmd.subcommands) {
-                lines.push(`complete -c openspec -n '__fish_openspec_using_subcommand ${cmd.name}; and not __fish_openspec_using_subcommand ${subcmd.name}' -a '${subcmd.name}' -d '${this.escapeDescription(subcmd.description)}'`);
+                lines.push(`complete -c openspec -n '${commandCondition}; and ${noSubcommandCondition}' -f -a '${subcmd.name}' -d '${this.escapeDescription(subcmd.description)}'`);
             }
             lines.push('');
-            // Add flags for parent command
             for (const flag of cmd.flags) {
-                lines.push(...this.generateFlagCompletion(flag, `__fish_openspec_using_subcommand ${cmd.name}`));
+                lines.push(...this.generateFlagCompletion(flag, commandCondition));
             }
-            // Add completions for each subcommand
             for (const subcmd of cmd.subcommands) {
+                const subcommandCondition = this.commandPathCondition([cmd.name, subcmd.name], parentValueFlags);
                 lines.push(`# ${cmd.name} ${subcmd.name} flags`);
+                lines.push(`complete -c openspec -n '${subcommandCondition}' -f`);
                 for (const flag of subcmd.flags) {
-                    lines.push(...this.generateFlagCompletion(flag, `__fish_openspec_using_subcommand ${cmd.name}; and __fish_openspec_using_subcommand ${subcmd.name}`));
+                    lines.push(...this.generateFlagCompletion(flag, subcommandCondition));
                 }
-                // Add positional completions for subcommand
-                if (subcmd.acceptsPositional) {
-                    lines.push(...this.generatePositionalCompletion(subcmd.positionalType, `__fish_openspec_using_subcommand ${cmd.name}; and __fish_openspec_using_subcommand ${subcmd.name}`));
+                if (subcmd.positionals?.length) {
+                    lines.push(...this.generateIndexedPositionalCompletions(subcmd.positionals, subcommandCondition, this.collectValueFlags(cmd.flags, subcmd.flags), 2));
+                }
+                else if (subcmd.acceptsPositional) {
+                    lines.push(...this.generatePositionalCompletion(subcmd.positionalType, subcommandCondition));
                 }
             }
         }
         else {
-            // Command without subcommands
             lines.push(`# ${cmd.name} flags`);
+            lines.push(`complete -c openspec -n '__fish_openspec_using_command_path ${cmd.name}' -f`);
             for (const flag of cmd.flags) {
-                lines.push(...this.generateFlagCompletion(flag, `__fish_openspec_using_subcommand ${cmd.name}`));
+                lines.push(...this.generateFlagCompletion(flag, `__fish_openspec_using_command_path ${cmd.name}`));
+            }
+            if (cmd.positionals?.length) {
+                lines.push(...this.generateIndexedPositionalCompletions(cmd.positionals, `__fish_openspec_using_command_path ${cmd.name}`, this.collectValueFlags(cmd.flags), 1));
             }
-            // Add positional completions
-            if (cmd.acceptsPositional) {
-                lines.push(...this.generatePositionalCompletion(cmd.positionalType, `__fish_openspec_using_subcommand ${cmd.name}`));
+            else if (cmd.acceptsPositional) {
+                lines.push(...this.generatePositionalCompletion(cmd.positionalType, `__fish_openspec_using_command_path ${cmd.name}`));
             }
         }
         return lines;
@@ -86,36 +89,26 @@ ${commandCompletions}`;
      */
     generateFlagCompletion(flag, condition) {
         const lines = [];
-        const longFlag = `--${flag.name}`;
-        const shortFlag = flag.short ? `-${flag.short}` : undefined;
+        const description = this.escapeDescription(flag.description);
+        const shortFlag = flag.short ? `-s ${flag.short} ` : '';
+        const flagOptions = `${shortFlag}-l ${flag.name}`;
         if (flag.takesValue && flag.values) {
-            // Flag with enum values
             for (const value of flag.values) {
-                if (shortFlag) {
-                    lines.push(`complete -c openspec -n '${condition}' -s ${flag.short} -l ${flag.name} -a '${value}' -d '${this.escapeDescription(flag.description)}'`);
-                }
-                else {
-                    lines.push(`complete -c openspec -n '${condition}' -l ${flag.name} -a '${value}' -d '${this.escapeDescription(flag.description)}'`);
-                }
+                lines.push(`complete -c openspec -n '${condition}' ${flagOptions} -r -f -a '${value}' -d '${description}'`);
             }
         }
         else if (flag.takesValue) {
-            // Flag that takes a value but no specific values defined
-            if (shortFlag) {
-                lines.push(`complete -c openspec -n '${condition}' -s ${flag.short} -l ${flag.name} -r -d '${this.escapeDescription(flag.description)}'`);
-            }
-            else {
-                lines.push(`complete -c openspec -n '${condition}' -l ${flag.name} -r -d '${this.escapeDescription(flag.description)}'`);
+            lines.push(`complete -c openspec -n '${condition}' ${flagOptions} -r -f -d '${description}'`);
+            if (flag.completionType === 'path') {
+                const optionNames = [`--${flag.name}`, ...(flag.short ? [`-${flag.short}`] : [])];
+                lines.push(`complete -c openspec -n '${condition}; and __fish_openspec_completing_option_value ${optionNames.join(' ')}' ${flagOptions} -r -F -d '${description}'`);
+                if (flag.short) {
+                    lines.push(`complete -c openspec -n '${condition}' ${flagOptions} -r -f -a '(__fish_openspec_complete_attached_short_path -${flag.short})' -d '${description}'`);
+                }
             }
         }
         else {
-            // Boolean flag
-            if (shortFlag) {
-                lines.push(`complete -c openspec -n '${condition}' -s ${flag.short} -l ${flag.name} -d '${this.escapeDescription(flag.description)}'`);
-            }
-            else {
-                lines.push(`complete -c openspec -n '${condition}' -l ${flag.name} -d '${this.escapeDescription(flag.description)}'`);
-            }
+            lines.push(`complete -c openspec -n '${condition}' ${flagOptions} -f -d '${description}'`);
         }
         return lines;
     }
@@ -141,20 +134,59 @@ ${commandCompletions}`;
                 lines.push(`complete -c openspec -n '${condition}' -a 'zsh bash fish powershell' -f`);
                 break;
             case 'path':
-                // Fish automatically completes files, no need to specify
+                // -F re-enables filesystem completion: sibling rules in the same
+                // context carry -f, and Fish never restores files without --force-files.
+                lines.push(`complete -c openspec -n '${condition}' -F`);
+                break;
+            default:
+                lines.push(`complete -c openspec -n '${condition}' -f`);
                 break;
         }
         return lines;
     }
+    /**
+     * Generate indexed positional completions.
+     */
+    generateIndexedPositionalCompletions(positionals, condition, valueFlags, depth) {
+        const lines = [];
+        for (const [index, positional] of positionals.entries()) {
+            const indexCondition = `${condition}; and __fish_openspec_positional_index ${index} ${depth}${valueFlags.length ? ` ${valueFlags.join(' ')}` : ''}`;
+            lines.push(...this.generatePositionalCompletion(positional.type, indexCondition));
+        }
+        return lines;
+    }
+    /**
+     * Collect the long and short names for flags that consume the next token.
+     */
+    collectValueFlags(...flagGroups) {
+        const flags = new Set();
+        for (const group of flagGroups) {
+            for (const flag of group) {
+                if (!flag.takesValue) {
+                    continue;
+                }
+                flags.add(`--${flag.name}`);
+                if (flag.short) {
+                    flags.add(`-${flag.short}`);
+                }
+            }
+        }
+        return [...flags];
+    }
+    /**
+     * Build a Fish condition that matches command words in their actual slots.
+     */
+    commandPathCondition(path, valueFlags = []) {
+        const valueFlagArguments = valueFlags.length ? ` -- ${valueFlags.join(' ')}` : '';
+        return `__fish_openspec_using_command_path ${path.join(' ')}${valueFlagArguments}`;
+    }
     /**
      * Escape description text for Fish
      */
     escapeDescription(description) {
         return description
             .replace(/\\/g, '\\\\') // Backslashes first
-            .replace(/'/g, "\\'") // Single quotes
-            .replace(/\$/g, '\\$') // Dollar signs (prevents $())
-            .replace(/`/g, '\\`'); // Backticks
+            .replace(/'/g, "\\'"); // Single quotes
     }
 }
 //# sourceMappingURL=fish-generator.js.map

package/dist/core/completions/installers/bash-installer.d.ts

@@ -22,6 +22,13 @@ export declare class BashInstaller {
      * @returns Installation path
      */
     getInstallationPath(): Promise<string>;
+    /**
+     * Check if a completion script is currently installed.
+     * Mirrors ZshInstaller.isInstalled so callers can ask any installer.
+     *
+     * @returns true if the completion script exists
+     */
+    isInstalled(): Promise<boolean>;
     /**
      * Backup an existing completion file if it exists
      *

package/dist/core/completions/installers/bash-installer.js

@@ -55,6 +55,21 @@ export class BashInstaller {
         // For user installation, use local directory
         return path.join(localCompletionDir, 'openspec');
     }
+    /**
+     * Check if a completion script is currently installed.
+     * Mirrors ZshInstaller.isInstalled so callers can ask any installer.
+     *
+     * @returns true if the completion script exists
+     */
+    async isInstalled() {
+        try {
+            // stat, not access: a directory at the install path is not a script.
+            return (await fs.stat(await this.getInstallationPath())).isFile();
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Backup an existing completion file if it exists
      *

package/dist/core/completions/installers/fish-installer.d.ts

@@ -12,6 +12,13 @@ export declare class FishInstaller {
      * @returns Installation path
      */
     getInstallationPath(): string;
+    /**
+     * Check if a completion script is currently installed.
+     * Mirrors ZshInstaller.isInstalled so callers can ask any installer.
+     *
+     * @returns true if the completion script exists
+     */
+    isInstalled(): Promise<boolean>;
     /**
      * Backup an existing completion file if it exists
      *

package/dist/core/completions/installers/fish-installer.js

@@ -19,6 +19,21 @@ export class FishInstaller {
     getInstallationPath() {
         return path.join(this.homeDir, '.config', 'fish', 'completions', 'openspec.fish');
     }
+    /**
+     * Check if a completion script is currently installed.
+     * Mirrors ZshInstaller.isInstalled so callers can ask any installer.
+     *
+     * @returns true if the completion script exists
+     */
+    async isInstalled() {
+        try {
+            // stat, not access: a directory at the install path is not a script.
+            return (await fs.stat(this.getInstallationPath())).isFile();
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Backup an existing completion file if it exists
      *

package/dist/core/completions/installers/powershell-installer.d.ts

@@ -43,6 +43,13 @@ export declare class PowerShellInstaller {
      * @returns Installation path
      */
     getInstallationPath(): string;
+    /**
+     * Check if a completion script is currently installed.
+     * Mirrors ZshInstaller.isInstalled so callers can ask any installer.
+     *
+     * @returns true if the completion script exists
+     */
+    isInstalled(): Promise<boolean>;
     /**
      * Backup an existing completion file if it exists
      *