@fission-ai/openspec 1.10.0 → 1.12.0

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
 

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

@@ -19,6 +19,10 @@ export interface FlagDefinition {
      * Whether the flag takes an argument value
      */
     takesValue?: boolean;
+    /**
+     * Completion type for the flag value.
+     */
+    completionType?: PositionalType;
     /**
      * Possible values for the flag (for completion suggestions)
      */

package/dist/core/config.js

@@ -19,7 +19,12 @@ export const OPENSPEC_MARKERS = {
 };
 export const AI_TOOLS = [
     { name: 'Amazon Q Developer', value: 'amazon-q', available: true, successLabel: 'Amazon Q Developer', skillsDir: '.amazonq', requiresIdeRestart: true },
-    { name: 'Antigravity', value: 'antigravity', available: true, successLabel: 'Antigravity', skillsDir: '.agent', requiresIdeRestart: true },
+    // Antigravity moved workspace skills and workflows from `.agent` to the
+    // shared `.agents` root in v1.20.5. Detection keys off `.agent` and
+    // `.agents/workflows` rather than the bare `.agents` root: that root is
+    // shared with Codex, Zed, and the vendor-neutral target, so its presence
+    // alone says nothing about Antigravity.
+    { name: 'Antigravity', value: 'antigravity', available: true, successLabel: 'Antigravity', skillsDir: '.agents', legacySkillsDirs: ['.agent'], detectionPaths: ['.agent', '.agents/workflows'], requiresIdeRestart: true },
     { name: 'Auggie (Augment CLI)', value: 'auggie', available: true, successLabel: 'Auggie', skillsDir: '.augment' },
     { name: 'Bob Shell', value: 'bob', available: true, successLabel: 'Bob Shell', skillsDir: '.bob' },
     { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code', skillsDir: '.claude' },
@@ -49,6 +54,7 @@ export const AI_TOOLS = [
     { name: 'Oh My Pi', value: 'oh-my-pi', available: true, successLabel: 'Oh My Pi', skillsDir: '.omp' },
     { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode', skillsDir: '.opencode' },
     { name: 'Pi', value: 'pi', available: true, successLabel: 'Pi', skillsDir: '.pi' },
+    { name: 'SourceCraft Code Assistant', value: 'codeassistant', available: true, successLabel: 'SourceCraft Code Assistant', skillsDir: '.codeassistant' },
     { name: 'Qoder', value: 'qoder', available: true, successLabel: 'Qoder', skillsDir: '.qoder', requiresIdeRestart: true },
     { name: 'Qwen Code', value: 'qwen', available: true, successLabel: 'Qwen Code', skillsDir: '.qwen' },
     { name: 'Rovo Dev CLI', value: 'rovodev', available: true, successLabel: 'Rovo Dev CLI', skillsDir: '.rovodev', detectionPaths: ['.rovodev/skills', '.rovodev'] },

package/dist/core/init.d.ts

@@ -78,6 +78,7 @@ export declare class InitCommand {
     private resolveToolsArg;
     private validateTools;
     private createDirectoryStructure;
+    private writeGitkeepFiles;
     /**
      * Generates skill files and slash commands for each selected tool,
      * honoring the configured delivery mode (skills, commands, or both).

package/dist/core/init.js

@@ -12,6 +12,7 @@ import { createRequire } from 'module';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { classifyOpenSpecDir, MAX_CONTEXT_SIZE, readProjectConfig, storePointerProblem, } from './project-config.js';
 import { findRepoPlanningRootSync } from './planning-home.js';
+import { ANCHORED_OPENSPEC_DIRS, ensureDirectoryAnchor } from './openspec-root.js';
 import { getSkillReferenceTransformer, getTransformerForTool, usesNaturalLanguageSkillReferences } from '../utils/command-references.js';
 import { AI_TOOLS, OPENSPEC_DIR_NAME, resolveToolIdAlias, } from './config.js';
 import { PALETTE } from './styles/palette.js';
@@ -19,11 +20,11 @@ import { isInteractive } from '../utils/interactive.js';
 import { serializeConfig } from './config-prompts.js';
 import { generateCommands, CommandAdapterRegistry, } from './command-generation/index.js';
 import { detectLegacyArtifacts, cleanupLegacyArtifacts, formatCleanupSummary, formatDeferredGlobalPromptSummary, formatDetectionSummary, getLegacyGlobalPromptMatches, omitGlobalLegacyPromptFiles, pickGlobalLegacyPromptFiles, } from './legacy-cleanup.js';
-import { getToolsWithSkillsDir, getToolStates, getSkillTemplates, getCommandContents, generateSkillContent, hasGlobalSkillTarget, resolveToolSkillsDir, toolSupportsSkills, } from './shared/index.js';
+import { getToolsWithSkillsDir, getToolStates, getSkillTemplates, getCommandContents, generateSkillContent, hasGlobalSkillTarget, resolveToolSkillsDir, toolSupportsSkills, formatIdeRestart, } from './shared/index.js';
 import { getGlobalConfig } from './global-config.js';
 import { getProfileWorkflows, ALL_WORKFLOWS } from './profiles.js';
 import { getAvailableTools } from './available-tools.js';
-import { writeSharedSkillTarget } from './shared-skill-target.js';
+import { resolveSharedSkillWriters, sharedSkillRootOwner, writeSharedSkillTarget, } from './shared-skill-target.js';
 import { migrateIfNeeded, migrateLegacyToolDirs, describeLegacyMigration, keptInPlaceNotice, hasMovableContent, scanInstalledWorkflows as scanInstalledWorkflowsShared } from './migration.js';
 import { resolveCommandSurfaceCapability, resolveCommandInvocation, shouldGenerateCommandsForTool, shouldGenerateSkillsForTool, shouldReconcileCommandFilesForTool, shouldRemoveSkillsForTool, } from './command-surface.js';
 import { writeCopilotCloudFiles, readCopilotCloudOptIn, hasExistingManagedCloudFiles, persistCopilotCloudOptIn, removeCopilotCloudFiles, findUnmanagedCloudFiles, listManagedCloudFiles, } from './github-copilot/cloud-agent.js';
@@ -526,34 +527,8 @@ export class InitCommand {
         return deduped;
     }
     validateTools(toolIds, toolStates, projectPath) {
-        const validatedTools = [];
-        const sharedAgentsTargets = ['codex', 'zed', 'agents'];
-        const selectedSharedTargets = sharedAgentsTargets.filter((toolId) => toolIds.includes(toolId));
-        // A Codex-rendered tree already serves Zed. Keep it when Zed is added later
-        // so Codex users do not lose the `$openspec-*` references they require.
-        const preserveConfiguredCodex = selectedSharedTargets.includes('zed') &&
-            toolStates.get('codex')?.configured;
-        const sharedTargetCandidates = preserveConfiguredCodex
-            ? [...new Set([...selectedSharedTargets, 'codex'])]
-            : selectedSharedTargets;
-        const sharedTargetOwner = sharedTargetCandidates.includes('codex')
-            ? 'codex'
-            : selectedSharedTargets.includes('zed')
-                ? 'zed'
-                : selectedSharedTargets[0];
-        const firstSharedIndex = toolIds.findIndex((id) => sharedAgentsTargets.includes(id));
-        const reconciledToolIds = sharedTargetCandidates.length > 1
-            ? toolIds.flatMap((toolId, index) => {
-                if (!sharedAgentsTargets.includes(toolId))
-                    return [toolId];
-                return index === firstSharedIndex && sharedTargetOwner ? [sharedTargetOwner] : [];
-            })
-            : toolIds;
-        if (reconciledToolIds.length !== toolIds.length ||
-            reconciledToolIds.some((toolId, index) => toolId !== toolIds[index])) {
-            console.log(chalk.dim(`Codex, Zed, and agents share .agents/skills; writing one tree for ${sharedTargetOwner}.`));
-        }
-        for (const toolId of reconciledToolIds) {
+        const selectedTools = [];
+        for (const toolId of toolIds) {
             const tool = AI_TOOLS.find((t) => t.value === toolId);
             if (!tool) {
                 const validToolIds = getToolsWithSkillsDir();
@@ -563,6 +538,48 @@ export class InitCommand {
                 const validToolsWithSkills = getToolsWithSkillsDir();
                 throw new Error(`Tool '${toolId}' does not support skill generation.\nTools with skill generation support:\n  ${validToolsWithSkills.join('\n  ')}`);
             }
+            selectedTools.push(tool);
+        }
+        // A selected tool may share its physical skills root with an already
+        // configured owner. Include that owner in the refresh without dropping the
+        // selected tool: it may still have an independent command surface.
+        const generationTools = [...selectedTools];
+        const delivery = getGlobalConfig().delivery ?? 'both';
+        for (const selected of selectedTools) {
+            if (!selected.skillsDir)
+                continue;
+            const selectedOwner = selected.value === 'codex' ||
+                !shouldGenerateSkillsForTool(selected.value, delivery)
+                ? undefined
+                : sharedSkillRootOwner(projectPath, selected.value);
+            for (const candidate of AI_TOOLS) {
+                if (candidate.skillsDir === selected.skillsDir &&
+                    toolStates.get(candidate.value)?.configured &&
+                    candidate.value === selectedOwner &&
+                    !generationTools.includes(candidate)) {
+                    generationTools.push(candidate);
+                }
+            }
+        }
+        const skillWriters = resolveSharedSkillWriters(projectPath, generationTools);
+        const sharedRoots = new Map();
+        for (const tool of generationTools) {
+            if (!tool.skillsDir)
+                continue;
+            const group = sharedRoots.get(tool.skillsDir) ?? [];
+            group.push(tool);
+            sharedRoots.set(tool.skillsDir, group);
+        }
+        for (const [root, group] of sharedRoots) {
+            if (group.length < 2)
+                continue;
+            const owner = group.find((tool) => skillWriters.has(tool.value));
+            console.log(chalk.dim(`${group.map((tool) => tool.name).join(', ')} share ${root}/skills; writing one tree for ${owner?.value}.`));
+        }
+        const validatedTools = [];
+        for (const tool of generationTools) {
+            if (!toolSupportsSkills(tool))
+                continue;
             const preState = toolStates.get(tool.value);
             const skillsPath = resolveToolSkillsDir(projectPath, tool);
             const isGlobalSkillTarget = hasGlobalSkillTarget(tool);
@@ -574,7 +591,7 @@ export class InitCommand {
                 skillsRoot: isGlobalSkillTarget ? skillsPath : projectPath,
                 isGlobalSkillTarget,
                 wasConfigured: preState?.configured ?? false,
-                requiresIdeRestart: tool.requiresIdeRestart,
+                writesSkills: !tool.skillsDir || skillWriters.has(tool.value),
             });
         }
         return validatedTools;
@@ -583,36 +600,37 @@ export class InitCommand {
     // DIRECTORY STRUCTURE
     // ═══════════════════════════════════════════════════════════
     async createDirectoryStructure(openspecPath, extendMode) {
+        const directories = [
+            openspecPath,
+            path.join(openspecPath, 'specs'),
+            path.join(openspecPath, 'changes'),
+            path.join(openspecPath, 'changes', 'archive'),
+        ];
         if (extendMode) {
             // In extend mode, just ensure directories exist without spinner
-            const directories = [
-                openspecPath,
-                path.join(openspecPath, 'specs'),
-                path.join(openspecPath, 'changes'),
-                path.join(openspecPath, 'changes', 'archive'),
-            ];
             for (const dir of directories) {
                 FileSystemUtils.assertProjectArtifactPath(path.dirname(openspecPath), dir);
                 await FileSystemUtils.createDirectory(dir);
             }
+            await this.writeGitkeepFiles(openspecPath);
             return;
         }
         const spinner = this.startSpinner('Creating OpenSpec structure...');
-        const directories = [
-            openspecPath,
-            path.join(openspecPath, 'specs'),
-            path.join(openspecPath, 'changes'),
-            path.join(openspecPath, 'changes', 'archive'),
-        ];
         for (const dir of directories) {
             FileSystemUtils.assertProjectArtifactPath(path.dirname(openspecPath), dir);
             await FileSystemUtils.createDirectory(dir);
         }
+        await this.writeGitkeepFiles(openspecPath);
         spinner.stopAndPersist({
             symbol: PALETTE.white('▌'),
             text: PALETTE.white('OpenSpec structure created'),
         });
     }
+    async writeGitkeepFiles(openspecPath) {
+        for (const relativeDir of ANCHORED_OPENSPEC_DIRS) {
+            await ensureDirectoryAnchor(path.dirname(openspecPath), relativeDir);
+        }
+    }
     // ═══════════════════════════════════════════════════════════
     // SKILL & COMMAND GENERATION
     // ═══════════════════════════════════════════════════════════
@@ -648,7 +666,7 @@ export class InitCommand {
                 const shouldGenerateSkills = shouldGenerateSkillsForTool(tool.value, delivery);
                 const shouldGenerateCommands = shouldGenerateCommandsForTool(tool.value, delivery);
                 // Generate skill files if the selected delivery and tool capability allow skills
-                if (shouldGenerateSkills) {
+                if (shouldGenerateSkills && tool.writesSkills) {
                     // Create skill directories and SKILL.md files
                     for (const { template, dirName } of skillTemplates) {
                         const skillDir = path.join(tool.skillsPath, dirName);
@@ -662,7 +680,9 @@ export class InitCommand {
                     }
                     writeSharedSkillTarget(projectPath, tool.value);
                 }
-                if (shouldRemoveSkillsForTool(tool.value, delivery) && !tool.isGlobalSkillTarget) {
+                if (shouldRemoveSkillsForTool(tool.value, delivery) &&
+                    tool.writesSkills &&
+                    !tool.isGlobalSkillTarget) {
                     removedSkillCount += await this.removeSkillDirs(tool.skillsRoot, tool.skillsPath);
                     // Retain an explicit selection even when this delivery mode produces
                     // no skills, so a divergent legacy sibling cannot reclaim ownership.
@@ -1015,27 +1035,13 @@ export class InitCommand {
         console.log();
         console.log(`Learn more: ${chalk.cyan('https://github.com/Fission-AI/OpenSpec')}`);
         console.log(`Feedback:   ${chalk.cyan('https://github.com/Fission-AI/OpenSpec/issues')}`);
-        // Restart instruction only when at least one IDE/editor-resident tool
-        // actually received a generated surface. Two conditions, coupled to the SAME
-        // tool: (1) its commands/skills are loaded by a long-running editor process
-        // (CLI tools pick the files up immediately, so a restart line would be wrong
-        // for them — see #1067), and (2) a surface was actually generated for it
-        // under the active delivery (an IDE tool that generated nothing has nothing a
-        // restart would pick up, even if a co-configured CLI tool did generate).
-        // Wording follows what the IDE tool itself generated, not the global
-        // aggregate: it must not say "commands" when the IDE tool only got skills
-        // while a co-configured CLI tool got commands. Not "slash commands" either:
-        // Amazon Q's generated files are prompt-library entries invoked with @, so a
-        // restart line promising slash commands would be wrong for it.
-        const restartCommandsGenerated = successfulTools.some((tool) => tool.requiresIdeRestart &&
-            shouldGenerateCommandsForTool(tool.value, activeDelivery));
-        const restartSkillsGenerated = successfulTools.some((tool) => tool.requiresIdeRestart &&
-            shouldGenerateSkillsForTool(tool.value, activeDelivery));
-        if (restartCommandsGenerated || restartSkillsGenerated) {
+        // Restart instruction for successfully configured IDE/editor-resident tools
+        // with a supported surface under the active delivery. The rule and wording live in
+        // formatIdeRestart so `update` says the same thing for the same event.
+        const restartHint = formatIdeRestart(successfulTools.map((tool) => tool.value), activeDelivery);
+        if (restartHint) {
             console.log();
-            console.log(chalk.white(restartCommandsGenerated
-                ? 'Restart your IDE for the new commands to take effect.'
-                : 'Restart your IDE for the new skills to take effect.'));
+            console.log(chalk.white(restartHint));
         }
         console.log();
     }