@fission-ai/openspec 1.7.0 → 1.9.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.d.ts

@@ -23,18 +23,6 @@ export declare function getUserSchemasDir(): string;
  * @returns The path to the project's schemas directory
  */
 export declare function getProjectSchemasDir(projectRoot: string): string;
-/**
- * Determines whether a directory entry represents a schema directory candidate.
- *
- * Returns true for real directories and for symlinks whose target is a
- * directory. `fs.Dirent.isDirectory()` reports the raw entry type, so a symlink
- * (even one pointing at a directory) has `isDirectory() === false`; we
- * dereference such entries via `fs.statSync` to admit symlinked schema dirs
- * while still rejecting symlinks-to-files and broken/dangling symlinks.
- *
- * @param parentDir - The directory containing the entry
- * @param entry - The directory entry from `fs.readdirSync(..., { withFileTypes: true })`
- */
 export declare function isSchemaDir(parentDir: string, entry: fs.Dirent): boolean;
 /**
  * Resolves a schema name to its directory path.

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.
@@ -51,7 +52,21 @@ export function getProjectSchemasDir(projectRoot) {
  * @param parentDir - The directory containing the entry
  * @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.
+ */
+function isOwnedForkTempDir(name) {
+    return name.startsWith('.fork-staging-') || name.includes('.fork-backup-');
+}
 export function isSchemaDir(parentDir, entry) {
+    if (isOwnedForkTempDir(entry.name)) {
+        return false;
+    }
     if (entry.isDirectory()) {
         return true;
     }
@@ -67,6 +82,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 +117,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/command-generation/adapters/command-code.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Command Code Command Adapter
+ *
+ * Command Code reads custom slash commands from `.commandcode/commands/`. The
+ * command name is the markdown filename without its `.md` extension, so
+ * `opsx-<id>.md` registers `/opsx-<id>` — the same flat naming Cursor and
+ * OpenCode use. See https://commandcode.ai/docs/reference/slash-commands.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Command Code adapter for command generation.
+ * File path: .commandcode/commands/opsx-<id>.md
+ * Format: plain Markdown with $ARGUMENTS injected after the input contract
+ *
+ * Command Code executes the full trimmed file body and substitutes invocation
+ * arguments only where the body includes one of its argument placeholders.
+ */
+export declare const commandCodeAdapter: ToolCommandAdapter;
+//# sourceMappingURL=command-code.d.ts.map

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

@@ -0,0 +1,34 @@
+/**
+ * Command Code Command Adapter
+ *
+ * Command Code reads custom slash commands from `.commandcode/commands/`. The
+ * command name is the markdown filename without its `.md` extension, so
+ * `opsx-<id>.md` registers `/opsx-<id>` — the same flat naming Cursor and
+ * OpenCode use. See https://commandcode.ai/docs/reference/slash-commands.
+ */
+import path from 'path';
+const COMMAND_CODE_INPUT_HEADING = /^\*\*Input\*\*:[^\n]*$/m;
+function injectCommandCodeArgs(body) {
+    if (/^\*\*Provided arguments\*\*:\s*(?:\$(?:ARGUMENTS|@)|\$\{(?:ARGUMENTS|@)\})\s*$/m.test(body)) {
+        return body;
+    }
+    return body.replace(COMMAND_CODE_INPUT_HEADING, (heading) => `${heading}\n**Provided arguments**: $ARGUMENTS`);
+}
+/**
+ * Command Code adapter for command generation.
+ * File path: .commandcode/commands/opsx-<id>.md
+ * Format: plain Markdown with $ARGUMENTS injected after the input contract
+ *
+ * Command Code executes the full trimmed file body and substitutes invocation
+ * arguments only where the body includes one of its argument placeholders.
+ */
+export const commandCodeAdapter = {
+    toolId: 'command-code',
+    getFilePath(commandId) {
+        return path.join('.commandcode', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `${injectCommandCodeArgs(content.body)}\n`;
+    },
+};
+//# sourceMappingURL=command-code.js.map

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

@@ -9,6 +9,7 @@ export { auggieAdapter } from './auggie.js';
 export { bobAdapter } from './bob.js';
 export { claudeAdapter } from './claude.js';
 export { clineAdapter } from './cline.js';
+export { commandCodeAdapter } from './command-code.js';
 export { codebuddyAdapter } from './codebuddy.js';
 export { continueAdapter } from './continue.js';
 export { costrictAdapter } from './costrict.js';

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

@@ -9,6 +9,7 @@ export { auggieAdapter } from './auggie.js';
 export { bobAdapter } from './bob.js';
 export { claudeAdapter } from './claude.js';
 export { clineAdapter } from './cline.js';
+export { commandCodeAdapter } from './command-code.js';
 export { codebuddyAdapter } from './codebuddy.js';
 export { continueAdapter } from './continue.js';
 export { costrictAdapter } from './costrict.js';

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

@@ -10,6 +10,7 @@ import { auggieAdapter } from './adapters/auggie.js';
 import { bobAdapter } from './adapters/bob.js';
 import { claudeAdapter } from './adapters/claude.js';
 import { clineAdapter } from './adapters/cline.js';
+import { commandCodeAdapter } from './adapters/command-code.js';
 import { devinAdapter } from './adapters/devin.js';
 import { codebuddyAdapter } from './adapters/codebuddy.js';
 import { continueAdapter } from './adapters/continue.js';
@@ -45,6 +46,7 @@ export class CommandAdapterRegistry {
         CommandAdapterRegistry.register(bobAdapter);
         CommandAdapterRegistry.register(claudeAdapter);
         CommandAdapterRegistry.register(clineAdapter);
+        CommandAdapterRegistry.register(commandCodeAdapter);
         CommandAdapterRegistry.register(devinAdapter);
         CommandAdapterRegistry.register(codebuddyAdapter);
         CommandAdapterRegistry.register(continueAdapter);

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',
+            },
         ],
     },
     {
@@ -89,6 +97,10 @@ export const COMMAND_REGISTRY = [
                 name: 'specs',
                 description: 'Validate all specs',
             },
+            {
+                name: 'archived',
+                description: 'Validate that archived changes have all tasks completed (for pre-commit linting)',
+            },
             COMMON_FLAGS.type,
             COMMON_FLAGS.strict,
             COMMON_FLAGS.jsonValidation,
@@ -218,6 +230,7 @@ export const COMMAND_REGISTRY = [
         description: 'List available workflow schemas with descriptions',
         flags: [
             COMMON_FLAGS.json,
+            COMMON_FLAGS.store,
         ],
     },
     {

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,8 +13,11 @@ export interface AIToolOption {
     available: boolean;
     successLabel?: string;
     skillsDir?: string;
+    legacySkillsDirs?: string[];
+    globalSkillsDir?: string;
     detectionPaths?: string[];
     setupNote?: string;
+    requiresIdeRestart?: boolean;
 }
 export declare const AI_TOOLS: AIToolOption[];
 /**