@fission-ai/openspec 1.7.0 → 1.8.0

package/dist/core/artifact-graph/index.d.ts

@@ -2,7 +2,7 @@ export { ArtifactSchema, SchemaYamlSchema, type Artifact, type SchemaYaml, type
 export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
 export { ArtifactGraph } from './graph.js';
 export { detectCompleted } from './state.js';
-export { artifactOutputExists, isGlobPattern, resolveArtifactOutputs } from './outputs.js';
+export { artifactOutputExists, isGlobPattern, resolveArtifactOutputPath, resolveArtifactOutputs, } from './outputs.js';
 export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, type SchemaInfo, } from './resolver.js';
 export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, type ChangeContext, type LoadChangeContextOptions, type ArtifactInstructions, type DependencyInfo, type ArtifactStatus, type ChangeStatus, type ArtifactPathSummary, } from './instruction-loader.js';
 export type { PlanningHomeSummary, ActionContext, } from '../change-status-policy.js';

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

@@ -6,7 +6,7 @@ export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
 export { ArtifactGraph } from './graph.js';
 // State detection
 export { detectCompleted } from './state.js';
-export { artifactOutputExists, isGlobPattern, resolveArtifactOutputs } from './outputs.js';
+export { artifactOutputExists, isGlobPattern, resolveArtifactOutputPath, resolveArtifactOutputs, } from './outputs.js';
 // Schema resolution
 export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, } from './resolver.js';
 // Instruction loading

package/dist/core/artifact-graph/instruction-loader.d.ts

