@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/workspace-schemas.js

@@ -7,6 +7,78 @@ export const workspaceGateSchema = z.object({
     approved_by: z.string().optional(),
     note: z.string().optional(),
 });
+export const workspacePolicyRequirementSchema = z.object({
+    skill_id: z.string().min(1),
+    policy_pool_ref: z.string().min(1),
+    source_contract_ref: z.string().min(1),
+    enforcement: z.enum(['blocking', 'advisory']),
+    required_rule_refs: z.array(z.string().min(1)).default([]),
+    required_evidence: z.array(z.string().min(1)).default([]),
+});
+export const workspacePolicyInjectionSchema = z.object({
+    version: z.literal(1),
+    generated_from: z.literal('recommended_skills'),
+    required_policies: z.array(workspacePolicyRequirementSchema).default([]),
+});
+const workspacePercentSchema = z.number().min(0).max(100);
+export const workspaceValidationGateSchema = z.object({
+    name: z.string().min(1),
+    command: z.string().min(1),
+    expected: z.string().min(1),
+});
+export const workspaceExecutionStepSchema = z.object({
+    name: z.string().min(1),
+    command: z.string().min(1),
+    writes_state: z.boolean().default(false),
+    expected_state_writes: z.array(z.string().min(1)).default([]),
+});
+export const workspacePlanExecutionSchema = z
+    .object({
+    mode: z.enum(['single-feature', 'parallel-wave', 'chained-features']).default('single-feature'),
+    state_boundary_ref: z.literal('codesdd-canonical-sdd-state').default('codesdd-canonical-sdd-state'),
+    command_sequence: z.array(workspaceExecutionStepSchema).min(1),
+    allowed_state_writes: z.array(z.string().min(1)).default([]),
+    forbidden_state_writes: z.array(z.string().min(1)).default(['.codesdd/**', 'external-context/**']),
+    handoff_artifacts: z.array(z.string().min(1)).default([]),
+})
+    .default({
+    mode: 'single-feature',
+    state_boundary_ref: 'codesdd-canonical-sdd-state',
+    command_sequence: [
+        {
+            name: 'SDD check',
+            command: 'codesdd sdd check --render',
+            writes_state: false,
+            expected_state_writes: [],
+        },
+    ],
+    allowed_state_writes: [],
+    forbidden_state_writes: ['.codesdd/**', 'external-context/**'],
+    handoff_artifacts: [],
+});
+export const workspacePlanGovernanceSchema = z
+    .object({
+    state_boundary: z.literal('codesdd-canonical-sdd-state').default('codesdd-canonical-sdd-state'),
+    planning_artifacts: z.array(z.string().min(1)).min(1),
+    decision_refs: z.array(z.string().min(1)).default([]),
+    planned_state_writes: z.array(z.string().min(1)).default([]),
+    rollback_plan: z.string().min(20),
+    validation_gates: z.array(workspaceValidationGateSchema).min(1),
+})
+    .default({
+    state_boundary: 'codesdd-canonical-sdd-state',
+    planning_artifacts: ['.sdd/state/backlog.yaml'],
+    decision_refs: [],
+    planned_state_writes: [],
+    rollback_plan: 'Review and revert only the scoped CodeSDD feature workspace and state changes if validation fails.',
+    validation_gates: [
+        {
+            name: 'SDD check',
+            command: 'codesdd sdd check --render',
+            expected: 'CodeSDD state and generated views remain valid.',
+        },
+    ],
+});
 export const workspaceSpecSchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
