@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

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.' },
@@ -43,12 +46,17 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'config:reset', strategy: 'contract', rationale: 'Reset behavior is deterministic once prompts are bypassed in tests.' },
     { commandPath: 'config:edit', strategy: 'exception', rationale: 'This command delegates to an external editor process and only needs focused environment-sensitive coverage.' },
     { commandPath: 'config:profile', strategy: 'contract', rationale: 'Profile inspection is scriptable and deterministic.' },
+    { commandPath: 'config:redis:status', strategy: 'contract', rationale: 'Redis status reports the governed runtime backend without exposing secrets.' },
+    { commandPath: 'config:redis:ping', strategy: 'contract', rationale: 'Redis ping is a deterministic readiness contract with mocked and unavailable paths.' },
+    { commandPath: 'config:redis:bench', strategy: 'contract', rationale: 'Redis benchmark output is bounded, redacted, and suitable for direct contract assertions.' },
+    { commandPath: 'config:redis:flush-namespace', strategy: 'contract', rationale: 'Redis namespace cleanup is explicitly scoped and guarded by confirmation.' },
     { commandPath: 'schema:which', strategy: 'contract', rationale: 'Schema resolution is deterministic with fixture directories.' },
     { commandPath: 'schema:validate', strategy: 'contract', rationale: 'Schema validation produces deterministic reports from fixture inputs.' },
     { commandPath: 'schema:fork', strategy: 'contract', rationale: 'Schema fork output is a filesystem contract that can be asserted directly.' },
     { commandPath: 'schema:init', strategy: 'contract', rationale: 'Schema initialization is deterministic over temporary workspaces.' },
     { commandPath: 'sdd:init', strategy: 'spawned-e2e', rationale: 'SDD init seeds canonical state and generated views, so it should keep lifecycle smoke coverage.' },
     { commandPath: 'sdd:init-context', strategy: 'spawned-e2e', rationale: 'Context bootstrap reads repository structure and writes canonical state, which benefits from spawned smoke coverage.' },
+    { commandPath: 'sdd:intent-guard', strategy: 'contract', rationale: 'Intent guard classification is deterministic and should stay covered with direct contract tests.' },
     { commandPath: 'sdd:fingerprint', strategy: 'contract', rationale: 'Fingerprint backfill is a deterministic batch operation over change fixtures.' },
     { commandPath: 'sdd:insight', strategy: 'spawned-e2e', rationale: 'Insight creation is the first discovery lifecycle write and should stay covered in spawned flow tests.' },
     { commandPath: 'sdd:ingest-deposito', strategy: 'spawned-e2e', rationale: 'Ingestion coordinates discovery inputs, indexing, and trail generation across filesystem boundaries.' },