@@ -144,7 +144,9 @@ export interface ChangeStatus {
     nextSteps: string[];
     /** Machine-readable action constraints for agents */
     actionContext: ActionContext;
-    /** Whether all artifacts are complete */
+    /** Whether all planning artifacts are complete */
+    isPlanningComplete: boolean;
+    /** Compatibility alias for isPlanningComplete */
     isComplete: boolean;
     /** Artifact IDs required before apply phase (from schema's apply.requires) */
     applyRequires: string[];

package/dist/core/artifact-graph/instruction-loader.js

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { getSchemaDir, resolveSchema, listSchemasWithInfo } from './resolver.js';
 import { ArtifactGraph } from './graph.js';
 import { detectCompleted } from './state.js';
-import { resolveArtifactOutputs } from './outputs.js';
+import { resolveArtifactOutputPath, resolveArtifactOutputs } from './outputs.js';
 import { readChangeMetadata, resolveSchemaForChange } from '../../utils/change-metadata.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { buildActionContext, buildNextSteps, summarizePlanningHome, } from '../change-status-policy.js';
@@ -42,7 +42,14 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
     if (!schemaDir) {
         throw new TemplateLoadError(`Schema '${schemaName}' not found`, templatePath);
     }
-    const templatePathOnDisk = path.join(schemaDir, 'templates', templatePath);
+    const templatesDir = path.join(schemaDir, 'templates');
+    const templatePathOnDisk = path.join(templatesDir, templatePath);
+    try {
+        FileSystemUtils.assertPathWithin(templatesDir, templatePathOnDisk);
+    }
+    catch (error) {
+        throw new TemplateLoadError(error instanceof Error ? error.message : String(error), templatePathOnDisk);
+    }
     if (!fs.existsSync(templatePathOnDisk)) {
         throw new TemplateLoadError(`Template not found: ${templatePathOnDisk}`, templatePathOnDisk);
     }
@@ -144,7 +151,9 @@ export function generateInstructions(context, artifactId, projectRoot, options =
     }
     // Extract context and rules as separate fields (not prepended to template)
     const configContext = projectConfig?.context?.trim() || undefined;
-    const rulesForArtifact = projectConfig?.rules?.[artifactId];
+    const rulesForArtifact = projectConfig?.rules && Object.hasOwn(projectConfig.rules, artifactId)
+        ? projectConfig.rules[artifactId]
+        : undefined;
     const configRules = rulesForArtifact && rulesForArtifact.length > 0 ? rulesForArtifact : undefined;
     return {
         changeName: context.changeName,
@@ -153,7 +162,7 @@ export function generateInstructions(context, artifactId, projectRoot, options =
         changeDir: context.changeDir,
         planningHome: summarizePlanningHome(context.planningHome),
         outputPath: artifact.generates,
-        resolvedOutputPath: path.join(context.changeDir, artifact.generates),
+        resolvedOutputPath: resolveArtifactOutputPath(context.changeDir, artifact.generates),
         existingOutputPaths: resolveArtifactOutputs(context.changeDir, artifact.generates),
         description: artifact.description,
         instruction: artifact.instruction,
@@ -216,7 +225,7 @@ export function formatChangeStatus(context, options = {}) {
     const artifactStatuses = artifacts.map(artifact => {
         artifactPaths[artifact.id] = {
             outputPath: artifact.generates,
-            resolvedOutputPath: path.join(context.changeDir, artifact.generates),
+            resolvedOutputPath: resolveArtifactOutputPath(context.changeDir, artifact.generates),
             existingOutputPaths: resolveArtifactOutputs(context.changeDir, artifact.generates),
         };
         if (context.skippedArtifacts?.has(artifact.id)) {
@@ -263,6 +272,7 @@ export function formatChangeStatus(context, options = {}) {
         planningHome: summarizePlanningHome(context.planningHome),
         changeRoot: context.changeDir,
         artifactPaths,
+        isPlanningComplete: isComplete,
         isComplete,
         applyRequires,
         nextSteps: buildNextSteps({

package/dist/core/artifact-graph/outputs.d.ts

@@ -2,6 +2,7 @@
  * Checks if a path contains glob pattern characters.
  */
 export declare function isGlobPattern(pattern: string): boolean;
+export declare function resolveArtifactOutputPath(changeDir: string, generates: string): string;
 /**
  * Resolves an artifact's output path(s) to concrete files that currently exist.
  * Returns absolute file paths. Glob matches are sorted for deterministic output.

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

@@ -8,16 +8,66 @@ import { FileSystemUtils } from '../../utils/file-system.js';
 export function isGlobPattern(pattern) {
     return pattern.includes('*') || pattern.includes('?') || pattern.includes('[');
 }
+export function resolveArtifactOutputPath(changeDir, generates) {
+    const outputPath = path.join(changeDir, generates);
+    FileSystemUtils.assertPathWithin(changeDir, outputPath);
+    return outputPath;
+}
+function assertGlobDirectoryTraversal(changeDir, currentDir, directorySegments, segmentIndex = 0, visited = new Set(), canonicalChangeDir = FileSystemUtils.canonicalizeExistingPath(changeDir), ancestors = new Set()) {
+    if (segmentIndex >= directorySegments.length)
+        return;
+    const canonicalDir = FileSystemUtils.canonicalizeExistingPath(currentDir);
+    FileSystemUtils.assertPathWithin(canonicalChangeDir, canonicalDir);
+    const visitKey = `${canonicalDir}\0${segmentIndex}`;
+    if (ancestors.has(visitKey)) {
+        throw new Error(`Cannot resolve artifact outputs through a linked directory cycle: ${currentDir}`);
+    }
+    if (visited.has(visitKey))
+        return;
+    visited.add(visitKey);
+    ancestors.add(visitKey);
+    try {
+        const segment = directorySegments[segmentIndex];
+        if (segment === '**') {
+            // `**` may consume no directory at all.
+            assertGlobDirectoryTraversal(changeDir, canonicalDir, directorySegments, segmentIndex + 1, visited, canonicalChangeDir, ancestors);
+        }
+        const matches = fg.sync(segment === '**' ? '*' : segment, {
+            cwd: canonicalDir,
+            onlyFiles: false,
+            followSymbolicLinks: false,
+            deep: 1,
+        });
+        for (const match of matches) {
+            const candidate = path.join(canonicalDir, match);
+            try {
+                if (!fs.statSync(candidate).isDirectory())
+                    continue;
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            const canonicalCandidate = FileSystemUtils.canonicalizeExistingPath(candidate);
+            FileSystemUtils.assertPathWithin(canonicalChangeDir, canonicalCandidate);
+            assertGlobDirectoryTraversal(changeDir, canonicalCandidate, directorySegments, segment === '**' ? segmentIndex : segmentIndex + 1, visited, canonicalChangeDir, ancestors);
+        }
+    }
+    finally {
+        ancestors.delete(visitKey);
+    }
+}
 /**
  * Resolves an artifact's output path(s) to concrete files that currently exist.
  * Returns absolute file paths. Glob matches are sorted for deterministic output.
  */
 export function resolveArtifactOutputs(changeDir, generates) {
+    const outputPath = resolveArtifactOutputPath(changeDir, generates);
     if (!isGlobPattern(generates)) {
-        const fullPath = path.join(changeDir, generates);
         try {
-            return fs.statSync(fullPath).isFile()
-                ? [FileSystemUtils.canonicalizeExistingPath(fullPath)]
+            return fs.statSync(outputPath).isFile()
+                ? [FileSystemUtils.canonicalizeExistingPath(outputPath)]
                 : [];
         }
         catch {
@@ -25,9 +75,21 @@ export function resolveArtifactOutputs(changeDir, generates) {
         }
     }
     const normalizedPattern = FileSystemUtils.toPosixPath(generates);
+    assertGlobDirectoryTraversal(changeDir, changeDir, normalizedPattern.split('/').slice(0, -1));
     const matches = fg
-        .sync(normalizedPattern, { cwd: changeDir, onlyFiles: true, absolute: true })
-        .map((match) => FileSystemUtils.canonicalizeExistingPath(path.normalize(match)));
+        .sync(normalizedPattern, {
+        cwd: changeDir,
+        onlyFiles: true,
+        absolute: true,
+        // Preserve existing support for linked artifact directories. Every
+        // concrete match is canonically confined below before it is returned.
+        followSymbolicLinks: true,
+    })
+        .map((match) => {
+        const normalizedMatch = path.normalize(match);
+        FileSystemUtils.assertPathWithin(changeDir, normalizedMatch);
+        return FileSystemUtils.canonicalizeExistingPath(normalizedMatch);
+    });
     return Array.from(new Set(matches)).sort();
 }
 /**

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

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getGlobalDataDir } from '../global-config.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
 import { parseSchema, SchemaValidationError } from './schema.js';
 /**
  * Error thrown when loading a schema fails.
@@ -67,6 +68,25 @@ export function isSchemaDir(parentDir, entry) {
     }
     return false;
 }
+/**
+ * Returns a schema directory only when its schema file stays within that
+ * directory's canonical trust boundary. The directory itself may be a symlink;
+ * external user schema links are an intentionally supported workflow.
+ */
+function getSchemaCandidateDir(schemasDir, name) {
+    const schemaDir = path.join(schemasDir, name);
+    const schemaPath = path.join(schemaDir, 'schema.yaml');
+    if (!fs.existsSync(schemaPath)) {
+        return null;
+    }
+    try {
+        FileSystemUtils.assertPathWithin(schemaDir, schemaPath);
+        return schemaDir;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Resolves a schema name to its directory path.
  *
@@ -83,24 +103,30 @@ export function isSchemaDir(parentDir, entry) {
  * @returns The path to the schema directory, or null if not found
  */
 export function getSchemaDir(name, projectRoot) {
+    if (name.length === 0 ||
+        name === '.' ||
+        name === '..' ||
+        /[\\/]/u.test(name) ||
+        /^[A-Za-z]:/u.test(name) ||
+        path.posix.isAbsolute(name) ||
+        path.win32.isAbsolute(name)) {
+        return null;
+    }
     // 1. Check project-local directory (if projectRoot provided)
     if (projectRoot) {
-        const projectDir = path.join(getProjectSchemasDir(projectRoot), name);
-        const projectSchemaPath = path.join(projectDir, 'schema.yaml');
-        if (fs.existsSync(projectSchemaPath)) {
+        const projectDir = getSchemaCandidateDir(getProjectSchemasDir(projectRoot), name);
+        if (projectDir) {
             return projectDir;
         }
     }
     // 2. Check user override directory
-    const userDir = path.join(getUserSchemasDir(), name);
-    const userSchemaPath = path.join(userDir, 'schema.yaml');
-    if (fs.existsSync(userSchemaPath)) {
+    const userDir = getSchemaCandidateDir(getUserSchemasDir(), name);
+    if (userDir) {
         return userDir;
     }
     // 3. Check package built-in directory
-    const packageDir = path.join(getPackageSchemasDir(), name);
-    const packageSchemaPath = path.join(packageDir, 'schema.yaml');
-    if (fs.existsSync(packageSchemaPath)) {
+    const packageDir = getSchemaCandidateDir(getPackageSchemasDir(), name);
+    if (packageDir) {
         return packageDir;
     }
     return null;

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

@@ -1,10 +1,28 @@
+import * as path from 'node:path';
 import { z } from 'zod';
+function relativePathSchema(fieldName) {
+    return z
+        .string()
+        .min(1, { error: `${fieldName} is required` })
+        .superRefine((value, ctx) => {
+        const segments = value.split(/[\\/]+/u);
+        const isDrivePath = /^[A-Za-z]:/u.test(value);
+        const isAbsolute = path.posix.isAbsolute(value) || path.win32.isAbsolute(value) || isDrivePath;
+        const escapes = segments.includes('..');
+        if (isAbsolute || escapes || value.includes('\0')) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `${fieldName} must be a relative path inside its allowed directory`,
+            });
+        }
+    });
+}
 // Artifact definition schema
 export const ArtifactSchema = z.object({
     id: z.string().min(1, { error: 'Artifact ID is required' }),
-    generates: z.string().min(1, { error: 'generates field is required' }),
+    generates: relativePathSchema('generates field'),
     description: z.string(),
-    template: z.string().min(1, { error: 'template field is required' }),
+    template: relativePathSchema('template field'),
     instruction: z.string().optional(),
     requires: z.array(z.string()).default([]),
 });
@@ -13,7 +31,7 @@ export const ApplyPhaseSchema = z.object({
     // Artifact IDs that must exist before apply is available
     requires: z.array(z.string()).min(1, { error: 'At least one required artifact' }),
     // Path to file with checkboxes for progress (relative to change dir), or null if no tracking
-    tracks: z.string().nullable().optional(),
+    tracks: relativePathSchema('apply.tracks').nullable().optional(),
     // Custom guidance for the apply phase
     instruction: z.string().optional(),
 });

package/dist/core/available-tools.d.ts

@@ -10,8 +10,8 @@ import { type AIToolOption } from './config.js';
  * the tools that are present.
  *
  * For tools with `detectionPaths`, checks those specific paths (files or
- * directories). Otherwise checks for the tool's `skillsDir` directory at
- * the project root. Only tools with a `skillsDir` property are considered.
+ * directories). Otherwise checks the project's `skillsDir`, or managed skill
+ * files in the user's home directory for a global skill target.
  */
 export declare function getAvailableTools(projectPath: string): AIToolOption[];
 //# sourceMappingURL=available-tools.d.ts.map

package/dist/core/available-tools.js

@@ -7,16 +7,25 @@
 import path from 'path';
 import * as fs from 'fs';
 import { AI_TOOLS } from './config.js';
+import { reconcileSharedSkillTargets } from './shared-skill-target.js';
+import { SKILL_NAMES } from './shared/tool-detection.js';
+import { resolveToolSkillsDir, toolSupportsSkills } from './shared/skill-paths.js';
 /**
  * Scans the project path for AI tool configuration directories and returns
  * the tools that are present.
  *
  * For tools with `detectionPaths`, checks those specific paths (files or
- * directories). Otherwise checks for the tool's `skillsDir` directory at
- * the project root. Only tools with a `skillsDir` property are considered.
+ * directories). Otherwise checks the project's `skillsDir`, or managed skill
+ * files in the user's home directory for a global skill target.
  */
 export function getAvailableTools(projectPath) {
-    return AI_TOOLS.filter((tool) => {
+    const available = AI_TOOLS.filter((tool) => {
+        if (!toolSupportsSkills(tool))
+            return false;
+        if (tool.globalSkillsDir) {
+            const skillsDir = resolveToolSkillsDir(projectPath, tool);
+            return SKILL_NAMES.some((skillName) => fs.existsSync(path.join(skillsDir, skillName, 'SKILL.md')));
+        }
         if (!tool.skillsDir)
             return false;
         if (tool.detectionPaths && tool.detectionPaths.length > 0) {
@@ -39,5 +48,7 @@ export function getAvailableTools(projectPath) {
             return false;
         }
     });
+    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));
 }
 //# sourceMappingURL=available-tools.js.map

package/dist/core/change-metadata/schema.d.ts

@@ -15,6 +15,7 @@ export declare const ChangeMetadataSchema: z.ZodObject<{
         id: z.ZodString;
     }, z.core.$strict>>;
     skip_specs: z.ZodOptional<z.ZodBoolean>;
+    retire_capabilities: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ChangeMetadata = z.infer<typeof ChangeMetadataSchema>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/core/change-metadata/schema.js

@@ -32,5 +32,12 @@ export const ChangeMetadataSchema = z.object({
     // complete - that path prefix, not the artifact id, is the contract custom
     // schemas inherit.
     skip_specs: z.boolean().optional(),
+    // Declares that this change may retire a capability: when its REMOVED entries
+    // take the last requirement a capability has, archive deletes that
+    // capability's main spec instead of aborting on a spec it could not write
+    // (#1302). Required because the deletion is not recoverable from the working
+    // tree - only from git - so it is the author's call, not an inference from the
+    // shape of a delta.
+    retire_capabilities: z.boolean().optional(),
 });
 //# sourceMappingURL=schema.js.map

package/dist/core/change-status-policy.js

@@ -23,12 +23,12 @@ export function buildActionContext(input) {
 export function buildNextSteps(input) {
     const readyArtifact = input.artifactStatuses.find((artifact) => artifact.status === 'ready');
     const steps = [];
+    const storeFlag = input.storeId ? ` --store ${input.storeId}` : '';
     if (readyArtifact) {
-        const storeFlag = input.storeId ? ` --store ${input.storeId}` : '';
         steps.push(`Run openspec instructions ${readyArtifact.id} --change "${input.changeName}"${storeFlag} --json before writing that artifact.`);
     }
     else if (input.allArtifactsComplete) {
-        steps.push('All planning artifacts are complete; review tasks before implementation.');
+        steps.push(`All planning artifacts are complete. Run openspec instructions apply --change "${input.changeName}"${storeFlag} --json to inspect implementation progress.`);
     }
     return steps;
 }

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

@@ -26,6 +26,14 @@ export const COMMAND_REGISTRY = [
                 name: 'no-animation',
                 description: 'Show a static welcome screen instead of the animated one',
             },
+            {
+                name: 'copilot-cloud',
+                description: 'Generate GitHub Copilot cloud coding-agent files (opt-in; default: prompt)',
+            },
+            {
+                name: 'no-copilot-cloud',
+                description: 'Skip generating GitHub Copilot cloud coding-agent files',
+            },
         ],
     },
     {

package/dist/core/config-schema.d.ts

@@ -16,6 +16,9 @@ export declare const GlobalConfigSchema: z.ZodObject<{
     }>>>;
     workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
     defaultStore: z.ZodOptional<z.ZodString>;
+    telemetry: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
 /**

package/dist/core/config-schema.js

@@ -24,6 +24,14 @@ export const GlobalConfigSchema = z
         .string()
         .optional()
         .describe('Store id used as fallback root when no explicit --store, local root, or project-level store: pointer resolves'),
+    // passthrough keeps runtime-managed fields (anonymousId, noticeSeen) valid
+    // under CLI validate when users only set telemetry.enabled.
+    telemetry: z
+        .object({
+        enabled: z.boolean().optional(),
+    })
+        .passthrough()
+        .optional(),
 })
     .passthrough();
 /**
@@ -34,7 +42,14 @@ export const DEFAULT_CONFIG = {
     profile: 'core',
     delivery: 'both',
 };
-const KNOWN_TOP_LEVEL_KEYS = new Set([...Object.keys(DEFAULT_CONFIG), 'workflows', 'defaultStore']);
+const KNOWN_TOP_LEVEL_KEYS = new Set([
+    ...Object.keys(DEFAULT_CONFIG),
+    'workflows',
+    'defaultStore',
+    'telemetry',
+]);
+/** Nested keys users may set under `telemetry` via the CLI. */
+const TELEMETRY_SETTABLE_KEYS = new Set(['enabled']);
 /**
  * Key segments that would reach the prototype chain instead of the config object.
  * Never valid as configuration keys, so rejecting them costs nothing.
@@ -73,6 +88,18 @@ export function validateConfigKeyPath(path) {
         }
         return { valid: true };
     }
+    if (rootKey === 'telemetry') {
+        if (rawKeys.length === 1) {
+            return { valid: false, reason: 'Set nested keys under telemetry (e.g. telemetry.enabled)' };
+        }
+        if (rawKeys.length !== 2 || !TELEMETRY_SETTABLE_KEYS.has(rawKeys[1])) {
+            return {
+                valid: false,
+                reason: `Unknown telemetry key "${rawKeys.slice(1).join('.')}" (allowed: enabled)`,
+            };
+        }
+        return { valid: true };
+    }
     if (rawKeys.length > 1) {
         return { valid: false, reason: `"${rootKey}" does not support nested keys` };
     }

package/dist/core/config.d.ts

@@ -1,4 +1,5 @@
 export declare const OPENSPEC_DIR_NAME = "openspec";
+export declare const OPENSPEC_SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-apply-change", "openspec-update-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change", "openspec-onboard", "openspec-propose"];
 export declare const OPENSPEC_MARKERS: {
     start: string;
     end: string;
@@ -12,6 +13,8 @@ export interface AIToolOption {
     available: boolean;
     successLabel?: string;
     skillsDir?: string;
+    legacySkillsDirs?: string[];
+    globalSkillsDir?: string;
     detectionPaths?: string[];
     setupNote?: string;
 }

package/dist/core/config.js

@@ -1,4 +1,18 @@
 export const OPENSPEC_DIR_NAME = 'openspec';
+export const OPENSPEC_SKILL_NAMES = [
+    'openspec-explore',
+    'openspec-new-change',
+    'openspec-continue-change',
+    'openspec-apply-change',
+    'openspec-update-change',
+    'openspec-ff-change',
+    'openspec-sync-specs',
+    'openspec-archive-change',
+    'openspec-bulk-archive-change',
+    'openspec-verify-change',
+    'openspec-onboard',
+    'openspec-propose',
+];
 export const OPENSPEC_MARKERS = {
     start: '<!-- OPENSPEC:START -->',
     end: '<!-- OPENSPEC:END -->'
@@ -11,7 +25,7 @@ export const AI_TOOLS = [
     { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code', skillsDir: '.claude' },
     { name: 'Cline', value: 'cline', available: true, successLabel: 'Cline', skillsDir: '.cline' },
     { name: 'CodeArts', value: 'codeartsagent', available: true, successLabel: 'CodeArts', skillsDir: '.codeartsdoer' },
-    { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex', skillsDir: '.codex' },
+    { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex', skillsDir: '.agents', legacySkillsDirs: ['.codex'], detectionPaths: ['.agents/skills', '.codex/skills'] },
     { name: 'Devin Desktop (formerly Windsurf)', value: 'devin', available: true, successLabel: 'Devin Desktop', skillsDir: '.devin', detectionPaths: ['.devin', '.windsurf'] },
     { name: 'ForgeCode', value: 'forgecode', available: true, successLabel: 'ForgeCode', skillsDir: '.forge' },
     { name: 'CodeBuddy Code (CLI)', value: 'codebuddy', available: true, successLabel: 'CodeBuddy Code', skillsDir: '.codebuddy' },
@@ -29,16 +43,24 @@ export const AI_TOOLS = [
     { name: 'Kimi Code', value: 'kimi', available: true, successLabel: 'Kimi Code', skillsDir: '.kimi-code', detectionPaths: ['.kimi-code', '.kimi'] },
     { name: 'Kiro', value: 'kiro', available: true, successLabel: 'Kiro', skillsDir: '.kiro' },
     { name: 'Lingma', value: 'lingma', available: true, successLabel: 'Lingma', skillsDir: '.lingma' },
+    { name: 'MiniMax Code', value: 'minimax-code', available: true, successLabel: 'MiniMax Code', globalSkillsDir: '.minimax' },
     { name: 'Mistral Vibe', value: 'vibe', available: true, successLabel: 'Mistral Vibe', skillsDir: '.vibe' },
     { 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: 'Qoder', value: 'qoder', available: true, successLabel: 'Qoder', skillsDir: '.qoder' },
     { 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'] },
     { name: 'Zoo Code', value: 'roocode', available: true, successLabel: 'Zoo Code', skillsDir: '.roo' },
     { name: 'Trae', value: 'trae', available: true, successLabel: 'Trae', skillsDir: '.trae' },
     { name: 'ZCode', value: 'zcode', available: true, successLabel: 'ZCode', skillsDir: '.zcode' },
-    { name: 'AGENTS.md (works with Amp, VS Code, …)', value: 'agents', available: false, successLabel: 'your AGENTS.md-compatible assistant' }
+    // Vendor-neutral target for assistants that read the shared `.agents` root.
+    // Detection keys off `.agents/skills` rather than the bare root: frameworks use
+    // `.agents/` for more than skills, so the root alone says nothing about skills.
+    // A project that does keep skills there is a project this target fits, the same
+    // way `.claude/` selects Claude Code — the signal is the user's setup, not
+    // OpenSpec's own files.
+    { name: 'Shared .agents skills', value: 'agents', available: true, successLabel: 'shared .agents skills', skillsDir: '.agents', detectionPaths: ['.agents/skills'] }
 ];
 /**
  * Retired tool ids that still resolve, so a rebrand does not break scripted