@fission-ai/openspec 1.10.0 → 1.11.0

package/dist/commands/workflow/status.d.ts

@@ -6,11 +6,13 @@
 import { type ChangeStatus } from '../../core/artifact-graph/index.js';
 export interface StatusOptions {
     change?: string;
+    all?: boolean;
     schema?: string;
     store?: string;
     storePath?: string;
     json?: boolean;
 }
+export declare const BATCH_STATUS_FAILURE_PAYLOAD: Record<string, unknown>;
 export declare function statusCommand(options: StatusOptions): Promise<void>;
 export declare function printStatusText(status: ChangeStatus): void;
 //# sourceMappingURL=status.d.ts.map

package/dist/commands/workflow/status.js

@@ -8,14 +8,26 @@ import chalk from 'chalk';
 import { getChangeDir } from '../../core/planning-home.js';
 import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
 import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
+import { asStatus } from '../shared-output.js';
 import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
-// -----------------------------------------------------------------------------
-// Command Implementation
-// -----------------------------------------------------------------------------
+// The --all --json failure null-shape. Root-selection failures (handled in
+// resolveRootForCommand) and thrown errors (caught by the CLI wrapper) must
+// emit the same shape, so both call sites reference this one constant.
+export const BATCH_STATUS_FAILURE_PAYLOAD = {
+    changes: [],
+    root: null,
+};
 export async function statusCommand(options) {
+    if (options.all && options.change) {
+        throw new Error('The --all and --change options are mutually exclusive.');
+    }
     // The root resolves (and the store banner prints) before the spinner starts
-    // so the two do not fight over stderr.
-    const root = await resolveRootForCommand(options, { json: options.json });
+    // so the two do not fight over stderr. The batch null-shape rides along so
+    // a root-selection failure under --all --json still carries `changes: []`.
+    const root = await resolveRootForCommand(options, {
+        json: options.json,
+        failurePayload: options.all ? BATCH_STATUS_FAILURE_PAYLOAD : undefined,
+    });
     if (!root) {
         return;
     }
@@ -25,9 +37,20 @@ export async function statusCommand(options) {
         const projectRoot = root.path;
         const rootOutput = toRootOutput(root);
         const newChangeHint = withStoreFlag(root, 'openspec new change <name>');
+        // Single definition of "load one change's status" so the batch and
+        // single-change payloads can never drift apart.
+        const loadStatus = (changeName) => formatChangeStatus(loadChangeContext(projectRoot, changeName, options.schema, {
+            changeDir: getChangeDir(planningHome, changeName),
+            planningHome,
+        }), isStoreSelectedRoot(root) ? { storeId: root.storeId } : {});
         // Handle no-changes case gracefully — status is informational,
         // so "no changes" is a valid state, not an error.
         if (!options.change) {
+            // Validate before the no-changes early return so a bogus --schema
+            // fails the same way whether or not any change exists yet.
+            if (options.all && options.schema) {
+                validateSchemaExists(options.schema, projectRoot);
+            }
             const available = await getAvailableChanges(projectRoot, root.changesDir);
             if (available.length === 0) {
                 spinner?.stop();
@@ -38,9 +61,54 @@ export async function statusCommand(options) {
                 console.log(`No active changes. Create one with: ${newChangeHint}`);
                 return;
             }
-            // Changes exist but --change not provided
+            if (options.all) {
+                // readdir order is platform-dependent; sort for deterministic output,
+                // with the same comparator validate --all uses so the two batch
+                // commands order a given change set identically.
+                const entries = [];
+                for (const changeName of available.sort((a, b) => a.localeCompare(b))) {
+                    try {
+                        entries.push(loadStatus(changeName));
+                    }
+                    catch (error) {
+                        // One malformed change must not blank the sweep; carry its
+                        // diagnostic in place and keep going.
+                        entries.push({ changeName, status: [asStatus(error, 'change_error')] });
+                    }
+                }
+                spinner?.stop();
+                const failed = entries.some((entry) => !('artifacts' in entry));
+                if (options.json) {
+                    console.log(JSON.stringify({ changes: entries, root: rootOutput }, null, 2));
+                    if (failed) {
+                        process.exitCode = 1;
+                    }
+                    return;
+                }
+                entries.forEach((entry, index) => {
+                    if (index > 0) {
+                        console.log();
+                    }
+                    if ('artifacts' in entry) {
+                        printStatusText(entry);
+                    }
+                    else {
+                        console.log(chalk.red(`✗ ${entry.changeName}: ${entry.status[0]?.message}`));
+                    }
+                });
+                // A partial load is still a failed command in both output modes;
+                // JSON callers can parse the complete envelope independently of
+                // the process exit code.
+                if (failed) {
+                    process.exitCode = 1;
+                }
+                return;
+            }
+            // Changes exist but neither --change nor --all provided. Name --all
+            // here too: it is the other way to answer this prompt, and a caller
+            // who wants every change should not have to find it in --help.
             spinner?.stop();
-            throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+            throw new Error(`Missing required option --change (or --all for every active change). Available changes:\n  ${available.join('\n  ')}`);
         }
         const changeName = await validateChangeExists(options.change, projectRoot, root.changesDir, { newChangeHint });
         // Validate schema if explicitly provided
@@ -48,11 +116,7 @@ export async function statusCommand(options) {
             validateSchemaExists(options.schema, projectRoot);
         }
         // loadChangeContext will auto-detect schema from metadata if not provided
-        const context = loadChangeContext(projectRoot, changeName, options.schema, {
-            changeDir: getChangeDir(planningHome, changeName),
-            planningHome,
-        });
-        const status = formatChangeStatus(context, isStoreSelectedRoot(root) ? { storeId: root.storeId } : {});
+        const status = loadStatus(changeName);
         spinner?.stop();
         if (options.json) {
             console.log(JSON.stringify({ ...status, root: rootOutput }, null, 2));

package/dist/core/artifact-graph/resolver.js

@@ -53,18 +53,24 @@ export function getProjectSchemasDir(projectRoot) {
  * @param entry - The directory entry from `fs.readdirSync(..., { withFileTypes: true })`
  */
 /**
- * Directories `schema fork` creates transiently while swapping a fork into
- * place: a staging copy (`.fork-staging-<rand>`, created via mkdtemp) and a
- * backup of the previous destination (`<name>.fork-backup-<pid>-<ts>`). Either
- * can briefly coexist with real schemas in the schemas dir, so discovery must
- * never surface them. Real schema names are kebab-case (no dots), so excluding
- * these dot-bearing temp names can never hide a legitimate schema.
+ * Directories `schema fork` and `schema init` create transiently while swapping
+ * a schema into place: a staging copy (`.fork-staging-<rand>` /
+ * `.init-staging-<rand>`, created via mkdtemp) and a backup of the previous
+ * destination (`<name>.fork-backup-<pid>-<ts>` /
+ * `<name>.init-backup-<pid>-<ts>`). Either can briefly coexist with real
+ * schemas in the schemas dir, and a backup outlives the run when its cleanup is
+ * blocked, so discovery must never surface them. Real schema names are
+ * kebab-case (no dots), so excluding these dot-bearing temp names can never
+ * hide a legitimate schema.
  */
-function isOwnedForkTempDir(name) {
-    return name.startsWith('.fork-staging-') || name.includes('.fork-backup-');
+function isOwnedTransientSchemaDir(name) {
+    return (name.startsWith('.fork-staging-') ||
+        name.includes('.fork-backup-') ||
+        name.startsWith('.init-staging-') ||
+        name.includes('.init-backup-'));
 }
 export function isSchemaDir(parentDir, entry) {
-    if (isOwnedForkTempDir(entry.name)) {
+    if (isOwnedTransientSchemaDir(entry.name)) {
         return false;
     }
     if (entry.isDirectory()) {

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/completions/command-registry.js

@@ -136,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)',
@@ -189,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',
@@ -285,6 +293,7 @@ export const COMMAND_REGISTRY = [
                         name: 'path',
                         description: 'Directory to use for the store',
                         takesValue: true,
+                        completionType: 'path',
                     },
                     {
                         name: 'init-git',
@@ -377,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',
@@ -407,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',
@@ -488,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/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/templates/fish-templates.d.ts

@@ -2,6 +2,6 @@
  * Static template strings for Fish completion scripts.
  * These are Fish-specific helper functions that never change.
  */
-export declare const FISH_STATIC_HELPERS = "# Helper function to check if a subcommand is present\nfunction __fish_openspec_using_subcommand\n    set -l cmd (commandline -opc)\n    set -e cmd[1]\n    for i in $argv\n        if contains -- $i $cmd\n            return 0\n        end\n    end\n    return 1\nend\n\nfunction __fish_openspec_no_subcommand\n    set -l cmd (commandline -opc)\n    test (count $cmd) -eq 1\nend";
+export declare const FISH_STATIC_HELPERS = "# Helper function to match the command path at the start of the invocation\nfunction __fish_openspec_using_command_path\n    set -l expected\n    set -l value_flags\n    set -l reading_value_flags 0\n    for argument in $argv\n        if test \"$argument\" = --\n            set reading_value_flags 1\n            continue\n        end\n        if test $reading_value_flags -eq 1\n            set -a value_flags $argument\n        else\n            set -a expected $argument\n        end\n    end\n\n    set -l tokens (commandline -opc)\n    set -e tokens[1]\n    set -l path\n    set -l skip 0\n    for token in $tokens\n        if test $skip -eq 1\n            set skip 0\n            continue\n        end\n        if test \"$token\" = --no-color\n            continue\n        end\n        if contains -- $token $value_flags\n            set skip 1\n            continue\n        end\n        if string match -q -- '-*' $token\n            continue\n        end\n        set -a path $token\n        if test (count $path) -eq (count $expected)\n            break\n        end\n    end\n    test (count $path) -eq (count $expected); or return 1\n    for index in (seq (count $expected))\n        test \"$path[$index]\" = \"$expected[$index]\"; or return 1\n    end\n    return 0\nend\n\nfunction __fish_openspec_no_subcommand\n    set -l tokens (commandline -opc)\n    set -e tokens[1]\n    for token in $tokens\n        if test \"$token\" != --no-color\n            return 1\n        end\n    end\n    return 0\nend\n\nfunction __fish_openspec_completing_option_value\n    set -l current (commandline -ct)\n    for option in $argv\n        if string match -q -- \"$option=*\" \"$current\"\n            return 0\n        end\n    end\n\n    set -l tokens (commandline -opc)\n    test (count $tokens) -gt 0; or return 1\n    contains -- $tokens[-1] $argv\nend\n\nfunction __fish_openspec_complete_attached_short_path\n    set -l option $argv[1]\n    set -l current (commandline -ct)\n    test \"$current\" != \"$option\"; or return 1\n    string match -q -- \"$option*\" \"$current\"; or return 1\n    set -l value (string sub -s (math (string length -- \"$option\") + 1) -- \"$current\")\n    __fish_complete_path \"$value\"\nend\n\nfunction __fish_openspec_positional_index\n    set -l target $argv[1]\n    set -l depth $argv[2]\n    set -l value_flags $argv[3..]\n    set -l tokens (commandline -opc)\n    set -e tokens[1]\n    set -l count 0\n    set -l options 1\n    set -l skip 0\n    for token in $tokens\n        if test $skip -eq 1\n            set skip 0\n            continue\n        end\n        if test $options -eq 1\n            if test \"$token\" = --\n                set options 0\n                continue\n            end\n            if contains -- $token $value_flags\n                set skip 1\n                continue\n            end\n            if string match -q -- '-*' $token\n                continue\n            end\n        end\n        set count (math $count + 1)\n    end\n    test $skip -eq 0; or return 1\n    test $count -eq (math $target + $depth)\nend";
 export declare const FISH_DYNAMIC_HELPERS = "# Dynamic completion helpers\n\nfunction __fish_openspec_changes\n    openspec __complete changes 2>/dev/null | while read -l id desc\n        printf '%s\\t%s\\n' \"$id\" \"$desc\"\n    end\nend\n\nfunction __fish_openspec_specs\n    openspec __complete specs 2>/dev/null | while read -l id desc\n        printf '%s\\t%s\\n' \"$id\" \"$desc\"\n    end\nend\n\nfunction __fish_openspec_items\n    __fish_openspec_changes\n    __fish_openspec_specs\nend\n\nfunction __fish_openspec_schemas\n    openspec __complete schemas 2>/dev/null | while read -l id desc\n        printf '%s\\t%s\\n' \"$id\" \"$desc\"\n    end\nend";
 //# sourceMappingURL=fish-templates.d.ts.map

package/dist/core/completions/templates/fish-templates.js

@@ -2,21 +2,118 @@
  * Static template strings for Fish completion scripts.
  * These are Fish-specific helper functions that never change.
  */
-export const FISH_STATIC_HELPERS = `# Helper function to check if a subcommand is present
-function __fish_openspec_using_subcommand
-    set -l cmd (commandline -opc)
-    set -e cmd[1]
-    for i in $argv
-        if contains -- $i $cmd
-            return 0
+export const FISH_STATIC_HELPERS = `# Helper function to match the command path at the start of the invocation
+function __fish_openspec_using_command_path
+    set -l expected
+    set -l value_flags
+    set -l reading_value_flags 0
+    for argument in $argv
+        if test "$argument" = --
+            set reading_value_flags 1
+            continue
+        end
+        if test $reading_value_flags -eq 1
+            set -a value_flags $argument
+        else
+            set -a expected $argument
         end
     end
-    return 1
+
+    set -l tokens (commandline -opc)
+    set -e tokens[1]
+    set -l path
+    set -l skip 0
+    for token in $tokens
+        if test $skip -eq 1
+            set skip 0
+            continue
+        end
+        if test "$token" = --no-color
+            continue
+        end
+        if contains -- $token $value_flags
+            set skip 1
+            continue
+        end
+        if string match -q -- '-*' $token
+            continue
+        end
+        set -a path $token
+        if test (count $path) -eq (count $expected)
+            break
+        end
+    end
+    test (count $path) -eq (count $expected); or return 1
+    for index in (seq (count $expected))
+        test "$path[$index]" = "$expected[$index]"; or return 1
+    end
+    return 0
 end
 
 function __fish_openspec_no_subcommand
-    set -l cmd (commandline -opc)
-    test (count $cmd) -eq 1
+    set -l tokens (commandline -opc)
+    set -e tokens[1]
+    for token in $tokens
+        if test "$token" != --no-color
+            return 1
+        end
+    end
+    return 0
+end
+
+function __fish_openspec_completing_option_value
+    set -l current (commandline -ct)
+    for option in $argv
+        if string match -q -- "$option=*" "$current"
+            return 0
+        end
+    end
+
+    set -l tokens (commandline -opc)
+    test (count $tokens) -gt 0; or return 1
+    contains -- $tokens[-1] $argv
+end
+
+function __fish_openspec_complete_attached_short_path
+    set -l option $argv[1]
+    set -l current (commandline -ct)
+    test "$current" != "$option"; or return 1
+    string match -q -- "$option*" "$current"; or return 1
+    set -l value (string sub -s (math (string length -- "$option") + 1) -- "$current")
+    __fish_complete_path "$value"
+end
+
+function __fish_openspec_positional_index
+    set -l target $argv[1]
+    set -l depth $argv[2]
+    set -l value_flags $argv[3..]
+    set -l tokens (commandline -opc)
+    set -e tokens[1]
+    set -l count 0
+    set -l options 1
+    set -l skip 0
+    for token in $tokens
+        if test $skip -eq 1
+            set skip 0
+            continue
+        end
+        if test $options -eq 1
+            if test "$token" = --
+                set options 0
+                continue
+            end
+            if contains -- $token $value_flags
+                set skip 1
+                continue
+            end
+            if string match -q -- '-*' $token
+                continue
+            end
+        end
+        set count (math $count + 1)
+    end
+    test $skip -eq 0; or return 1
+    test $count -eq (math $target + $depth)
 end`;
 export const FISH_DYNAMIC_HELPERS = `# Dynamic completion helpers