@fission-ai/openspec 1.8.0 → 1.10.0

package/dist/commands/validate.js

@@ -7,15 +7,33 @@ import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
 import { getSpecIds } from '../utils/item-discovery.js';
 import { getAvailableChanges } from './workflow/shared.js';
 import { nearestMatches } from '../utils/match.js';
+import { promises as fs } from 'fs';
+import { getTaskProgressDetailForChange } from '../utils/task-progress.js';
+import { FileSystemUtils } from '../utils/file-system.js';
 export class ValidateCommand {
     async execute(itemName, options = {}) {
-        const root = await resolveRootForCommand(options, { json: options.json });
+        const bulk = options.all || options.changes || options.specs;
+        const root = await resolveRootForCommand(options, {
+            json: options.json,
+            ...(bulk ? { allowImplicitRoot: false } : {}),
+        });
         if (!root) {
             return;
         }
         const interactive = isInteractive(options);
+        // Archived-task linting is its own scope: it checks task completion of
+        // already-archived changes, not delta specs (whose operations are already
+        // applied). Handled before the other bulk flags so `--archived` is explicit
+        // and never alters an existing invocation's behavior (#205).
+        if (options.archived) {
+            await this.runArchivedTaskValidation(root, {
+                json: !!options.json,
+                noInteractive: resolveNoInteractive(options),
+            });
+            return;
+        }
         // Handle bulk flags first
-        if (options.all || options.changes || options.specs) {
+        if (bulk) {
             await this.runBulkValidation(root, {
                 changes: !!options.all || !!options.changes,
                 specs: !!options.all || !!options.specs,
@@ -145,7 +163,10 @@ export class ValidateCommand {
         if (type === 'change') {
             const changeDir = path.join(root.changesDir, id);
             const start = Date.now();
-            const report = await validator.validateChangeDeltaSpecs(changeDir, { mainSpecsDir: root.specsDir });
+            const report = await validator.validateChangeDeltaSpecs(changeDir, {
+                mainSpecsDir: root.specsDir,
+                projectRoot: root.path,
+            });
             const durationMs = Date.now() - start;
             this.printReport('change', id, report, durationMs, opts.json, root);
             // Non-zero exit if invalid (keeps enriched output test semantics)
@@ -222,7 +243,10 @@ export class ValidateCommand {
             queue.push(async () => {
                 const start = Date.now();
                 const changeDir = path.join(root.changesDir, id);
-                const report = await validator.validateChangeDeltaSpecs(changeDir, { mainSpecsDir: root.specsDir });
+                const report = await validator.validateChangeDeltaSpecs(changeDir, {
+                    mainSpecsDir: root.specsDir,
+                    projectRoot: root.path,
+                });
                 const durationMs = Date.now() - start;
                 return { id, type: 'change', valid: report.valid, issues: report.issues, durationMs };
             });
@@ -322,6 +346,126 @@ export class ValidateCommand {
         }
         process.exitCode = failed > 0 ? 1 : 0;
     }
+    /**
+     * Lists archived change ids from the resolved root's archive directory,
+     * mirroring `getArchivedChangeIds` but store-aware (uses `root.archiveDir`
+     * rather than a cwd-relative path). Directories only, hidden entries skipped.
+     *
+     * Only a missing archive directory (ENOENT) is an empty list; a permission
+     * error, an I/O error, or an `archive` path that is a file (ENOTDIR) is a real
+     * failure and must not read as "no archived changes" — that would let a
+     * pre-commit lint pass without inspecting anything (#205).
+     */
+    async listArchivedChangeIds(root) {
+        try {
+            const entries = await fs.readdir(root.archiveDir, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+                .map((entry) => entry.name)
+                .sort();
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    /**
+     * Validates that every archived change has all of its tasks completed.
+     *
+     * An archived change is expected to be finished; an archived change with
+     * unchecked tasks is a real integrity problem the normal validate flow never
+     * surfaces, because active-change discovery excludes the archive directory
+     * (#205). Reuses the same task-progress counting `status`, `list`, and
+     * `archive` rely on, so what counts as a task never forks. Changes with no
+     * tasks pass (nothing to complete).
+     */
+    async runArchivedTaskValidation(root, opts) {
+        // List first (may throw on a real archive-read failure), then start the
+        // spinner so a thrown error never leaves a spinner spinning.
+        const ids = await this.listArchivedChangeIds(root);
+        const spinner = !opts.json && !opts.noInteractive ? ora('Validating archived changes...').start() : undefined;
+        // The archive is append-only and can hold thousands of changes; a single
+        // run resolves them all under one constant projectRoot (root.path), so
+        // memoize the schema→glob lookup to avoid re-parsing the same schema.yaml
+        // once per change. The loop is intentionally sequential: the per-change work
+        // is dominated by synchronous schema/config resolution, which a promise pool
+        // cannot overlap on Node's single thread — a pool would add complexity for
+        // no real gain here.
+        const schemaGlobCache = new Map();
+        const results = [];
+        let passed = 0;
+        let failed = 0;
+        for (const id of ids) {
+            const start = Date.now();
+            const issues = [];
+            try {
+                // The explicit root.path override is load-bearing: an archived change
+                // lives one directory deeper (changes/archive/<id>), so the default
+                // "../../.." projectRoot derivation would be wrong without it.
+                const progress = await getTaskProgressDetailForChange(root.archiveDir, id, root.path, schemaGlobCache);
+                // A tasks file that exists but cannot be read must fail loudly, not be
+                // silently counted as "no tasks" and pass. Report one issue per file,
+                // pathed like every other validate issue (POSIX, root-relative).
+                for (const file of progress.unreadable) {
+                    issues.push({
+                        level: 'ERROR',
+                        path: FileSystemUtils.toPosixPath(path.relative(root.path, file)),
+                        message: 'could not read task file',
+                    });
+                }
+                const incomplete = Math.max(progress.total - progress.completed, 0);
+                if (incomplete > 0) {
+                    issues.push({
+                        level: 'ERROR',
+                        path: 'tasks.md',
+                        message: `${incomplete} incomplete task${incomplete === 1 ? '' : 's'} (${progress.completed}/${progress.total} completed)`,
+                    });
+                }
+            }
+            catch (error) {
+                issues.push({ level: 'ERROR', path: 'tasks.md', message: error?.message || 'Unknown error' });
+            }
+            const valid = issues.length === 0;
+            if (valid)
+                passed++;
+            else
+                failed++;
+            results.push({ id, type: 'change', valid, issues, durationMs: Date.now() - start });
+        }
+        spinner?.stop();
+        const summary = {
+            totals: { items: results.length, passed, failed },
+            byType: { change: summarizeType(results, 'change') },
+        };
+        if (opts.json) {
+            const out = { items: results, summary, version: '1.0', root: toRootOutput(root) };
+            console.log(JSON.stringify(out, null, 2));
+            process.exitCode = failed > 0 ? 1 : 0;
+            return;
+        }
+        if (results.length === 0) {
+            console.log('No archived changes found.');
+            process.exitCode = 0;
+            return;
+        }
+        // Use the same `<type>/<id>` prefix bulk validation prints, so the plain
+        // output maps to the JSON `type` ('change') and stays greppable the same way.
+        for (const res of results) {
+            if (res.valid) {
+                console.log(`✓ change/${res.id}`);
+            }
+            else {
+                console.error(`✗ change/${res.id}`);
+                for (const issue of res.issues) {
+                    const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
+                    console.error(`  ${prefix} ${issue.message}`);
+                }
+            }
+        }
+        console.log(`Totals: ${summary.totals.passed} passed, ${summary.totals.failed} failed (${summary.totals.items} items)`);
+        process.exitCode = failed > 0 ? 1 : 0;
+    }
 }
 function summarizeType(results, type) {
     const filtered = results.filter(r => r.type === type);

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

@@ -5,6 +5,8 @@
  */
 export interface SchemasOptions {
     json?: boolean;
+    store?: string;
+    storePath?: string;
 }
 export declare function schemasCommand(options: SchemasOptions): Promise<void>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/commands/workflow/schemas.js

@@ -5,12 +5,19 @@
  */
 import chalk from 'chalk';
 import { listSchemasWithInfo } from '../../core/artifact-graph/index.js';
+import { resolveRootForCommand } from '../../core/root-selection.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
 export async function schemasCommand(options) {
-    const projectRoot = process.cwd();
-    const schemas = listSchemasWithInfo(projectRoot);
+    const root = await resolveRootForCommand(options, {
+        json: options.json,
+        failurePayload: { schemas: [], root: null },
+    });
+    if (!root) {
+        return;
+    }
+    const schemas = listSchemasWithInfo(root.path);
     if (options.json) {
         console.log(JSON.stringify(schemas, null, 2));
         return;

package/dist/core/archive.js

@@ -10,7 +10,7 @@ import { emitStoreRootBanner, isRootSelectionError, resolveOpenSpecRoot, toRootO
 import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, retireSpec, finalizeRetiredSpec, } from './specs-apply.js';
 import { discoverSpecFiles, hasAnyFileUnder } from '../utils/spec-discovery.js';
 import { METADATA_FILENAME, readRetireCapabilitiesMarker, readSkipSpecsMarker } from '../utils/change-metadata.js';
-import { isNonInteractivePromptError } from '../utils/interactive.js';
+import { confirmPrompt, isNonInteractivePromptError } from '../utils/interactive.js';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { folderStyleNameProblem } from './id.js';
 function isMissingPathError(error) {
@@ -46,6 +46,33 @@ export async function isRetirableSpec(specName, rebuilt) {
     return (errors.length > 0 &&
         errors.every((issue) => issue.message === VALIDATION_MESSAGES.SPEC_NO_REQUIREMENTS));
 }
+/**
+ * How much of one blocking line the abort is willing to show. A line long
+ * enough to fill the screen would push the way out of the abort off it.
+ */
+const UNACCOUNTED_LINE_MAX = 200;
+/**
+ * The first few lines a retirement would delete without being able to name
+ * them, quoted, with a count for the rest. Capped so a long tail cannot bury
+ * the rest of the abort.
+ *
+ * The lines are authored spec content printed verbatim to a terminal, so they
+ * get the same treatment as a change directory name (`describeChangeName`): a
+ * raw CR could forge a line of its own, and an ESC could redraw the screen.
+ * Truncation counts code points so a cut never leaves half a surrogate pair.
+ */
+function describeUnaccountedContent(lines) {
+    const shown = lines
+        .slice(0, 3)
+        .map((line) => {
+        const safe = [...line.replace(/[\u0000-\u001f\u007f]/g, '?')];
+        const clipped = safe.slice(0, UNACCOUNTED_LINE_MAX).join('');
+        return `"${safe.length > UNACCOUNTED_LINE_MAX ? `${clipped}\u2026` : clipped}"`;
+    })
+        .join(', ');
+    const rest = lines.length > 3 ? `, and ${lines.length - 3} more line(s)` : '';
+    return `${shown}${rest}`;
+}
 async function isRetirementCandidate(update, built, skipValidation) {
     return (!skipValidation &&
         built.noRequirementBlocks &&
@@ -202,9 +229,8 @@ function rerunCommand(root, changeName, options) {
  * `User force closed the prompt` (#1479).
  */
 async function confirmOrBlock(prompt, blocked) {
-    const { confirm } = await import('@inquirer/prompts');
     try {
-        return await confirm(prompt);
+        return await confirmPrompt(prompt);
     }
     catch (error) {
         if (isNonInteractivePromptError(error)) {
@@ -1253,17 +1279,24 @@ export class ArchiveCommand {
                                 const specName = p.update.id;
                                 const report = await new Validator().validateSpecContent(specName, p.rebuilt);
                                 if (!report.valid) {
+                                    // This run is what emptied the capability, and "no
+                                    // requirements" is the only thing wrong with the spec that
+                                    // would be written - so retiring it is what archive would do,
+                                    // and what stands in the way of that is worth saying. Not
+                                    // always the *only* fix: a live requirement can be hiding in a
+                                    // second `## Requirements` section the validator never reaches,
+                                    // and merging the sections fixes that spec without a deletion.
+                                    const emptiedByThisRun = p.update.exists &&
+                                        p.counts.removed > 0 &&
+                                        p.noRequirementBlocks &&
+                                        (await isRetirableSpec(specName, p.rebuilt));
                                     // The dead end #1302 describes: the rebuilt spec is unwritable
                                     // for exactly one reason, and retiring the capability is the
                                     // fix - but only the author can authorise deleting the spec, so
                                     // the abort names the marker instead of just rejecting. Says so
                                     // only when the marker is the ONLY thing missing, so it never
                                     // sends someone after a marker that would not have helped.
-                                    const retirementWouldFix = !retirementDeclared &&
-                                        p.update.exists &&
-                                        p.counts.removed > 0 &&
-                                        (await isRetirementCandidate(p.update, p, false));
-                                    const retirementHint = retirementWouldFix
+                                    const retirementHint = !retirementDeclared && emptiedByThisRun && p.unaccountedContent.length === 0
                                         ? `This change removes the last requirement '${specName}' has. To retire the` +
                                             ` capability and delete its spec, add \`retire_capabilities: true\` to the` +
                                             ` change's ${METADATA_FILENAME} (alongside its \`schema:\`, which that file` +
@@ -1272,6 +1305,27 @@ export class ArchiveCommand {
                                                 ? ` The marker present now cannot be honored (${retirementMarker.invalidReason}).`
                                                 : '')
                                         : undefined;
+                                    // #1696: the marker is missing AND the file holds content a
+                                    // retirement cannot account for, so this abort said nothing at
+                                    // all - just "must have at least one requirement", with no way
+                                    // forward. It names the content instead of the marker, on
+                                    // purpose: the marker is only ever named when adding it would
+                                    // really let the archive through, and here it would not. Once
+                                    // the content is resolved the rerun names the marker.
+                                    const blockedRetirementHint = !retirementDeclared && emptiedByThisRun && p.unaccountedContent.length > 0
+                                        ? `This change removes the last requirement '${specName}' has, so the rebuilt ` +
+                                            `spec has none left and cannot be written. Retiring the capability is what ` +
+                                            `archive does instead, and it is refused while the spec holds content the ` +
+                                            `merge cannot safely account for and deleting the file would take with it: ` +
+                                            `${describeUnaccountedContent(p.unaccountedContent)}. ` +
+                                            'Move it into `## Purpose` or a canonical requirement, or delete the spec by hand, then rerun.' +
+                                            // Said here too, because an author looking at a marker they
+                                            // believe authorises the deletion should not have to clear
+                                            // the content first to find out it was never read.
+                                            (retirementMarker.invalidReason
+                                                ? ` The marker present now cannot be honored (${retirementMarker.invalidReason}).`
+                                                : '')
+                                        : undefined;
                                     // The marker was set and retirement was still refused. Saying
                                     // nothing left the author who did exactly what the docs asked
                                     // back in the original dead end with no signal that their
@@ -1283,13 +1337,13 @@ export class ArchiveCommand {
                                         (await isRetirableSpec(specName, p.rebuilt))
                                         ? `'${specName}' declares retire_capabilities, but the spec holds content the merge ` +
                                             `cannot safely account for and deleting the file would take with it: ` +
-                                            `${p.unaccountedContent.slice(0, 3).map((line) => `"${line}"`).join(', ')}` +
-                                            `${p.unaccountedContent.length > 3 ? `, and ${p.unaccountedContent.length - 3} more line(s)` : ''}. ` +
+                                            `${describeUnaccountedContent(p.unaccountedContent)}. ` +
                                             'Move it into `## Purpose` or a canonical requirement, or delete the spec by hand.'
                                         : undefined;
                                     if (json) {
                                         throw new ArchiveBlockedError('archive_spec_validation_failed', `Rebuilt spec for '${specName}' failed validation. No files were changed.`, refusalReason ??
                                             retirementHint ??
+                                            blockedRetirementHint ??
                                             `Run ${withStoreFlag(root, `openspec validate ${specName}`)} after fixing the change deltas.`);
                                     }
                                     console.log(chalk.red(`\nValidation errors in rebuilt spec for ${specName} (will not write changes):`));
@@ -1301,6 +1355,8 @@ export class ArchiveCommand {
                                     }
                                     if (retirementHint)
                                         console.log(chalk.yellow(`  → ${retirementHint}`));
+                                    if (blockedRetirementHint)
+                                        console.log(chalk.yellow(`  → ${blockedRetirementHint}`));
                                     if (refusalReason)
                                         console.log(chalk.yellow(`  → ${refusalReason}`));
                                     console.log('Aborted. No files were changed.');
@@ -1603,6 +1659,14 @@ export class ArchiveCommand {
             console.log('No active changes found.');
             return null;
         }
+        // A picker needs a real terminal, and @inquirer's `select` writes ANSI
+        // cursor escapes to stdout even when it is redirected — the same #1526
+        // mechanism the confirm prompts were fixed for. When either stream is not a
+        // TTY, refuse up front with the guidance the caught ExitPromptError would
+        // give, rather than render an escape-spewing menu into a pipe or file.
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new ArchiveBlockedError('archive_change_name_required', 'A change name is required: no terminal is available to choose one from a list.', withStoreFlag(root, `openspec archive <change-name> ${rerunFlags(options).join(' ')}`));
+        }
         // Build choices with progress inline to avoid duplicate lists
         let choices = changeDirs.map(name => ({ name, value: name }));
         try {

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 { resolveArtifactOutputPath, resolveArtifactOutputs } from './outputs.js';
+import { isSpecsArtifactPath, 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';
@@ -92,12 +92,7 @@ export function loadChangeContext(projectRoot, changeName, schemaName, options =
     const skippedArtifacts = new Set();
     if (metadata?.skip_specs) {
         for (const artifact of graph.getAllArtifacts()) {
-            // A schema may write generates as './specs/...' - the globs treat that
-            // identically to 'specs/...', so the skip set must too, or validate
-            // would honor the marker while instructions tell the agent to create
-            // the very files the conflict gate polices.
-            const generates = artifact.generates.replace(/^(?:\.\/)+/, '');
-            if (generates.startsWith('specs/') && !completed.has(artifact.id)) {
+            if (isSpecsArtifactPath(artifact.generates) && !completed.has(artifact.id)) {
                 completed.add(artifact.id);
                 skippedArtifacts.add(artifact.id);
             }

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

@@ -2,6 +2,10 @@
  * Checks if a path contains glob pattern characters.
  */
 export declare function isGlobPattern(pattern: string): boolean;
+/**
+ * Returns whether an artifact generates files under the change's specs/ tree.
+ */
+export declare function isSpecsArtifactPath(generates: string): boolean;
 export declare function resolveArtifactOutputPath(changeDir: string, generates: string): string;
 /**
  * Resolves an artifact's output path(s) to concrete files that currently exist.

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

@@ -8,6 +8,13 @@ import { FileSystemUtils } from '../../utils/file-system.js';
 export function isGlobPattern(pattern) {
     return pattern.includes('*') || pattern.includes('?') || pattern.includes('[');
 }
+/**
+ * Returns whether an artifact generates files under the change's specs/ tree.
+ */
+export function isSpecsArtifactPath(generates) {
+    const normalized = path.posix.normalize(FileSystemUtils.toPosixPath(generates));
+    return normalized.startsWith('specs/');
+}
 export function resolveArtifactOutputPath(changeDir, generates) {
     const outputPath = path.join(changeDir, generates);
     FileSystemUtils.assertPathWithin(changeDir, outputPath);

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

@@ -52,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;
     }

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/adapters/opencode.d.ts

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

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

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

package/dist/core/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/completion-tip.d.ts

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