@@ -57,6 +65,9 @@ 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:preflight', strategy: 'contract', rationale: 'Preflight reuses deterministic mutation guardrails without invoking agent runtime.' },
+    { commandPath: 'sdd:agent:run', strategy: 'contract', rationale: 'DeepAgents run gating is a deterministic fail-closed policy contract with no direct state writes.' },
+    { commandPath: 'sdd:release-readiness', strategy: 'contract', rationale: 'Release readiness aggregates static gates and CI parity commands without publishing or mutating release state.' },
     { 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.' },
@@ -64,15 +75,22 @@ export const CLI_COMMAND_MATRIX = [
     { commandPath: 'sdd:onboard', strategy: 'contract', rationale: 'Onboard is a read-oriented guidance surface with deterministic ranking output.' },
     { 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:plan-status', strategy: 'contract', rationale: 'Plan status aggregates active and ready work without mutating state.' },
+    { commandPath: 'sdd:execute-next', strategy: 'spawned-e2e', rationale: 'Execute next bridges ranking into start and must preserve lifecycle guardrails.' },
     { 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

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

@@ -0,0 +1,180 @@
+const OWNER = 'CodeSDD maintainers';
+const REVIEW_DEADLINE = '2026-11-09';
+export const UNIVERSAL_SPAWNED_HELP_SMOKE_REF = 'test/cli-e2e/all-commands-smoke.test.ts';
+function withUniversalSpawnedHelpSmoke(validationRefs) {
+    return Array.from(new Set([UNIVERSAL_SPAWNED_HELP_SMOKE_REF, ...validationRefs]));
+}
+function entry(path, evidenceMode, rationale, validationRefs, options = {}) {
+    return {
+        path,
+        evidence_mode: evidenceMode,
+        owner: OWNER,
+        rationale,
+        validation_refs: withUniversalSpawnedHelpSmoke(validationRefs),
+        interactive: options.interactive ?? false,
+        exception: options.exception,
+    };
+}
+function entries(paths, evidenceMode, rationale, validationRefs) {
+    return paths.map((path) => entry(path, evidenceMode, rationale, validationRefs));
+}
+function exceptionEntry(path, reason, acceptedRisk, compensatingControl, validationRefs) {
+    return entry(path, 'exception', 'Interactive, deprecated, or local-environment-sensitive command that needs compensating contract evidence.', validationRefs, {
+        interactive: true,
+        exception: {
+            reason,
+            accepted_risk: acceptedRisk,
+            compensating_control: compensatingControl,
+            review_deadline: REVIEW_DEADLINE,
+        },
+    });
+}
+export const CLI_COMMAND_QUALITY_MATRIX = [
+    ...entries([
+        'init',
+        'reload',
+        'install',
+        'validate',
+        'sdd init',
+        'sdd insight',
+        'sdd debate',
+        'sdd decide',
+        'sdd breakdown',
+        'sdd aprovar',
+        'sdd start',
+        'sdd context',
+        'sdd execute-next',
+        'sdd frontend-impact',
+        'sdd finalize',
+        'sdd init-context',
+        'sdd rebuild',
+        'sdd metrics',
+        'sdd dedup',
+        'sdd lint feature',
+    ], 'spawned_e2e', 'Critical user-facing lifecycle or package-entrypoint command with spawned CLI coverage.', [
+        'test/helpers/run-cli.test.ts',
+        'test/cli-e2e/basic.test.ts',
+        'test/cli-e2e/critical-smoke.test.ts',
+        'test/e2e/full-lifecycle.test.ts',
+    ]),
+    ...entries([
+        'archive',
+        'change list',
+        'change show',
+        'change validate',
+        'completion generate',
+        'completion install',
+        'completion uninstall',
+        'config doctor',
+        'config get',
+        'config init',
+        'config list',
+        'config path',
+        'config redis bench',
+        'config redis flush-namespace',
+        'config redis ping',
+        'config redis status',
+        'config reset',
+        'config set',
+        'config unset',
+        'feedback',
+        'list',
+        'new change',
+        'schema fork',
+        'schema init',
+        'schema validate',
+        'schema which',
+        'schemas',
+        'show',
+        'spec list',
+        'spec show',
+        'spec validate',
+        'status',
+        'templates',
+        'update',
+    ], 'in_process', 'Command behavior is covered by focused command or core tests, with universal spawned help smoke covering the bin entrypoint.', ['test/commands', 'test/core']),
+    ...entries([
+        '__complete',
+        'config profile',
+        'instructions',
+        'sdd audit',
+        'sdd check',
+        'sdd diagnose',
+        'sdd agent run',
+        'sdd fgap add',
+        'sdd fgap done',
+        'sdd fingerprint',
+        'sdd import-legacy-spec',
+        'sdd ingest-deposito',
+        'sdd mcp-call',
+        'sdd mcp-manifest',
+        'sdd migrate',
+        'sdd migrate-workspace',
+        'sdd next',
+        'sdd onboard',
+        'sdd plan-status',
+        'sdd preflight',
+        'sdd release-readiness',
+        'sdd intent-guard',
+        'sdd backlog project',
+        'sdd plugin devtrack-api scaffold-dry-run',
+        'sdd plugin inspect',
+        'sdd plugin plan',
+        'sdd sanitize rollback',
+        'sdd scan-naming',
+        'sdd skills bundles',
+        'sdd skills suggest',
+        'sdd skills sync',
+        'sdd skills usar',
+        'sdd upgrade-to-codesdd',
+    ], 'contract', 'Command has registration, service, or workflow contract coverage, with universal spawned help smoke covering the bin entrypoint.', ['test/commands/sdd-command.test.ts', 'test/core/sdd-operations.test.ts']),
+    exceptionEntry('experimental', 'Hidden deprecated alias retained only for backwards compatibility.', 'A packaging regression in the hidden alias may not be caught by critical-path spawned smoke tests.', 'Registration inventory keeps the alias visible, and init command coverage protects the underlying implementation.', ['src/cli/index.ts', 'test/cli-e2e/basic.test.ts']),
+    exceptionEntry('view', 'Interactive dashboard command depends on terminal UI behavior and is unsuitable for deterministic spawned CI coverage.', 'Terminal rendering regressions may require manual or future TUI-specific verification.', 'Keep command registration visible and cover the underlying view module with focused tests.', ['src/core/view.ts', 'test/core/view.test.ts']),
+    exceptionEntry('config edit', 'Launches the user editor and depends on local EDITOR behavior.', 'Editor launch behavior can vary by machine and shell configuration.', 'Config schema read/write operations are covered by non-editor config command tests.', ['test/commands/config.test.ts', 'test/core/config-schema.test.ts']),
+];
+export function commandQualityMatrixByPath(matrix = CLI_COMMAND_QUALITY_MATRIX) {
+    return new Map(matrix.map((item) => [item.path, item]));
+}
+export function validateCliCommandQualityMatrix(registeredLeafCommandPaths, matrix = CLI_COMMAND_QUALITY_MATRIX) {
+    const registered = new Set(registeredLeafCommandPaths);
+    const matrixPaths = matrix.map((item) => item.path);
+    const matrixPathSet = new Set(matrixPaths);
+    const duplicatePaths = matrixPaths
+        .filter((path, index) => matrixPaths.indexOf(path) !== index)
+        .sort();
+    const invalidEntries = matrix.flatMap((item) => {
+        const errors = [];
+        if (!item.path.trim())
+            errors.push('path is required');
+        if (!item.owner.trim())
+            errors.push('owner is required');
+        if (!item.rationale.trim())
+            errors.push('rationale is required');
+        if (item.validation_refs.length === 0)
+            errors.push('validation_refs must not be empty');
+        if (item.evidence_mode === 'exception') {
+            if (!item.exception) {
+                errors.push('exception details are required');
+            }
+            else {
+                if (!item.exception.reason.trim())
+                    errors.push('exception.reason is required');
+                if (!item.exception.accepted_risk.trim())
+                    errors.push('exception.accepted_risk is required');
+                if (!item.exception.compensating_control.trim()) {
+                    errors.push('exception.compensating_control is required');
+                }
+                if (!item.exception.review_deadline.trim())
+                    errors.push('exception.review_deadline is required');
+            }
+        }
+        return errors.map((error) => `${item.path}: ${error}`);
+    });
+    return {
+        missing: registeredLeafCommandPaths.filter((path) => !matrixPathSet.has(path)).sort(),
+        extra: matrixPaths.filter((path) => !registered.has(path)).sort(),
+        duplicate_paths: Array.from(new Set(duplicatePaths)),
+        invalid_entries: invalidEntries.sort(),
+    };
+}
+//# sourceMappingURL=cli-command-quality.js.map

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

@@ -6,7 +6,7 @@
 import type { ToolCommandAdapter } from '../types.js';
 /**
  * CoStrict adapter for command generation.
- * File path: .cospec/openspec/commands/opsx-<id>.md
+ * File path: .cospec/legacy-spec/commands/opsx-<id>.md
  * Frontmatter: description, argument-hint
  */
 export declare const costrictAdapter: ToolCommandAdapter;

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

@@ -6,13 +6,13 @@
 import path from 'path';
 /**
  * CoStrict adapter for command generation.
- * File path: .cospec/openspec/commands/opsx-<id>.md
+ * File path: .cospec/legacy-spec/commands/opsx-<id>.md
  * Frontmatter: description, argument-hint
  */
 export const costrictAdapter = {
     toolId: 'costrict',
     getFilePath(commandId) {
-        return path.join('.cospec', 'openspec', 'commands', `opsx-${commandId}.md`);
+        return path.join('.cospec', 'codesdd', 'commands', `opsx-${commandId}.md`);
     },
     formatFile(content) {
         return `---

package/dist/core/command-generation/types.d.ts

@@ -11,7 +11,7 @@
 export interface CommandContent {
     /** Command identifier (e.g., 'explore', 'apply', 'new') */
     id: string;
-    /** Human-readable name (e.g., 'OpenSpec Explore') */
+    /** Human-readable name (e.g., 'CodeSDD Explore') */
     name: string;
     /** Brief description of command purpose */
     description: string;

package/dist/core/completions/command-registry.d.ts

@@ -1,6 +1,6 @@
 import { CommandDefinition } from './types.js';
 /**
- * Registry of all OpenSpec CLI commands with their flags and metadata.
+ * Registry of all visible CodeSDD CLI commands with their flags and metadata.
  * This registry is used to generate shell completion scripts.
  */
 export declare const COMMAND_REGISTRY: CommandDefinition[];