@fission-ai/openspec 1.10.0 → 1.12.0

package/dist/commands/show.js

@@ -4,7 +4,7 @@ import { resolveRootForCommand, toRootOutput, withStoreFlag, isStoreSelectedRoot
 import { ChangeCommand } from './change.js';
 import { SpecCommand } from './spec.js';
 import { nearestMatches } from '../utils/match.js';
-const CHANGE_FLAG_KEYS = new Set(['deltasOnly', 'requirementsOnly']);
+const CHANGE_FLAG_KEYS = new Set(['deltasOnly', 'requirementsOnly', 'diff']);
 const SPEC_FLAG_KEYS = new Set(['requirements', 'scenarios', 'requirement']);
 export class ShowCommand {
     async execute(itemName, options = {}) {

package/dist/commands/validate.d.ts

@@ -1,8 +1,11 @@
+import { toRootOutput } from '../core/root-selection.js';
+type ItemType = 'change' | 'spec';
 interface ExecuteOptions {
     all?: boolean;
     changes?: boolean;
     specs?: boolean;
     archived?: boolean;
+    report?: string;
     type?: string;
     strict?: boolean;
     json?: boolean;
@@ -12,6 +15,58 @@ interface ExecuteOptions {
     store?: string;
     storePath?: string;
 }
+interface BulkItemResult {
+    id: string;
+    type: ItemType;
+    valid: boolean;
+    issues: {
+        level: 'ERROR' | 'WARNING' | 'INFO';
+        path: string;
+        message: string;
+    }[];
+    durationMs: number;
+}
+type BulkScope = 'all' | 'changes' | 'specs' | 'archived';
+interface BulkValidationResult<T extends BulkItemResult = BulkItemResult> {
+    items: T[];
+    summary: {
+        totals: {
+            items: number;
+            passed: number;
+            failed: number;
+        };
+        byType: Partial<Record<ItemType, {
+            items: number;
+            passed: number;
+            failed: number;
+        }>>;
+    };
+    root: ReturnType<typeof toRootOutput>;
+}
+/** Findings are a distinct report, not a partial full-v1 items collection. */
+export declare function projectValidationFindings<T extends BulkItemResult>(full: BulkValidationResult<T>, scope: BulkScope): {
+    report: {
+        kind: "validation-findings";
+        version: "1.0";
+        scope: BulkScope;
+        returnedItems: number;
+        totalItems: number;
+    };
+    itemFindings: T[];
+    summary: {
+        totals: {
+            items: number;
+            passed: number;
+            failed: number;
+        };
+        byType: Partial<Record<ItemType, {
+            items: number;
+            passed: number;
+            failed: number;
+        }>>;
+    };
+    root: import("../core/root-selection.js").RootOutput;
+};
 export declare class ValidateCommand {
     execute(itemName: string | undefined, options?: ExecuteOptions): Promise<void>;
     private normalizeType;
@@ -29,6 +84,8 @@ export declare class ValidateCommand {
     private validateByType;
     private printReport;
     private printNextSteps;
+    private printFindingsReport;
+    private printBulkDetails;
     private runBulkValidation;
     /**
      * Lists archived change ids from the resolved root's archive directory,

package/dist/commands/validate.js

@@ -10,9 +10,54 @@ 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';
+/** Findings are a distinct report, not a partial full-v1 items collection. */
+export function projectValidationFindings(full, scope) {
+    const itemFindings = full.items.filter(item => item.issues.length > 0);
+    return {
+        report: {
+            kind: 'validation-findings',
+            version: '1.0',
+            scope,
+            returnedItems: itemFindings.length,
+            totalItems: full.summary.totals.items,
+        },
+        itemFindings,
+        summary: full.summary,
+        root: full.root,
+    };
+}
 export class ValidateCommand {
     async execute(itemName, options = {}) {
         const bulk = options.all || options.changes || options.specs;
+        let findingsScope;
+        if (options.report !== undefined) {
+            const message = options.report !== 'full' && options.report !== 'findings'
+                ? `Unknown validation report '${options.report}'.`
+                : itemName !== undefined
+                    ? 'A validation report cannot be combined with an item name.'
+                    : options.archived && bulk
+                        ? 'A validation report cannot combine archived and active scopes.'
+                        : !options.archived && !bulk
+                            ? 'A validation report requires an explicit bulk scope.'
+                            : undefined;
+            if (message) {
+                const fix = 'Use --report full|findings with --all, --changes, --specs, or --archived, without an item name. Do not combine archived and active scopes.';
+                if (options.json) {
+                    console.log(JSON.stringify({ status: [{ severity: 'error', code: 'invalid_validation_report_request', message, fix }] }, null, 2));
+                }
+                else {
+                    console.error(`Error: ${message}`);
+                    console.error(`Fix: ${fix}`);
+                }
+                process.exitCode = 1;
+                return;
+            }
+            if (options.report === 'findings') {
+                findingsScope = options.archived ? 'archived'
+                    : options.all || (options.changes && options.specs) ? 'all'
+                        : options.changes ? 'changes' : 'specs';
+            }
+        }
         const root = await resolveRootForCommand(options, {
             json: options.json,
             ...(bulk ? { allowImplicitRoot: false } : {}),
@@ -29,6 +74,7 @@ export class ValidateCommand {
             await this.runArchivedTaskValidation(root, {
                 json: !!options.json,
                 noInteractive: resolveNoInteractive(options),
+                findingsScope,
             });
             return;
         }
@@ -37,7 +83,7 @@ export class ValidateCommand {
             await this.runBulkValidation(root, {
                 changes: !!options.all || !!options.changes,
                 specs: !!options.all || !!options.specs,
-            }, { strict: !!options.strict, json: !!options.json, concurrency: options.concurrency, noInteractive: resolveNoInteractive(options) });
+            }, { strict: !!options.strict, json: !!options.json, concurrency: options.concurrency, noInteractive: resolveNoInteractive(options), findingsScope });
             return;
         }
         // No item and no flags
@@ -191,11 +237,12 @@ export class ValidateCommand {
         }
         else {
             console.error(`${type === 'change' ? 'Change' : 'Specification'} '${id}' has issues`);
-            for (const issue of report.issues) {
-                const label = issue.level === 'ERROR' ? 'ERROR' : issue.level;
-                const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
-                console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
-            }
+        }
+        for (const issue of report.issues) {
+            const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
+            console.error(`${prefix} [${issue.level}] ${issue.path}: ${issue.message}`);
+        }
+        if (!report.valid) {
             this.printNextSteps(type, id, root, report.issues);
         }
     }
@@ -228,6 +275,34 @@ export class ValidateCommand {
         console.error('Next steps:');
         bullets.forEach(b => console.error(`  ${b}`));
     }
+    printFindingsReport(full, scope, json, root) {
+        const findings = projectValidationFindings(full, scope);
+        if (json) {
+            console.log(JSON.stringify(findings, null, 2));
+            return;
+        }
+        console.log(`Scope: ${scope} (${findings.report.totalItems} items)`);
+        if (findings.itemFindings.length === 0) {
+            console.log('No item findings.');
+        }
+        for (const item of findings.itemFindings) {
+            console.error(`${item.type}/${item.id}`);
+            for (const issue of item.issues) {
+                console.error(`  [${issue.level}] ${issue.path}: ${issue.message}`);
+            }
+        }
+        const totals = findings.summary.totals;
+        console.log(`Totals: ${totals.passed} passed, ${totals.failed} failed (${totals.items} items)`);
+        if (scope !== 'archived')
+            this.printBulkDetails(full.items, root);
+    }
+    printBulkDetails(results, root) {
+        const firstFailure = results.find((res) => !res.valid);
+        if (firstFailure) {
+            const storeFlag = isStoreSelectedRoot(root) ? ` --store ${root.storeId}` : '';
+            console.log(`Details: openspec validate ${firstFailure.id} --type ${firstFailure.type}${storeFlag}`);
+        }
+    }
     async runBulkValidation(root, scope, opts) {
         const spinner = !opts.json && !opts.noInteractive ? ora('Validating...').start() : undefined;
         const [changeIds, specIds] = await Promise.all([
@@ -269,7 +344,10 @@ export class ValidateCommand {
                     ...(scope.specs ? { spec: { items: 0, passed: 0, failed: 0 } } : {}),
                 },
             };
-            if (opts.json) {
+            if (opts.findingsScope) {
+                this.printFindingsReport({ items: [], summary, root: toRootOutput(root) }, opts.findingsScope, opts.json, root);
+            }
+            else if (opts.json) {
                 const out = { items: [], summary, version: '1.0', root: toRootOutput(root) };
                 console.log(JSON.stringify(out, null, 2));
             }
@@ -326,7 +404,10 @@ export class ValidateCommand {
                 ...(scope.specs ? { spec: summarizeType(results, 'spec') } : {}),
             },
         };
-        if (opts.json) {
+        if (opts.findingsScope) {
+            this.printFindingsReport({ items: results, summary, root: toRootOutput(root) }, opts.findingsScope, opts.json, root);
+        }
+        else if (opts.json) {
             const out = { items: results, summary, version: '1.0', root: toRootOutput(root) };
             console.log(JSON.stringify(out, null, 2));
         }
@@ -336,13 +417,13 @@ export class ValidateCommand {
                     console.log(`✓ ${res.type}/${res.id}`);
                 else
                     console.error(`✗ ${res.type}/${res.id}`);
+                for (const issue of res.issues) {
+                    const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
+                    console.error(`  ${prefix} [${issue.level}] ${issue.path}: ${issue.message}`);
+                }
             }
             console.log(`Totals: ${summary.totals.passed} passed, ${summary.totals.failed} failed (${summary.totals.items} items)`);
-            const firstFailure = results.find((res) => !res.valid);
-            if (firstFailure) {
-                const storeFlag = isStoreSelectedRoot(root) ? ` --store ${root.storeId}` : '';
-                console.log(`Details: openspec validate ${firstFailure.id} --type ${firstFailure.type}${storeFlag}`);
-            }
+            this.printBulkDetails(results, root);
         }
         process.exitCode = failed > 0 ? 1 : 0;
     }
@@ -438,6 +519,11 @@ export class ValidateCommand {
             totals: { items: results.length, passed, failed },
             byType: { change: summarizeType(results, 'change') },
         };
+        if (opts.findingsScope) {
+            this.printFindingsReport({ items: results, summary, root: toRootOutput(root) }, opts.findingsScope, opts.json, root);
+            process.exitCode = failed > 0 ? 1 : 0;
+            return;
+        }
         if (opts.json) {
             const out = { items: results, summary, version: '1.0', root: toRootOutput(root) };
             console.log(JSON.stringify(out, null, 2));

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

@@ -3,7 +3,7 @@
  *
  * Commands for the artifact-driven workflow: status, instructions, templates, schemas, new change.
  */
-export { statusCommand } from './status.js';
+export { statusCommand, BATCH_STATUS_FAILURE_PAYLOAD } from './status.js';
 export type { StatusOptions } from './status.js';
 export { instructionsCommand, applyInstructionsCommand, archiveInstructionsCommand, } from './instructions.js';
 export type { InstructionsOptions } from './instructions.js';

package/dist/commands/workflow/index.js

@@ -3,7 +3,7 @@
  *
  * Commands for the artifact-driven workflow: status, instructions, templates, schemas, new change.
  */
-export { statusCommand } from './status.js';
+export { statusCommand, BATCH_STATUS_FAILURE_PAYLOAD } from './status.js';
 export { instructionsCommand, applyInstructionsCommand, archiveInstructionsCommand, } from './instructions.js';
 export { templatesCommand } from './templates.js';
 export { schemasCommand } from './schemas.js';

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

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

package/dist/commands/workflow/status.js

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

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

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

package/dist/core/available-tools.js

@@ -49,6 +49,21 @@ export function getAvailableTools(projectPath) {
         }
     });
     const activeProjectTools = new Set(reconcileSharedSkillTargets(projectPath, available.filter((tool) => tool.skillsDir)).map((tool) => tool.value));
-    return available.filter((tool) => tool.globalSkillsDir || activeProjectTools.has(tool.value));
+    const hasIndependentDetectionPath = (tool) => (tool.detectionPaths ?? []).some((detectionPath) => {
+        // Skill roots still go through managed-content reconciliation below;
+        // their mere existence is not an independent tool signal.
+        if (detectionPath.endsWith('/skills'))
+            return false;
+        try {
+            fs.statSync(path.join(projectPath, detectionPath));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    return available.filter((tool) => tool.globalSkillsDir ||
+        hasIndependentDetectionPath(tool) ||
+        activeProjectTools.has(tool.value));
 }
 //# sourceMappingURL=available-tools.js.map

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

@@ -6,7 +6,7 @@
 import type { ToolCommandAdapter } from '../types.js';
 /**
  * Antigravity adapter for command generation.
- * File path: .agent/workflows/opsx-<id>.md
+ * File path: .agents/workflows/opsx-<id>.md
  * Frontmatter: description
  */
 export declare const antigravityAdapter: ToolCommandAdapter;

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

@@ -7,13 +7,13 @@ import path from 'path';
 import { escapeYamlValue } from '../yaml.js';
 /**
  * Antigravity adapter for command generation.
- * File path: .agent/workflows/opsx-<id>.md
+ * File path: .agents/workflows/opsx-<id>.md
  * Frontmatter: description
  */
 export const antigravityAdapter = {
     toolId: 'antigravity',
     getFilePath(commandId) {
-        return path.join('.agent', 'workflows', `opsx-${commandId}.md`);
+        return path.join('.agents', 'workflows', `opsx-${commandId}.md`);
     },
     formatFile(content) {
         return `---

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

@@ -0,0 +1,15 @@
+/**
+ * SourceCraft Code Assistant Command Adapter
+ *
+ * Formats commands for the SourceCraft Code Assistant VS Code extension.
+ *
+ * @see https://sourcecraft.dev/portal/docs/en/code-assistant/operations/agent/slash-commands
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * SourceCraft Code Assistant adapter for command generation.
+ * File path: .codeassistant/commands/opsx-<id>.md
+ * Format: YAML frontmatter with description
+ */
+export declare const codeassistantAdapter: ToolCommandAdapter;
+//# sourceMappingURL=codeassistant.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * SourceCraft Code Assistant Command Adapter
+ *
+ * Formats commands for the SourceCraft Code Assistant VS Code extension.
+ *
+ * @see https://sourcecraft.dev/portal/docs/en/code-assistant/operations/agent/slash-commands
+ */
+import path from 'path';
+import { escapeYamlValue } from '../yaml.js';
+/**
+ * SourceCraft Code Assistant adapter for command generation.
+ * File path: .codeassistant/commands/opsx-<id>.md
+ * Format: YAML frontmatter with description
+ */
+export const codeassistantAdapter = {
+    toolId: 'codeassistant',
+    getFilePath(commandId) {
+        return path.join('.codeassistant', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${escapeYamlValue(content.description)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=codeassistant.js.map

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

@@ -26,6 +26,7 @@ export { kiroAdapter } from './kiro.js';
 export { ohMyPiAdapter } from './oh-my-pi.js';
 export { opencodeAdapter } from './opencode.js';
 export { piAdapter } from './pi.js';
+export { codeassistantAdapter } from './codeassistant.js';
 export { qoderAdapter } from './qoder.js';
 export { lingmaAdapter } from './lingma.js';
 export { qwenAdapter } from './qwen.js';

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

@@ -26,6 +26,7 @@ export { kiroAdapter } from './kiro.js';
 export { ohMyPiAdapter } from './oh-my-pi.js';
 export { opencodeAdapter } from './opencode.js';
 export { piAdapter } from './pi.js';
+export { codeassistantAdapter } from './codeassistant.js';
 export { qoderAdapter } from './qoder.js';
 export { lingmaAdapter } from './lingma.js';
 export { qwenAdapter } from './qwen.js';

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

@@ -27,6 +27,7 @@ import { kiroAdapter } from './adapters/kiro.js';
 import { ohMyPiAdapter } from './adapters/oh-my-pi.js';
 import { opencodeAdapter } from './adapters/opencode.js';
 import { piAdapter } from './adapters/pi.js';
+import { codeassistantAdapter } from './adapters/codeassistant.js';
 import { qoderAdapter } from './adapters/qoder.js';
 import { lingmaAdapter } from './adapters/lingma.js';
 import { qwenAdapter } from './adapters/qwen.js';
@@ -63,6 +64,7 @@ export class CommandAdapterRegistry {
         CommandAdapterRegistry.register(ohMyPiAdapter);
         CommandAdapterRegistry.register(opencodeAdapter);
         CommandAdapterRegistry.register(piAdapter);
+        CommandAdapterRegistry.register(codeassistantAdapter);
         CommandAdapterRegistry.register(qoderAdapter);
         CommandAdapterRegistry.register(lingmaAdapter);
         CommandAdapterRegistry.register(qwenAdapter);

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

@@ -106,6 +106,12 @@ export const COMMAND_REGISTRY = [
                 name: 'archived',
                 description: 'Validate that archived changes have all tasks completed (for pre-commit linting)',
             },
+            {
+                name: 'report',
+                description: 'Select bulk report content',
+                takesValue: true,
+                values: ['full', 'findings'],
+            },
             COMMON_FLAGS.type,
             COMMON_FLAGS.strict,
             COMMON_FLAGS.jsonValidation,
@@ -136,6 +142,10 @@ export const COMMAND_REGISTRY = [
                 name: 'requirements-only',
                 description: 'Alias for --deltas-only (deprecated, change-specific)',
             },
+            {
+                name: 'diff',
+                description: 'Show per-requirement diffs for delta specs (change-specific)',
+            },
             {
                 name: 'requirements',
                 description: 'Show only requirements, exclude scenarios (JSON only, spec-specific)',
@@ -189,6 +199,10 @@ export const COMMAND_REGISTRY = [
                 description: 'Change name to show status for',
                 takesValue: true,
             },
+            {
+                name: 'all',
+                description: 'Show status for all active changes',
+            },
             {
                 name: 'schema',
                 description: 'Schema override',
@@ -285,6 +299,7 @@ export const COMMAND_REGISTRY = [
                         name: 'path',
                         description: 'Directory to use for the store',
                         takesValue: true,
+                        completionType: 'path',
                     },
                     {
                         name: 'init-git',
@@ -377,6 +392,7 @@ export const COMMAND_REGISTRY = [
                 name: 'code-workspace',
                 description: 'Also write a VS Code workspace file for the set',
                 takesValue: true,
+                completionType: 'path',
             },
             {
                 name: 'force',
@@ -407,6 +423,7 @@ export const COMMAND_REGISTRY = [
                         name: 'member',
                         description: 'Member folder as <path> or <name>=<path>; repeatable, first is the primary',
                         takesValue: true,
+                        completionType: 'path',
                     },
                     {
                         name: 'tool',
@@ -488,6 +505,10 @@ export const COMMAND_REGISTRY = [
                         name: 'requirements-only',
                         description: 'Alias for --deltas-only (deprecated)',
                     },
+                    {
+                        name: 'diff',
+                        description: 'Show per-requirement diffs for delta specs',
+                    },
                     COMMON_FLAGS.noInteractive,
                 ],
             },