@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/commands/spec.js

@@ -5,7 +5,7 @@ import { Validator } from '../core/validation/validator.js';
 import { isInteractive } from '../utils/interactive.js';
 import { getSpecIds } from '../utils/item-discovery.js';
 import { CLI_NAME } from '../core/branding.js';
-import { displayLegacyOpenSpecPath, resolveOpenSpecSubpath, } from '../core/sdd/services/legacy-capability.service.js';
+import { displayLegacySpecPath, resolveLegacySpecSubpath, } from '../core/sdd/services/legacy-capability.service.js';
 const SPECS_DIR = 'specs';
 function parseSpecFromFile(specPath, specId) {
     const content = readFileSync(specPath, 'utf-8');
@@ -30,7 +30,7 @@ function filterSpec(spec, options) {
         text: req.text,
         scenarios: includeScenarios ? req.scenarios : [],
     }));
-    const metadata = spec.metadata ?? { version: '1.0.0', format: 'openspec' };
+    const metadata = spec.metadata ?? { version: '1.0.0', format: 'codesdd' };
     return {
         name: spec.name,
         overview: spec.overview,
@@ -63,9 +63,9 @@ export class SpecCommand {
                 throw new Error('Missing required argument <spec-id>');
             }
         }
-        const specPath = resolveOpenSpecSubpath(process.cwd(), this.SPECS_DIR, specId, 'spec.md');
+        const specPath = resolveLegacySpecSubpath(process.cwd(), this.SPECS_DIR, specId, 'spec.md');
         if (!existsSync(specPath)) {
-            throw new Error(`Spec '${specId}' not found at ${displayLegacyOpenSpecPath('specs', specId, 'spec.md')}`);
+            throw new Error(`Spec '${specId}' not found at ${displayLegacySpecPath('specs', specId, 'spec.md')}`);
         }
         if (options.json) {
             if (options.requirements && options.requirement) {
@@ -79,7 +79,7 @@ export class SpecCommand {
                 overview: parsed.overview,
                 requirementCount: filtered.requirements.length,
                 requirements: filtered.requirements,
-                metadata: parsed.metadata ?? { version: '1.0.0', format: 'openspec' },
+                metadata: parsed.metadata ?? { version: '1.0.0', format: 'codesdd' },
             };
             console.log(JSON.stringify(output, null, 2));
             return;
@@ -90,7 +90,7 @@ export class SpecCommand {
 export function registerSpecCommand(rootProgram) {
     const specCommand = rootProgram
         .command('spec')
-        .description('Manage and view OpenSpec specifications');
+        .description('Manage and view specifications');
     // Deprecation notice for noun-based commands
     specCommand.hook('preAction', () => {
         console.error(`Warning: The "${CLI_NAME} spec ..." commands are deprecated. Prefer verb-first commands (e.g., "${CLI_NAME} show", "${CLI_NAME} validate --specs").`);
@@ -120,7 +120,7 @@ export function registerSpecCommand(rootProgram) {
         .option('--long', 'Show id and title with counts')
         .action((options) => {
         try {
-            const specsDir = resolveOpenSpecSubpath(process.cwd(), SPECS_DIR);
+            const specsDir = resolveLegacySpecSubpath(process.cwd(), SPECS_DIR);
             if (!existsSync(specsDir)) {
                 console.log('No items found');
                 return;
@@ -194,9 +194,9 @@ export function registerSpecCommand(rootProgram) {
                     throw new Error('Missing required argument <spec-id>');
                 }
             }
-            const specPath = resolveOpenSpecSubpath(process.cwd(), SPECS_DIR, specId, 'spec.md');
+            const specPath = resolveLegacySpecSubpath(process.cwd(), SPECS_DIR, specId, 'spec.md');
             if (!existsSync(specPath)) {
-                throw new Error(`Spec '${specId}' not found at ${displayLegacyOpenSpecPath('specs', specId, 'spec.md')}`);
+                throw new Error(`Spec '${specId}' not found at ${displayLegacySpecPath('specs', specId, 'spec.md')}`);
             }
             const validator = new Validator(options.strict);
             const report = await validator.validateSpec(specPath);

package/dist/commands/validate.js

@@ -4,7 +4,7 @@ import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
 import { getActiveChangeIds, getSpecIds } from '../utils/item-discovery.js';
 import { nearestMatches } from '../utils/match.js';
 import { CLI_NAME } from '../core/branding.js';
-import { resolveOpenSpecSubpath } from '../core/sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from '../core/sdd/services/legacy-capability.service.js';
 export class ValidateCommand {
     async execute(itemName, options = {}) {
         const interactive = isInteractive(options);
@@ -100,7 +100,7 @@ export class ValidateCommand {
     async validateByType(type, id, opts) {
         const validator = new Validator(opts.strict);
         if (type === 'change') {
-            const changeDir = resolveOpenSpecSubpath(process.cwd(), 'changes', id);
+            const changeDir = resolveLegacySpecSubpath(process.cwd(), 'changes', id);
             const start = Date.now();
             const report = await validator.validateChangeDeltaSpecs(changeDir);
             const durationMs = Date.now() - start;
@@ -109,7 +109,7 @@ export class ValidateCommand {
             process.exitCode = report.valid ? 0 : 1;
             return;
         }
-        const file = resolveOpenSpecSubpath(process.cwd(), 'specs', id, 'spec.md');
+        const file = resolveLegacySpecSubpath(process.cwd(), 'specs', id, 'spec.md');
         const start = Date.now();
         const report = await validator.validateSpec(file);
         const durationMs = Date.now() - start;
@@ -158,13 +158,13 @@ export class ValidateCommand {
         ]);
         const DEFAULT_CONCURRENCY = 6;
         const maxSuggestions = 5; // used by nearestMatches
-        const concurrency = normalizeConcurrency(opts.concurrency) ?? normalizeConcurrency(process.env.OPENSPEC_CONCURRENCY) ?? DEFAULT_CONCURRENCY;
+        const concurrency = normalizeConcurrency(opts.concurrency) ?? normalizeConcurrency(process.env.CODESDD_CONCURRENCY) ?? DEFAULT_CONCURRENCY;
         const validator = new Validator(opts.strict);
         const queue = [];
         for (const id of changeIds) {
             queue.push(async () => {
                 const start = Date.now();
-                const changeDir = resolveOpenSpecSubpath(process.cwd(), 'changes', id);
+                const changeDir = resolveLegacySpecSubpath(process.cwd(), 'changes', id);
                 const report = await validator.validateChangeDeltaSpecs(changeDir);
                 const durationMs = Date.now() - start;
                 return { id, type: 'change', valid: report.valid, issues: report.issues, durationMs };
@@ -173,7 +173,7 @@ export class ValidateCommand {
         for (const id of specIds) {
             queue.push(async () => {
                 const start = Date.now();
-                const file = resolveOpenSpecSubpath(process.cwd(), 'specs', id, 'spec.md');
+                const file = resolveLegacySpecSubpath(process.cwd(), 'specs', id, 'spec.md');
                 const report = await validator.validateSpec(file);
                 const durationMs = Date.now() - start;
                 return { id, type: 'spec', valid: report.valid, issues: report.issues, durationMs };

package/dist/commands/workflow/instructions.js

@@ -8,7 +8,7 @@ import ora from 'ora';
 import path from 'path';
 import * as fs from 'fs';
 import { loadChangeContext, generateInstructions, resolveSchema, } from '../../core/artifact-graph/index.js';
-import { resolveOpenSpecSubpath } from '../../core/sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from '../../core/sdd/services/legacy-capability.service.js';
 import { validateChangeExists, validateSchemaExists, } from './shared.js';
 import { CLI_NAME } from '../../core/branding.js';
 // -----------------------------------------------------------------------------
@@ -228,7 +228,7 @@ function artifactOutputExists(changeDir, generates) {
 export async function generateApplyInstructions(projectRoot, changeName, schemaName) {
     // loadChangeContext will auto-detect schema from metadata if not provided
     const context = loadChangeContext(projectRoot, changeName, schemaName);
-    const changeDir = resolveOpenSpecSubpath(projectRoot, 'changes', changeName);
+    const changeDir = resolveLegacySpecSubpath(projectRoot, 'changes', changeName);
     // Get the full schema to access the apply phase configuration
     const schema = resolveSchema(context.schemaName, projectRoot);
     const applyConfig = schema.apply;
@@ -272,19 +272,19 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
     let instruction;
     if (missingArtifacts.length > 0) {
         state = 'blocked';
-        instruction = `Cannot apply this change yet. Missing artifacts: ${missingArtifacts.join(', ')}.\nUse the openspec-continue-change skill or run ${CLI_NAME} instructions to create the missing artifacts first.`;
+        instruction = `Cannot apply this change yet. Missing artifacts: ${missingArtifacts.join(', ')}.\nUse the codesdd-continue-change skill or run ${CLI_NAME} instructions to create the missing artifacts first.`;
     }
     else if (tracksFile && !tracksFileExists) {
         // Tracking file configured but doesn't exist yet
         const tracksFilename = path.basename(tracksFile);
         state = 'blocked';
-        instruction = `The ${tracksFilename} file is missing and must be created.\nUse openspec-continue-change or run ${CLI_NAME} instructions to generate the tracking file.`;
+        instruction = `The ${tracksFilename} file is missing and must be created.\nUse codesdd-continue-change or run ${CLI_NAME} instructions to generate the tracking file.`;
     }
     else if (tracksFile && tracksFileExists && total === 0) {
         // Tracking file exists but contains no tasks
         const tracksFilename = path.basename(tracksFile);
         state = 'blocked';
-        instruction = `The ${tracksFilename} file exists but contains no tasks.\nAdd tasks to ${tracksFilename} or regenerate it with openspec-continue-change.`;
+        instruction = `The ${tracksFilename} file exists but contains no tasks.\nAdd tasks to ${tracksFilename} or regenerate it with codesdd-continue-change.`;
     }
     else if (tracksFile && remaining === 0 && total > 0) {
         state = 'all_done';
@@ -344,7 +344,7 @@ export function printApplyInstructionsText(instructions) {
         console.log('### ⚠️ Blocked');
         console.log();
         console.log(`Missing artifacts: ${missingArtifacts.join(', ')}`);
-        console.log(`Use the openspec-continue-change skill or run ${CLI_NAME} instructions to create these first.`);
+        console.log(`Use the codesdd-continue-change skill or run ${CLI_NAME} instructions to create these first.`);
         console.log();
     }
     // Context files (dynamically from schema)

package/dist/commands/workflow/new-change.js

@@ -7,7 +7,7 @@ import ora from 'ora';
 import path from 'path';
 import { createChange, validateChangeName } from '../../utils/change-utils.js';
 import { validateSchemaExists } from './shared.js';
-import { OPENSPEC_DIR_NAME } from '../../core/config.js';
+import { displayLegacySpecPath, resolveLegacySpecLiveSubpath } from '../../core/sdd/services/legacy-capability.service.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
@@ -31,11 +31,11 @@ export async function newChangeCommand(name, options) {
         // If description provided, create README.md with description
         if (options.description) {
             const { promises: fs } = await import('fs');
-            const changeDir = path.join(projectRoot, OPENSPEC_DIR_NAME, 'changes', name);
+            const changeDir = resolveLegacySpecLiveSubpath(projectRoot, 'changes', name);
             const readmePath = path.join(changeDir, 'README.md');
             await fs.writeFile(readmePath, `# ${name}\n\n${options.description}\n`, 'utf-8');
         }
-        spinner.succeed(`Created change '${name}' at ${OPENSPEC_DIR_NAME}/changes/${name}/ (schema: ${result.schema})`);
+        spinner.succeed(`Created change '${name}' at ${displayLegacySpecPath('changes', name)}/ (schema: ${result.schema})`);
     }
     catch (error) {
         spinner.fail(`Failed to create change '${name}'`);

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

@@ -38,7 +38,7 @@ export declare function getStatusColor(status: 'done' | 'ready' | 'blocked'): (t
  */
 export declare function getStatusIndicator(status: 'done' | 'ready' | 'blocked'): string;
 /**
- * Returns the list of available change directory names under openspec/changes/.
+ * Returns the list of available legacy change directory names under legacy-spec/changes/.
  * Excludes the archive directory and hidden directories.
  */
 export declare function getAvailableChanges(projectRoot: string): Promise<string[]>;

package/dist/commands/workflow/shared.js

@@ -9,7 +9,7 @@ import * as fs from 'fs';
 import { getSchemaDir, listSchemas } from '../../core/artifact-graph/index.js';
 import { validateChangeName } from '../../utils/change-utils.js';
 import { CLI_NAME } from '../../core/branding.js';
-import { resolveOpenSpecSubpath } from '../../core/sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from '../../core/sdd/services/legacy-capability.service.js';
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
@@ -54,11 +54,11 @@ export function getStatusIndicator(status) {
     }
 }
 /**
- * Returns the list of available change directory names under openspec/changes/.
+ * Returns the list of available legacy change directory names under legacy-spec/changes/.
  * Excludes the archive directory and hidden directories.
  */
 export async function getAvailableChanges(projectRoot) {
-    const changesPath = resolveOpenSpecSubpath(projectRoot, 'changes');
+    const changesPath = resolveLegacySpecSubpath(projectRoot, 'changes');
     try {
         const entries = await fs.promises.readdir(changesPath, { withFileTypes: true });
         return entries
@@ -89,7 +89,7 @@ export async function validateChangeExists(changeName, projectRoot) {
         throw new Error(`Invalid change name '${changeName}': ${nameValidation.error}`);
     }
     // Check directory existence directly
-    const changePath = resolveOpenSpecSubpath(projectRoot, 'changes', changeName);
+    const changePath = resolveLegacySpecSubpath(projectRoot, 'changes', changeName);
     const exists = fs.existsSync(changePath) && fs.statSync(changePath).isDirectory();
     if (!exists) {
         const available = await getAvailableChanges(projectRoot);

package/dist/core/archive.js

@@ -10,7 +10,7 @@ import { computeRequirementHash, readMeta, captureFingerprintsForChange, writeMe
 import { extractRequirementsSection, normalizeRequirementName, parseDeltaSpec, } from './parsers/requirement-blocks.js';
 import { CLI_NAME } from './branding.js';
 import { trackFingerprintMismatch } from '../telemetry/index.js';
-import { resolveOpenSpecLiveSubpath } from './sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecLiveSubpath } from './sdd/services/legacy-capability.service.js';
 const execFileAsync = promisify(execFile);
 function buildRequirementKey(capability, name) {
     return `${capability}::${normalizeRequirementName(name)}`;
@@ -56,15 +56,25 @@ async function moveDirectory(src, dest) {
 export class ArchiveCommand {
     async execute(changeName, options = {}) {
         const targetPath = '.';
-        const changesDir = resolveOpenSpecLiveSubpath(targetPath, 'changes');
+        const changesDir = resolveLegacySpecLiveSubpath(targetPath, 'changes');
         const archiveDir = path.join(changesDir, 'archive');
-        const mainSpecsDir = resolveOpenSpecLiveSubpath(targetPath, 'specs');
+        const mainSpecsDir = resolveLegacySpecLiveSubpath(targetPath, 'specs');
         // Check if changes directory exists
         try {
             await fs.access(changesDir);
         }
         catch {
-            throw new Error(`No OpenSpec changes directory found. Run '${CLI_NAME} init' first.`);
+            const sddStatePath = path.join(targetPath, '.sdd', 'state', 'backlog.yaml');
+            try {
+                await fs.access(sddStatePath);
+                throw new Error(`This repository uses SDD canonical state. The legacy '${CLI_NAME} archive' command does not apply here.\nUse '${CLI_NAME} sdd finalize --ref <FEAT-ID>' to consolidate a completed FEAT.`);
+            }
+            catch (err) {
+                if (err instanceof Error && err.message.startsWith('This repository uses SDD canonical state')) {
+                    throw err;
+                }
+                throw new Error(`No CodeSDD changes directory found. Run '${CLI_NAME} init' first.`);
+            }
         }
         // Get change name interactively if not provided
         if (!changeName) {
@@ -336,7 +346,7 @@ export class ArchiveCommand {
         return new Date().toISOString().split('T')[0];
     }
     async validateFingerprintsAgainstLiveSpec(changeName, changeDir, specUpdates) {
-        const mainSpecsDir = resolveOpenSpecLiveSubpath('.', 'specs');
+        const mainSpecsDir = resolveLegacySpecLiveSubpath('.', 'specs');
         let meta = await readMeta(changeDir);
         if (!meta) {
             meta = await captureFingerprintsForChange(changeDir, mainSpecsDir, {

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

@@ -109,7 +109,7 @@ export declare function loadTemplate(schemaName: string, templatePath: string, p
  *
  * Schema resolution order:
  * 1. Explicit schemaName parameter (if provided)
- * 2. Schema from .openspec.yaml metadata (if exists in change directory)
+ * 2. Schema from .sdd.yaml metadata (if exists in change directory)
  * 3. Default 'spec-driven'
  *
  * @param projectRoot - Project root directory

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

@@ -5,7 +5,7 @@ import { ArtifactGraph } from './graph.js';
 import { detectCompleted } from './state.js';
 import { resolveSchemaForChange } from '../../utils/change-metadata.js';
 import { readProjectConfig, validateConfigRules } from '../project-config.js';
-import { resolveOpenSpecSubpath } from '../sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from '../sdd/services/legacy-capability.service.js';
 // Session-level cache for validation warnings (avoid repeating same warnings)
 const shownWarnings = new Set();
 /**
@@ -50,7 +50,7 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
  *
  * Schema resolution order:
  * 1. Explicit schemaName parameter (if provided)
- * 2. Schema from .openspec.yaml metadata (if exists in change directory)
+ * 2. Schema from .sdd.yaml metadata (if exists in change directory)
  * 3. Default 'spec-driven'
  *
  * @param projectRoot - Project root directory
@@ -59,7 +59,7 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
  * @returns Change context with graph, completed set, and metadata
  */
 export function loadChangeContext(projectRoot, changeName, schemaName) {
-    const changeDir = resolveOpenSpecSubpath(projectRoot, 'changes', changeName);
+    const changeDir = resolveLegacySpecSubpath(projectRoot, 'changes', changeName);
     // Resolve schema: explicit > metadata > default
     const resolvedSchemaName = resolveSchemaForChange(changeDir, schemaName);
     const schema = resolveSchema(resolvedSchemaName, projectRoot);

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

@@ -26,8 +26,8 @@ export declare function getProjectSchemasDir(projectRoot: string): string;
  * Resolves a schema name to its directory path.
  *
  * Resolution order (when projectRoot is provided):
- * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
- * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 1. Project-local: <projectRoot>/legacy-spec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/legacy-spec/schemas/<name>/schema.yaml
  * 3. Package built-in: <package>/schemas/<name>/schema.yaml
  *
  * When projectRoot is not provided, only user override and package built-in are checked
@@ -42,8 +42,8 @@ export declare function getSchemaDir(name: string, projectRoot?: string): string
  * Resolves a schema name to a SchemaYaml object.
  *
  * Resolution order (when projectRoot is provided):
- * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
- * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 1. Project-local: <projectRoot>/legacy-spec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/legacy-spec/schemas/<name>/schema.yaml
  * 3. Package built-in: <package>/schemas/<name>/schema.yaml
  *
  * When projectRoot is not provided, only user override and package built-in are checked

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

@@ -2,7 +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 { resolveOpenSpecSubpath } from '../sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from '../sdd/services/legacy-capability.service.js';
 import { parseSchema, SchemaValidationError } from './schema.js';
 /**
  * Error thrown when loading a schema fails.
@@ -38,14 +38,14 @@ export function getUserSchemasDir() {
  * @returns The path to the project's schemas directory
  */
 export function getProjectSchemasDir(projectRoot) {
-    return resolveOpenSpecSubpath(projectRoot, 'schemas');
+    return resolveLegacySpecSubpath(projectRoot, 'schemas');
 }
 /**
  * Resolves a schema name to its directory path.
  *
  * Resolution order (when projectRoot is provided):
- * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
- * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 1. Project-local: <projectRoot>/legacy-spec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/legacy-spec/schemas/<name>/schema.yaml
  * 3. Package built-in: <package>/schemas/<name>/schema.yaml
  *
  * When projectRoot is not provided, only user override and package built-in are checked
@@ -82,8 +82,8 @@ export function getSchemaDir(name, projectRoot) {
  * Resolves a schema name to a SchemaYaml object.
  *
  * Resolution order (when projectRoot is provided):
- * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
- * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 1. Project-local: <projectRoot>/legacy-spec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/legacy-spec/schemas/<name>/schema.yaml
  * 3. Package built-in: <package>/schemas/<name>/schema.yaml
  *
  * When projectRoot is not provided, only user override and package built-in are checked

package/dist/core/branding.js

@@ -6,7 +6,7 @@ export const CLI_NAME = envOrDefault('CODESDD_CLI_NAME', 'codesdd');
 export const CLI_PACKAGE_NAME = envOrDefault('CODESDD_CLI_PACKAGE_NAME', '@devtrack-solution/codesdd');
 export const CLI_ENTRYPOINT = envOrDefault('CODESDD_CLI_ENTRYPOINT', 'bin/codesdd.js');
 export const CLI_PRODUCT_NAME = envOrDefault('CODESDD_CLI_PRODUCT_NAME', 'CodeSDD');
-export const CLI_REPOSITORY_SLUG = envOrDefault('CODESDD_REPOSITORY_SLUG', 'devtrack-solution/opensdd-cli');
-export const CLI_REPOSITORY_URL = envOrDefault('CODESDD_REPOSITORY_URL', 'https://github.com/devtrack-solution/opensdd-cli');
-export const CLI_ISSUES_URL = envOrDefault('CODESDD_ISSUES_URL', 'https://github.com/devtrack-solution/opensdd-cli/issues');
+export const CLI_REPOSITORY_SLUG = envOrDefault('CODESDD_REPOSITORY_SLUG', 'devtrack-solution/codesdd');
+export const CLI_REPOSITORY_URL = envOrDefault('CODESDD_REPOSITORY_URL', 'https://github.com/devtrack-solution/codesdd');
+export const CLI_ISSUES_URL = envOrDefault('CODESDD_ISSUES_URL', 'https://github.com/devtrack-solution/codesdd/issues');
 //# sourceMappingURL=branding.js.map

package/dist/core/cli/command-matrix.js

@@ -23,6 +23,7 @@ export function collectCliLeafCommands(command, prefix = []) {
 }
 export const CLI_COMMAND_MATRIX = [
     { commandPath: 'init', strategy: 'contract', rationale: 'Project bootstrap is deterministic and already decomposes into testable setup services.' },
+    { commandPath: 'reload', strategy: 'spawned-e2e', rationale: 'Reload reapplies base setup plus SDD bootstrap with the installed CLI version and needs real-bin smoke coverage.' },
     { commandPath: 'install', strategy: 'spawned-e2e', rationale: 'Full installation composes base bootstrap plus SDD initialization and should keep a spawned smoke path.' },
     { commandPath: 'experimental', strategy: 'exception', rationale: 'Deprecated compatibility alias inherits init behavior and only needs lightweight regression coverage.' },
     { commandPath: 'update', strategy: 'contract', rationale: 'Update flow is deterministic and validated through targeted service and CLI contract tests.' },
@@ -36,6 +37,8 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'spec:list', strategy: 'contract', rationale: 'Spec listing is read-only and easy to validate with direct CLI assertions.' },
     { commandPath: 'spec:validate', strategy: 'contract', rationale: 'Spec validation is a deterministic contract surface with fixture-driven expectations.' },
     { commandPath: 'config:path', strategy: 'contract', rationale: 'Config path output is deterministic and scriptable.' },
+    { commandPath: 'config:init', strategy: 'contract', rationale: 'Global runtime bootstrap is deterministic and should be covered with fixture-backed contract tests.' },
+    { commandPath: 'config:doctor', strategy: 'contract', rationale: 'Doctor emits deterministic readiness diagnostics for DeepAgents, cache, and Redis boundary.' },
     { commandPath: 'config:list', strategy: 'contract', rationale: 'Config listing is a stable read-only contract.' },
     { commandPath: 'config:get', strategy: 'contract', rationale: 'Config key retrieval is a stable scriptable surface.' },
     { commandPath: 'config:set', strategy: 'contract', rationale: 'Config writes can be asserted directly against temporary config fixtures.' },
@@ -57,6 +60,7 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'sdd:breakdown', strategy: 'spawned-e2e', rationale: 'Breakdown materializes executable FEAT workspaces and needs lifecycle smoke coverage.' },
     { commandPath: 'sdd:mcp-manifest', strategy: 'contract', rationale: 'Manifest rendering is deterministic and provider-profile driven.' },
     { commandPath: 'sdd:mcp-call', strategy: 'contract', rationale: 'The MCP bridge reuses canonical services and is best guarded with direct contract assertions.' },
+    { commandPath: 'sdd:agent:run', strategy: 'contract', rationale: 'DeepAgents run gating is a deterministic fail-closed policy contract with no direct state writes.' },
     { commandPath: 'sdd:start', strategy: 'spawned-e2e', rationale: 'Start transitions planned work into active execution and is a core lifecycle boundary.' },
     { commandPath: 'sdd:frontend-impact', strategy: 'spawned-e2e', rationale: 'Frontend impact is a required lifecycle declaration that should remain part of spawned finalize-path smoke.' },
     { commandPath: 'sdd:finalize', strategy: 'spawned-e2e', rationale: 'Finalize is the highest-risk lifecycle transition and must keep spawned smoke coverage.' },
@@ -65,14 +69,19 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'sdd:aprovar', strategy: 'contract', rationale: 'Approval transitions are deterministic and fit fixture-driven lifecycle assertions.' },
     { commandPath: 'sdd:next', strategy: 'contract', rationale: 'Next is ranking logic over canonical state and is naturally contract-testable.' },
     { commandPath: 'sdd:audit', strategy: 'contract', rationale: 'Audit is a deterministic report over canonical state.' },
+    { commandPath: 'sdd:plugin:inspect', strategy: 'contract', rationale: 'Plugin inspect is a read-only manifest parser surface.' },
+    { commandPath: 'sdd:plugin:plan', strategy: 'contract', rationale: 'Plugin plan builds a non-executing runtime envelope from a manifest fixture.' },
+    { commandPath: 'sdd:plugin:devtrack-api:scaffold-dry-run', strategy: 'contract', rationale: 'DevTrack API scaffold dry-run plans appliance artifacts without executing a generator.' },
+    { commandPath: 'sdd:backlog:project', strategy: 'contract', rationale: 'Backlog projection is a read-only dry-run plan over canonical SDD refs with no provider I/O.' },
     { commandPath: 'sdd:check', strategy: 'contract', rationale: 'Check is a deterministic health summary with strict output contracts.' },
     { commandPath: 'sdd:rebuild', strategy: 'spawned-e2e', rationale: 'Rebuild reconstructs canonical state from filesystem artifacts and needs real-bin recovery smoke coverage.' },
     { commandPath: 'sdd:metrics', strategy: 'spawned-e2e', rationale: 'Metrics aggregate transition-log lifecycle data and should keep real-bin smoke coverage for reporting windows.' },
     { commandPath: 'sdd:dedup', strategy: 'spawned-e2e', rationale: 'Dedup apply reconciles historical warning_links across canonical state and needs real-bin mutation smoke coverage.' },
     { commandPath: 'sdd:lint:feature', strategy: 'spawned-e2e', rationale: 'Feature lint evaluates workspace scope heuristics and should keep real-bin smoke coverage for strict/non-strict behavior.' },
     { commandPath: 'sdd:migrate', strategy: 'contract', rationale: 'Migration planning and reporting are deterministic over fixture state.' },
+    { commandPath: 'sdd:upgrade-to-codesdd', strategy: 'contract', rationale: 'Transactional upgrade readiness, apply manifest, and rollback behavior are deterministic over fixture SDD state.' },
     { commandPath: 'sdd:migrate-workspace', strategy: 'contract', rationale: 'Workspace migration is deterministic and already aligns with fixture-based validation.' },
-    { commandPath: 'sdd:import-openspec', strategy: 'spawned-e2e', rationale: 'Legacy import crosses filesystem and generated-state boundaries, so a spawned smoke path is valuable.' },
+    { commandPath: 'sdd:import-legacy-spec', strategy: 'spawned-e2e', rationale: 'Legacy import crosses filesystem and generated-state boundaries, so a spawned smoke path is valuable.' },
     { commandPath: 'sdd:skills:bundles', strategy: 'contract', rationale: 'Bundle listing is a stable read-only catalog contract.' },
     { commandPath: 'sdd:skills:sync', strategy: 'contract', rationale: 'Skill sync can be asserted directly against temporary memory roots and tool targets.' },
     { commandPath: 'sdd:skills:suggest', strategy: 'contract', rationale: 'Suggestion ranking is deterministic over the catalog state.' },

package/dist/core/cli-command-quality.d.ts

@@ -0,0 +1,27 @@
+export type CliCommandEvidenceMode = 'contract' | 'in_process' | 'spawned_e2e' | 'exception';
+export interface CliCommandQualityException {
+    reason: string;
+    accepted_risk: string;
+    compensating_control: string;
+    review_deadline: string;
+}
+export interface CliCommandQualityEntry {
+    path: string;
+    evidence_mode: CliCommandEvidenceMode;
+    owner: string;
+    rationale: string;
+    validation_refs: string[];
+    interactive: boolean;
+    exception?: CliCommandQualityException;
+}
+export interface CliCommandQualityValidation {
+    missing: string[];
+    extra: string[];
+    duplicate_paths: string[];
+    invalid_entries: string[];
+}
+export declare const UNIVERSAL_SPAWNED_HELP_SMOKE_REF = "test/cli-e2e/all-commands-smoke.test.ts";
+export declare const CLI_COMMAND_QUALITY_MATRIX: CliCommandQualityEntry[];
+export declare function commandQualityMatrixByPath(matrix?: CliCommandQualityEntry[]): Map<string, CliCommandQualityEntry>;
+export declare function validateCliCommandQualityMatrix(registeredLeafCommandPaths: string[], matrix?: CliCommandQualityEntry[]): CliCommandQualityValidation;
+//# sourceMappingURL=cli-command-quality.d.ts.map