@@ -39,6 +111,8 @@ export const workspaceSpecSchema = z.object({
 export const workspacePlanSchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
+    governance: workspacePlanGovernanceSchema,
+    execution_plan: workspacePlanExecutionSchema,
     architectural_impact: z.object({
         description: z.string(),
         affected_modules: z.array(z.string()),
@@ -52,8 +126,8 @@ export const workspacePlanSchema = z.object({
         change_type: z.string(),
     })),
     quality_strategy: z.object({
-        unit_target: z.number(),
-        integration_target: z.number(),
+        unit_target: workspacePercentSchema,
+        integration_target: workspacePercentSchema,
         approach: z.string(),
     }),
     suggested_skills: z.array(z.string()),
@@ -75,6 +149,7 @@ export const workspacePlanSchema = z.object({
         architecture_tree_ascii: z.string().optional(),
     })
         .optional(),
+    policy_injection: workspacePolicyInjectionSchema.optional(),
 });
 export const workspaceTaskSchema = z.object({
     id: z.string(),
@@ -93,8 +168,16 @@ export const workspaceTaskSchema = z.object({
 export const workspaceTasksSchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
+    policy_injection: workspacePolicyInjectionSchema.optional(),
     tasks: z.array(workspaceTaskSchema).min(5),
 });
+export const promptAssetPhaseSchema = z.enum(['preparation', 'implementation', 'testing', 'documentation', 'finalization']);
+export const promptAssetSchemaV1 = z.object({
+    id: z.string().min(1),
+    version: z.literal(1),
+    phase: promptAssetPhaseSchema,
+    outputs: z.array(z.string().min(1)).min(1),
+});
 export const workspaceChangelogSchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
@@ -134,13 +217,132 @@ export const workspaceTraceabilitySchema = z.object({
     }),
     requirements: z.array(workspaceTraceabilityRequirementSchema).default([]),
 });
+export const workspaceQualityLedgerAxisSchema = z.object({
+    raw_score: workspacePercentSchema,
+    weighted_score: workspacePercentSchema,
+    rationale: z.string().min(1),
+});
+export const workspaceQualityLedgerWeightsSchema = z
+    .object({
+    coverage: workspacePercentSchema.default(30),
+    traceability: workspacePercentSchema.default(20),
+    integrity: workspacePercentSchema.default(20),
+    naming: workspacePercentSchema.default(10),
+    token: workspacePercentSchema.default(20),
+})
+    .superRefine((weights, ctx) => {
+    const total = weights.coverage + weights.traceability + weights.integrity + weights.naming + weights.token;
+    if (total !== 100) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `q95_ledger.weights must total 100, got ${total}.`,
+        });
+    }
+});
+export const workspaceQualityLedgerSchema = z
+    .object({
+    threshold: workspacePercentSchema.default(95),
+    score: workspacePercentSchema.default(0),
+    status: z.enum(['pass', 'fail', 'pending']).default('pending'),
+    computed_at: z.string().default(''),
+    weights: workspaceQualityLedgerWeightsSchema.default({
+        coverage: 30,
+        traceability: 20,
+        integrity: 20,
+        naming: 10,
+        token: 20,
+    }),
+    axes: z
+        .object({
+        coverage: workspaceQualityLedgerAxisSchema,
+        traceability: workspaceQualityLedgerAxisSchema,
+        integrity: workspaceQualityLedgerAxisSchema,
+        naming: workspaceQualityLedgerAxisSchema,
+        token: workspaceQualityLedgerAxisSchema,
+    })
+        .default({
+        coverage: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        traceability: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        integrity: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        naming: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        token: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+    }),
+    next_best_action: z.string().default('Record missing evidence to raise the lowest weighted axis.'),
+})
+    .superRefine((ledger, ctx) => {
+    if (ledger.status === 'pass' && ledger.score < ledger.threshold) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['status'],
+            message: 'q95_ledger.status cannot be pass when score is below threshold.',
+        });
+    }
+});
+export const workspaceTokenTelemetrySchema = z.object({
+    mode: z.enum(['compact', 'standard', 'full']).optional(),
+    budget_chars: z.number().int().positive().optional(),
+    actual_chars: z.number().int().nonnegative().optional(),
+    efficiency_percent: workspacePercentSchema.optional(),
+    gate: z.enum(['pass', 'warn', 'fail']).default('pass'),
+    evidence_ref: z.string().min(1).optional(),
+    notes: z.string().optional(),
+});
+export const workspaceTokenBudgetGatesSchema = z.object({
+    max_context_chars: z.number().int().positive().optional(),
+    require_numeric_efficiency: z.boolean().default(true),
+    fail_below_percent: workspacePercentSchema.default(95),
+    telemetry: z.array(workspaceTokenTelemetrySchema).default([]),
+});
+export const workspaceRuntimePerformanceTelemetrySchema = z.object({
+    command: z.string().min(1),
+    metric: z.enum(['duration_ms', 'p95_ms', 'memory_mb', 'cpu_percent']).default('duration_ms'),
+    threshold: z.number().nonnegative().optional(),
+    actual: z.number().nonnegative().optional(),
+    gate: z.enum(['pass', 'warn', 'fail']).default('pass'),
+    evidence_ref: z.string().min(1).optional(),
+    notes: z.string().optional(),
+});
+export const workspaceFlakinessTelemetrySchema = z.object({
+    command: z.string().min(1),
+    attempts: z.number().int().positive().optional(),
+    failures: z.number().int().nonnegative().optional(),
+    failure_rate_percent: workspacePercentSchema.optional(),
+    gate: z.enum(['pass', 'warn', 'fail']).default('pass'),
+    evidence_ref: z.string().min(1).optional(),
+    notes: z.string().optional(),
+});
+export const workspaceRuntimeQualityGatesSchema = z.object({
+    mode: z.enum(['observe', 'enforce']).default('observe'),
+    performance: z.array(workspaceRuntimePerformanceTelemetrySchema).default([]),
+    flakiness: z.array(workspaceFlakinessTelemetrySchema).default([]),
+});
 export const workspaceQualitySchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
     coverage_targets: z.object({
-        unit: z.number(),
-        integration: z.number(),
-        modules: z.record(z.string(), z.number()).optional(),
+        unit: workspacePercentSchema,
+        integration: workspacePercentSchema,
+        modules: z.record(z.string(), workspacePercentSchema).optional(),
     }),
     validation_strategies: z.array(z.object({
         name: z.string(),
@@ -156,6 +358,7 @@ export const workspaceQualitySchema = z.object({
     skill_evidence: z
         .object({
         required_skill_ids: z.array(z.string()),
+        policy_requirements: z.array(workspacePolicyRequirementSchema).default([]),
         evidence: z.array(z.object({
             skill_id: z.string().min(1),
             note: z.string().min(10),
@@ -165,14 +368,25 @@ export const workspaceQualitySchema = z.object({
     })
         .default({
         required_skill_ids: [],
+        policy_requirements: [],
         evidence: [],
         verification_rule: 'No skill evidence required for this feature.',
     }),
+    policy_injection: workspacePolicyInjectionSchema.optional(),
     acceptance_matrix: z.array(z.object({
         criterion: z.string(),
         status: z.enum(['met', 'not_met', 'na']),
         evidence: z.string(),
     })),
+    requirement_validation_evidence_risk_matrix: z
+        .array(z.object({
+        requirement_ref: z.string().min(1),
+        validation_refs: z.array(z.string().min(1)).min(1),
+        evidence_refs: z.array(z.string().min(1)).min(1),
+        residual_risk: z.string().min(5),
+        risk_status: z.enum(['open', 'mitigated', 'accepted']).default('open'),
+    }))
+        .default([]),
     exceptions: z.array(z.object({
         scope: z.string(),
         reason: z.string(),
@@ -200,6 +414,57 @@ export const workspaceQualitySchema = z.object({
         notes: z.string().optional(),
     })
         .optional(),
+    token_budget_gates: workspaceTokenBudgetGatesSchema.default({
+        require_numeric_efficiency: true,
+        fail_below_percent: 95,
+        telemetry: [],
+    }),
+    runtime_quality_gates: workspaceRuntimeQualityGatesSchema.default({
+        mode: 'observe',
+        performance: [],
+        flakiness: [],
+    }),
+    q95_ledger: workspaceQualityLedgerSchema.default({
+        threshold: 95,
+        score: 0,
+        status: 'pending',
+        computed_at: '',
+        weights: {
+            coverage: 30,
+            traceability: 20,
+            integrity: 20,
+            naming: 10,
+            token: 20,
+        },
+        axes: {
+            coverage: {
+                raw_score: 0,
+                weighted_score: 0,
+                rationale: 'Computed during finalize.'
+            },
+            traceability: {
+                raw_score: 0,
+                weighted_score: 0,
+                rationale: 'Computed during finalize.'
+            },
+            integrity: {
+                raw_score: 0,
+                weighted_score: 0,
+                rationale: 'Computed during finalize.'
+            },
+            naming: {
+                raw_score: 0,
+                weighted_score: 0,
+                rationale: 'Computed during finalize.'
+            },
+            token: {
+                raw_score: 0,
+                weighted_score: 0,
+                rationale: 'Computed during finalize.'
+            },
+        },
+        next_best_action: 'Record missing evidence to raise the lowest weighted axis.',
+    }),
 });
 export const workspaceDocumentSchemas = {
     '1-spec.yaml': workspaceSpecSchema,
@@ -251,4 +516,19 @@ export function stringifyWorkspaceYamlDocument(fileName, value) {
     parseWorkspaceYamlDocument(fileName, serialized);
     return serialized;
 }
+export function parsePromptAssetYamlDocument(content) {
+    let parsed;
+    try {
+        parsed = parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new WorkspaceYamlError(`Prompt asset YAML parse failed: ${message}`);
+    }
+    const result = promptAssetSchemaV1.safeParse(parsed);
+    if (!result.success) {
+        throw new WorkspaceYamlError(`Prompt asset YAML schema validation failed: ${result.error.message}`);
+    }
+    return result.data;
+}
 //# sourceMappingURL=workspace-schemas.js.map

package/dist/core/sdd/write-manifest.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { RootResolver } from './root-resolver.js';
 import { loadProjectSddConfig, resolveSddPaths } from './state.js';
-import { parseWorkspaceYamlDocument, workspaceSchemaForFile } from './workspace-schemas.js';
+import { parsePromptAssetYamlDocument, parseWorkspaceYamlDocument, workspaceSchemaForFile } from './workspace-schemas.js';
 export class SddWritePolicyError extends Error {
     constructor(message) {
         super(message);
@@ -276,10 +276,13 @@ function validateTemplatesPath(operation, policyPath, segments, label) {
             return;
         throw policyError(label, operation, policyPath, 'templates root may only be created as a directory');
     }
-    if (segments.length === 2 && /\.(md|ya?ml)$/.test(segments[1]) && operation.type !== 'mkdir') {
+    if (segments.length === 2 && operation.type === 'delete' && segments[1].endsWith('.md')) {
         return;
     }
-    throw policyError(label, operation, policyPath, 'templates accepts .md/.yaml files directly under root');
+    if (segments.length === 2 && /\.ya?ml$/.test(segments[1]) && operation.type !== 'mkdir') {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'templates accepts YAML files directly under root; Markdown templates may only be deleted during cleanup');
 }
 function validateSkillsPath(operation, policyPath, segments, label) {
     if (segments.length === 1) {
@@ -315,10 +318,16 @@ function validatePromptsPath(operation, policyPath, segments, label) {
             return;
         throw policyError(label, operation, policyPath, 'prompts root may only be created as a directory');
     }
+    if (segments.length === 3 && segments[1] === 'assets' && segments[2].endsWith('.yaml') && operation.type !== 'mkdir') {
+        if (operation.type === 'write') {
+            validatePromptAssetYamlContent(operation.content, label, operation, policyPath);
+        }
+        return;
+    }
     if (segments.length === 2 && segments[1].endsWith('.md') && operation.type !== 'mkdir') {
         return;
     }
-    throw policyError(label, operation, policyPath, 'prompts accepts markdown files directly under root');
+    throw policyError(label, operation, policyPath, 'prompts accepts markdown files directly under root and YAML assets under prompts/assets/');
 }
 function validateSourcesPath(operation, policyPath, segments, label) {
     if (segments.length === 1) {
@@ -350,4 +359,13 @@ function validateWorkspaceYamlContent(content, fileName, label, operation, polic
         throw policyError(label, operation, policyPath, `workspace YAML schema validation failed: ${message}`);
     }
 }
+function validatePromptAssetYamlContent(content, label, operation, policyPath) {
+    try {
+        parsePromptAssetYamlDocument(content);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw policyError(label, operation, policyPath, `prompt asset YAML schema validation failed: ${message}`);
+    }
+}
 //# sourceMappingURL=write-manifest.js.map

package/dist/core/shared/skill-generation.d.ts

@@ -42,7 +42,7 @@ export declare function getCommandContents(workflowFilter?: readonly string[]):
  * Generates skill file content with YAML frontmatter.
  *
  * @param template - The skill template
- * @param generatedByVersion - The OpenSpec version to embed in the file
+ * @param generatedByVersion - The CodeSDD version to embed in the file
  * @param transformInstructions - Optional callback to transform the instructions content
  */
 export declare function generateSkillContent(template: SkillTemplate, generatedByVersion: string, transformInstructions?: (instructions: string) => string): string;

package/dist/core/shared/skill-generation.js

@@ -18,18 +18,18 @@ function ensurePtBrGuardrail(content) {
  */
 export function getSkillTemplates(workflowFilter) {
     const all = [
-        { template: getExploreSkillTemplate(), dirName: 'openspec-explore', workflowId: 'explore' },
-        { template: getNewChangeSkillTemplate(), dirName: 'openspec-new-change', workflowId: 'new' },
-        { template: getContinueChangeSkillTemplate(), dirName: 'openspec-continue-change', workflowId: 'continue' },
-        { template: getApplyChangeSkillTemplate(), dirName: 'openspec-apply-change', workflowId: 'apply' },
-        { template: getFfChangeSkillTemplate(), dirName: 'openspec-ff-change', workflowId: 'ff' },
-        { template: getSyncSpecsSkillTemplate(), dirName: 'openspec-sync-specs', workflowId: 'sync' },
-        { template: getArchiveChangeSkillTemplate(), dirName: 'openspec-archive-change', workflowId: 'archive' },
-        { template: getBulkArchiveChangeSkillTemplate(), dirName: 'openspec-bulk-archive-change', workflowId: 'bulk-archive' },
-        { template: getVerifyChangeSkillTemplate(), dirName: 'openspec-verify-change', workflowId: 'verify' },
-        { template: getOnboardSkillTemplate(), dirName: 'openspec-onboard', workflowId: 'onboard' },
-        { template: getOpsxProposeSkillTemplate(), dirName: 'openspec-propose', workflowId: 'propose' },
-        { template: getSddSkillTemplate(), dirName: 'openspec-sdd', workflowId: 'sdd' },
+        { template: getExploreSkillTemplate(), dirName: 'codesdd-explore', workflowId: 'explore' },
+        { template: getNewChangeSkillTemplate(), dirName: 'codesdd-new-change', workflowId: 'new' },
+        { template: getContinueChangeSkillTemplate(), dirName: 'codesdd-continue-change', workflowId: 'continue' },
+        { template: getApplyChangeSkillTemplate(), dirName: 'codesdd-apply-change', workflowId: 'apply' },
+        { template: getFfChangeSkillTemplate(), dirName: 'codesdd-ff-change', workflowId: 'ff' },
+        { template: getSyncSpecsSkillTemplate(), dirName: 'codesdd-sync-specs', workflowId: 'sync' },
+        { template: getArchiveChangeSkillTemplate(), dirName: 'codesdd-archive-change', workflowId: 'archive' },
+        { template: getBulkArchiveChangeSkillTemplate(), dirName: 'codesdd-bulk-archive-change', workflowId: 'bulk-archive' },
+        { template: getVerifyChangeSkillTemplate(), dirName: 'codesdd-verify-change', workflowId: 'verify' },
+        { template: getOnboardSkillTemplate(), dirName: 'codesdd-onboard', workflowId: 'onboard' },
+        { template: getOpsxProposeSkillTemplate(), dirName: 'codesdd-propose', workflowId: 'propose' },
+        { template: getSddSkillTemplate(), dirName: 'codesdd-sdd', workflowId: 'sdd' },
     ];
     if (!workflowFilter)
         return all;
@@ -81,7 +81,7 @@ export function getCommandContents(workflowFilter) {
  * Generates skill file content with YAML frontmatter.
  *
  * @param template - The skill template
- * @param generatedByVersion - The OpenSpec version to embed in the file
+ * @param generatedByVersion - The CodeSDD version to embed in the file
  * @param transformInstructions - Optional callback to transform the instructions content
  */
 export function generateSkillContent(template, generatedByVersion, transformInstructions) {
@@ -93,9 +93,9 @@ export function generateSkillContent(template, generatedByVersion, transformInst
 name: ${template.name}
 description: ${template.description}
 license: ${template.license || 'MIT'}
-compatibility: ${template.compatibility || 'Requires opensdd CLI.'}
+compatibility: ${template.compatibility || 'Requires codesdd CLI.'}
 metadata:
-  author: ${template.metadata?.author || 'openspec'}
+  author: ${template.metadata?.author || 'codesdd'}
   version: "${template.metadata?.version || '1.0'}"
   generatedBy: "${generatedByVersion}"
 ---

package/dist/core/shared/tool-detection.d.ts

@@ -4,12 +4,12 @@
  * Shared utilities for detecting tool configurations and version status.
  */
 /**
- * Names of skill directories created by openspec init.
+ * Names of skill directories created by codesdd init.
  */
-export declare const SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-apply-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change", "openspec-onboard", "openspec-propose"];
+export declare const SKILL_NAMES: readonly ["codesdd-explore", "codesdd-new-change", "codesdd-continue-change", "codesdd-apply-change", "codesdd-ff-change", "codesdd-sync-specs", "codesdd-archive-change", "codesdd-bulk-archive-change", "codesdd-verify-change", "codesdd-onboard", "codesdd-propose"];
 export type SkillName = (typeof SKILL_NAMES)[number];
 /**
- * IDs of command templates created by openspec init.
+ * IDs of command templates created by codesdd init.
  */
 export declare const COMMAND_IDS: readonly ["explore", "new", "continue", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard", "propose"];
 export type CommandId = (typeof COMMAND_IDS)[number];

package/dist/core/shared/tool-detection.js

@@ -7,23 +7,23 @@ import path from 'path';
 import * as fs from 'fs';
 import { AI_TOOLS } from '../config.js';
 /**
- * Names of skill directories created by openspec init.
+ * Names of skill directories created by codesdd init.
  */
 export const SKILL_NAMES = [
-    'openspec-explore',
-    'openspec-new-change',
-    'openspec-continue-change',
-    'openspec-apply-change',
-    'openspec-ff-change',
-    'openspec-sync-specs',
-    'openspec-archive-change',
-    'openspec-bulk-archive-change',
-    'openspec-verify-change',
-    'openspec-onboard',
-    'openspec-propose',
+    'codesdd-explore',
+    'codesdd-new-change',
+    'codesdd-continue-change',
+    'codesdd-apply-change',
+    'codesdd-ff-change',
+    'codesdd-sync-specs',
+    'codesdd-archive-change',
+    'codesdd-bulk-archive-change',
+    'codesdd-verify-change',
+    'codesdd-onboard',
+    'codesdd-propose',
 ];
 /**
- * IDs of command templates created by openspec init.
+ * IDs of command templates created by codesdd init.
  */
 export const COMMAND_IDS = [
     'explore',
@@ -92,7 +92,7 @@ export function extractGeneratedByVersion(skillFilePath) {
         // ---
         // ...
         // metadata:
-        //   author: openspec
+        //   author: codesdd
         //   version: "1.0"
         //   generatedBy: "0.23.0"
         // ---

package/dist/core/specs-apply.js

@@ -9,7 +9,7 @@ import path from 'path';
 import chalk from 'chalk';
 import { extractRequirementsSection, parseDeltaSpec, normalizeRequirementName, } from './parsers/requirement-blocks.js';
 import { Validator } from './validation/validator.js';
-import { resolveOpenSpecLiveSubpath } from './sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecLiveSubpath } from './sdd/services/legacy-capability.service.js';
 // -----------------------------------------------------------------------------
 // Public API
 // -----------------------------------------------------------------------------
@@ -264,7 +264,7 @@ export async function writeUpdatedSpec(update, rebuilt, counts) {
     await fs.mkdir(targetDir, { recursive: true });
     await fs.writeFile(update.target, rebuilt);
     const specName = path.basename(path.dirname(update.target));
-    console.log(`Applying changes to openspec/specs/${specName}/spec.md:`);
+    console.log(`Applying changes to legacy-spec/specs/${specName}/spec.md:`);
     if (counts.added)
         console.log(`  + ${counts.added} added`);
     if (counts.modified)
@@ -290,8 +290,8 @@ export function buildSpecSkeleton(specFolderName, changeName) {
  * @returns Result of the operation with counts
  */
 export async function applySpecs(projectRoot, changeName, options = {}) {
-    const changeDir = resolveOpenSpecLiveSubpath(projectRoot, 'changes', changeName);
-    const mainSpecsDir = resolveOpenSpecLiveSubpath(projectRoot, 'specs');
+    const changeDir = resolveLegacySpecLiveSubpath(projectRoot, 'changes', changeName);
+    const mainSpecsDir = resolveLegacySpecLiveSubpath(projectRoot, 'specs');
     // Verify change exists
     try {
         const stat = await fs.stat(changeDir);
@@ -344,7 +344,7 @@ export async function applySpecs(projectRoot, changeName, options = {}) {
             await fs.mkdir(targetDir, { recursive: true });
             await fs.writeFile(p.update.target, p.rebuilt);
             if (!options.silent) {
-                console.log(`Applying changes to openspec/specs/${capability}/spec.md:`);
+                console.log(`Applying changes to legacy-spec/specs/${capability}/spec.md:`);
                 if (p.counts.added)
                     console.log(`  + ${p.counts.added} added`);
                 if (p.counts.modified)
@@ -356,7 +356,7 @@ export async function applySpecs(projectRoot, changeName, options = {}) {
             }
         }
         else if (!options.silent) {
-            console.log(`Would apply changes to openspec/specs/${capability}/spec.md:`);
+            console.log(`Would apply changes to legacy-spec/specs/${capability}/spec.md:`);
             if (p.counts.added)
                 console.log(`  + ${p.counts.added} added`);
             if (p.counts.modified)

package/dist/core/templates/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Template exports for OpenSpec.
+ * Template exports for CodeSDD.
  *
  * The old config file templates (AGENTS.md, project.md, claude-template, etc.)
  * have been removed. The skill-based workflow uses skill-templates.ts directly.

package/dist/core/templates/index.js

@@ -1,5 +1,5 @@
 /**
- * Template exports for OpenSpec.
+ * Template exports for CodeSDD.
  *
  * The old config file templates (AGENTS.md, project.md, claude-template, etc.)
  * have been removed. The skill-based workflow uses skill-templates.ts directly.