@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/governance-schemas.d.ts

@@ -0,0 +1,245 @@
+import { z } from 'zod';
+export declare const insightFrontmatterSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    title_canonical: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        PLANNED: "PLANNED";
+        NEW: "NEW";
+        DEBATED: "DEBATED";
+        PROMOTED: "PROMOTED";
+        DROPPED: "DROPPED";
+        OPEN: "OPEN";
+        APPROVED: "APPROVED";
+        DISCARDED: "DISCARDED";
+        SUPERSEDED: "SUPERSEDED";
+        READY: "READY";
+        IN_PROGRESS: "IN_PROGRESS";
+        DONE: "DONE";
+        CANCELLED: "CANCELLED";
+    }>;
+    origin: z.ZodObject<{
+        type: z.ZodEnum<{
+            feature: "feature";
+            user_prompt: "user_prompt";
+            insight: "insight";
+            debate: "debate";
+            source_intake: "source_intake";
+        }>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    related_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    quality_contract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    artifact_type: z.ZodLiteral<"INS">;
+    id: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    motivation: z.ZodOptional<z.ZodString>;
+    initial_evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    temporal_context: z.ZodOptional<z.ZodString>;
+    suggested_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    promoted_to: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const debateFrontmatterSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    title_canonical: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        PLANNED: "PLANNED";
+        NEW: "NEW";
+        DEBATED: "DEBATED";
+        PROMOTED: "PROMOTED";
+        DROPPED: "DROPPED";
+        OPEN: "OPEN";
+        APPROVED: "APPROVED";
+        DISCARDED: "DISCARDED";
+        SUPERSEDED: "SUPERSEDED";
+        READY: "READY";
+        IN_PROGRESS: "IN_PROGRESS";
+        DONE: "DONE";
+        CANCELLED: "CANCELLED";
+    }>;
+    origin: z.ZodObject<{
+        type: z.ZodEnum<{
+            feature: "feature";
+            user_prompt: "user_prompt";
+            insight: "insight";
+            debate: "debate";
+            source_intake: "source_intake";
+        }>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    related_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    quality_contract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    artifact_type: z.ZodLiteral<"DEB">;
+    id: z.ZodString;
+    decision: z.ZodObject<{
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        criteria: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        scoring: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            criterion: z.ZodString;
+            weight: z.ZodNumber;
+            scores: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strict>>>;
+        mediator: z.ZodObject<{
+            choice: z.ZodString;
+            rationale: z.ZodString;
+            accepted_risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                risk: z.ZodString;
+                mitigation: z.ZodString;
+            }, z.core.$strict>>>;
+            reversal_conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        output: z.ZodEnum<{
+            APPROVED: "APPROVED";
+            DISCARDED: "DISCARDED";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const epicFrontmatterSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    title_canonical: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        PLANNED: "PLANNED";
+        NEW: "NEW";
+        DEBATED: "DEBATED";
+        PROMOTED: "PROMOTED";
+        DROPPED: "DROPPED";
+        OPEN: "OPEN";
+        APPROVED: "APPROVED";
+        DISCARDED: "DISCARDED";
+        SUPERSEDED: "SUPERSEDED";
+        READY: "READY";
+        IN_PROGRESS: "IN_PROGRESS";
+        DONE: "DONE";
+        CANCELLED: "CANCELLED";
+    }>;
+    origin: z.ZodObject<{
+        type: z.ZodEnum<{
+            feature: "feature";
+            user_prompt: "user_prompt";
+            insight: "insight";
+            debate: "debate";
+            source_intake: "source_intake";
+        }>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    related_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    quality_contract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    artifact_type: z.ZodLiteral<"EPIC">;
+    id: z.ZodString;
+    approved_summary: z.ZodString;
+    lock_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    produces: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    consumes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    breakdown_policy: z.ZodDefault<z.ZodEnum<{
+        flat: "flat";
+        graph: "graph";
+    }>>;
+}, z.core.$strict>;
+export declare const discardedFrontmatterSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    title_canonical: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        PLANNED: "PLANNED";
+        NEW: "NEW";
+        DEBATED: "DEBATED";
+        PROMOTED: "PROMOTED";
+        DROPPED: "DROPPED";
+        OPEN: "OPEN";
+        APPROVED: "APPROVED";
+        DISCARDED: "DISCARDED";
+        SUPERSEDED: "SUPERSEDED";
+        READY: "READY";
+        IN_PROGRESS: "IN_PROGRESS";
+        DONE: "DONE";
+        CANCELLED: "CANCELLED";
+    }>;
+    origin: z.ZodObject<{
+        type: z.ZodEnum<{
+            feature: "feature";
+            user_prompt: "user_prompt";
+            insight: "insight";
+            debate: "debate";
+            source_intake: "source_intake";
+        }>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    related_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    quality_contract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    artifact_type: z.ZodLiteral<"Discarded">;
+    id: z.ZodString;
+    discarded_from: z.ZodString;
+    discard_reason: z.ZodString;
+    discarded_at: z.ZodString;
+    discarded_by: z.ZodString;
+}, z.core.$strict>;
+export declare const adrFrontmatterSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    title_canonical: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        PLANNED: "PLANNED";
+        NEW: "NEW";
+        DEBATED: "DEBATED";
+        PROMOTED: "PROMOTED";
+        DROPPED: "DROPPED";
+        OPEN: "OPEN";
+        APPROVED: "APPROVED";
+        DISCARDED: "DISCARDED";
+        SUPERSEDED: "SUPERSEDED";
+        READY: "READY";
+        IN_PROGRESS: "IN_PROGRESS";
+        DONE: "DONE";
+        CANCELLED: "CANCELLED";
+    }>;
+    origin: z.ZodObject<{
+        type: z.ZodEnum<{
+            feature: "feature";
+            user_prompt: "user_prompt";
+            insight: "insight";
+            debate: "debate";
+            source_intake: "source_intake";
+        }>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    related_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    quality_contract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    artifact_type: z.ZodLiteral<"ADR">;
+    id: z.ZodString;
+    feature_id: z.ZodString;
+    decision_status: z.ZodDefault<z.ZodEnum<{
+        SUPERSEDED: "SUPERSEDED";
+        PROPOSED: "PROPOSED";
+        ACCEPTED: "ACCEPTED";
+    }>>;
+    supersedes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    superseded_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type InsightFrontmatter = z.infer<typeof insightFrontmatterSchema>;
+export type DebateFrontmatter = z.infer<typeof debateFrontmatterSchema>;
+export type EpicFrontmatter = z.infer<typeof epicFrontmatterSchema>;
+export type DiscardedFrontmatter = z.infer<typeof discardedFrontmatterSchema>;
+export type AdrFrontmatter = z.infer<typeof adrFrontmatterSchema>;
+export declare function parseInsightFrontmatter(value: unknown): InsightFrontmatter;
+export declare function parseDebateFrontmatter(value: unknown): DebateFrontmatter;
+export declare function parseEpicFrontmatter(value: unknown): EpicFrontmatter;
+export declare function parseDiscardedFrontmatter(value: unknown): DiscardedFrontmatter;
+export declare function parseAdrFrontmatter(value: unknown): AdrFrontmatter;
+//# sourceMappingURL=governance-schemas.d.ts.map

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

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+const governanceStatusSchema = z.enum([
+    'NEW',
+    'OPEN',
+    'DEBATED',
+    'PROMOTED',
+    'DROPPED',
+    'APPROVED',
+    'DISCARDED',
+    'SUPERSEDED',
+    'READY',
+    'PLANNED',
+    'IN_PROGRESS',
+    'DONE',
+    'CANCELLED',
+]);
+const governanceOriginSchema = z
+    .object({
+    type: z.enum(['user_prompt', 'insight', 'debate', 'feature', 'source_intake']),
+    ref: z.string().min(1).optional(),
+})
+    .strict();
+const governanceCommonSchema = z
+    .object({
+    schema_version: z.literal(1),
+    id: z.string().regex(/^[A-Z]+(?:-[A-Z]+)?-\d{3,4}$/),
+    title: z.string().min(1),
+    title_canonical: z.string().min(1).optional(),
+    status: governanceStatusSchema,
+    origin: governanceOriginSchema,
+    related_ids: z.array(z.string().min(1)).default([]),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+    quality_contract: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+export const insightFrontmatterSchema = governanceCommonSchema
+    .extend({
+    artifact_type: z.literal('INS'),
+    id: z.string().regex(/^INS-\d{4}$/),
+    source: z.string().min(1).optional(),
+    motivation: z.string().min(1).optional(),
+    initial_evidence: z.array(z.string().min(1)).optional(),
+    temporal_context: z.string().min(1).optional(),
+    suggested_agents: z.array(z.string().min(1)).optional(),
+    promoted_to: z.string().min(1).optional(),
+})
+    .strict();
+const debateOptionSchema = z
+    .object({
+    id: z.string().regex(/^[A-Z]$/),
+    label: z.string().min(1),
+})
+    .strict();
+const debateScoringSchema = z
+    .object({
+    criterion: z.string().min(1),
+    weight: z.number(),
+    scores: z.record(z.string().regex(/^[A-Z]$/), z.number()),
+})
+    .strict();
+const debateAcceptedRiskSchema = z
+    .object({
+    risk: z.string().min(1),
+    mitigation: z.string().min(1),
+})
+    .strict();
+const debateDecisionSchema = z
+    .object({
+    question: z.string().min(1),
+    options: z.array(debateOptionSchema).min(1),
+    criteria: z.array(z.string().min(1)).default([]),
+    scoring: z.array(debateScoringSchema).default([]),
+    mediator: z
+        .object({
+        choice: z.string().regex(/^[A-Z]$/),
+        rationale: z.string().min(1),
+        accepted_risks: z.array(debateAcceptedRiskSchema).default([]),
+        reversal_conditions: z.array(z.string().min(1)).default([]),
+    })
+        .strict(),
+    output: z.enum(['APPROVED', 'DISCARDED']),
+})
+    .strict();
+export const debateFrontmatterSchema = governanceCommonSchema
+    .extend({
+    artifact_type: z.literal('DEB'),
+    id: z.string().regex(/^DEB-\d{4}$/),
+    decision: debateDecisionSchema,
+})
+    .strict();
+export const epicFrontmatterSchema = governanceCommonSchema
+    .extend({
+    artifact_type: z.literal('EPIC'),
+    id: z.string().regex(/^EPIC-\d{4}$/),
+    approved_summary: z.string().min(1),
+    lock_domains: z.array(z.string().min(1)).default([]),
+    produces: z.array(z.string().min(1)).default([]),
+    consumes: z.array(z.string().min(1)).default([]),
+    breakdown_policy: z.enum(['graph', 'flat']).default('graph'),
+})
+    .strict();
+export const discardedFrontmatterSchema = governanceCommonSchema
+    .extend({
+    artifact_type: z.literal('Discarded'),
+    id: z.string().regex(/^DEB-\d{4}$/),
+    discarded_from: z.string().regex(/^DEB-\d{4}$/),
+    discard_reason: z.string().min(1),
+    discarded_at: z.string().datetime(),
+    discarded_by: z.string().min(1),
+})
+    .strict()
+    .refine((value) => value.id === value.discarded_from, {
+    message: 'Discarded artifact id must match discarded_from',
+    path: ['id'],
+});
+export const adrFrontmatterSchema = governanceCommonSchema
+    .extend({
+    artifact_type: z.literal('ADR'),
+    id: z.string().regex(/^ADR-FEAT-\d{3,4}$/),
+    feature_id: z.string().regex(/^FEAT-\d{3,4}$/),
+    decision_status: z.enum(['PROPOSED', 'ACCEPTED', 'SUPERSEDED']).default('PROPOSED'),
+    supersedes: z.array(z.string().regex(/^ADR-FEAT-\d{3,4}$/)).default([]),
+    superseded_by: z.array(z.string().regex(/^ADR-FEAT-\d{3,4}$/)).default([]),
+    references: z.array(z.string().min(1)).default([]),
+})
+    .strict();
+export function parseInsightFrontmatter(value) {
+    return insightFrontmatterSchema.parse(value);
+}
+export function parseDebateFrontmatter(value) {
+    return debateFrontmatterSchema.parse(value);
+}
+export function parseEpicFrontmatter(value) {
+    return epicFrontmatterSchema.parse(value);
+}
+export function parseDiscardedFrontmatter(value) {
+    return discardedFrontmatterSchema.parse(value);
+}
+export function parseAdrFrontmatter(value) {
+    return adrFrontmatterSchema.parse(value);
+}
+//# sourceMappingURL=governance-schemas.js.map

package/dist/core/sdd/{import-openspec.d.ts → import-legacy-spec.d.ts}

@@ -1,10 +1,10 @@
-export interface SddImportOpenSpecOptions {
+export interface SddImportLegacySpecOptions {
     dryRun?: boolean;
     remove?: boolean;
     yes?: boolean;
     render?: boolean;
 }
-export interface ImportedOpenSpecFile {
+export interface ImportedLegacySpecFile {
     source_path: string;
     target_path: string;
     sha256: string;
@@ -12,7 +12,7 @@ export interface ImportedOpenSpecFile {
     category: string;
     indexed_source_id: string;
 }
-export interface SddImportOpenSpecResult {
+export interface SddImportLegacySpecResult {
     project_root: string;
     source_root: string;
     target_root: string;
@@ -23,9 +23,9 @@ export interface SddImportOpenSpecResult {
     files_copied: number;
     sources_indexed: number;
     categories: Record<string, number>;
-    files: ImportedOpenSpecFile[];
+    files: ImportedLegacySpecFile[];
 }
-export declare class SddImportOpenSpecCommand {
-    execute(projectRoot: string, options?: SddImportOpenSpecOptions): Promise<SddImportOpenSpecResult>;
+export declare class SddImportLegacySpecCommand {
+    execute(projectRoot: string, options?: SddImportLegacySpecOptions): Promise<SddImportLegacySpecResult>;
 }
-//# sourceMappingURL=import-openspec.d.ts.map
+//# sourceMappingURL=import-legacy-spec.d.ts.map

package/dist/core/sdd/{import-openspec.js → import-legacy-spec.js}

@@ -5,7 +5,7 @@ import { stringify as stringifyYaml } from 'yaml';
 import { loadProjectSddConfig, loadStateSnapshot, resolveSddPaths, saveSourceIndexState, } from './state.js';
 import { renderViews } from './views.js';
 import { nextSourceId } from './legacy-operations.js';
-import { OPENSPEC_LEGACY_CAPABILITY, resolveLegacyCapabilityImportedDepositoRoot, resolveLegacyCapabilityLiveRoot, } from './services/legacy-capability.service.js';
+import { LEGACY_SPEC_CAPABILITY, resolveLegacyCapabilityImportedDepositoRoot, resolveLegacyCapabilityLiveRoot, } from './services/legacy-capability.service.js';
 async function pathExists(filePath) {
     try {
         await fs.access(filePath);
@@ -41,7 +41,7 @@ async function sha256(filePath) {
 function normalizePath(value) {
     return value.replace(/\\/g, '/');
 }
-function categoryForOpenSpecPath(relativePath) {
+function categoryForLegacySpecPath(relativePath) {
     const normalized = normalizePath(relativePath).toLowerCase();
     if (normalized.startsWith('specs/'))
         return 'spec';
@@ -58,22 +58,22 @@ function categoryForOpenSpecPath(relativePath) {
     }
     return 'other';
 }
-function titleFromOpenSpecPath(relativePath) {
+function titleFromLegacySpecPath(relativePath) {
     const normalized = normalizePath(relativePath);
     const parts = normalized.split('/');
     const meaningful = parts.length >= 2 ? parts.slice(0, -1).join(' / ') : normalized;
-    return `Legacy spec corpus: ${meaningful || normalized}`;
+    return `Legacy spec corpus: ${meaningful}`;
 }
 function targetRelativePath(relativePath) {
     return normalizePath(relativePath);
 }
-export class SddImportOpenSpecCommand {
+export class SddImportLegacySpecCommand {
     async execute(projectRoot, options = {}) {
         const config = await loadProjectSddConfig(projectRoot);
         const paths = resolveSddPaths(projectRoot, config);
-        const sourceRoot = resolveLegacyCapabilityLiveRoot(projectRoot, OPENSPEC_LEGACY_CAPABILITY);
-        const targetRoot = resolveLegacyCapabilityImportedDepositoRoot(paths.depositoDir, OPENSPEC_LEGACY_CAPABILITY);
-        const reportPath = path.join(targetRoot, '_codesdd-import-report.yaml');
+        const sourceRoot = resolveLegacyCapabilityLiveRoot(projectRoot, LEGACY_SPEC_CAPABILITY);
+        const targetRoot = resolveLegacyCapabilityImportedDepositoRoot(paths.depositoDir, LEGACY_SPEC_CAPABILITY);
+        const reportPath = path.join(targetRoot, '_legacy-spec-import-report.yaml');
         const dryRun = options.dryRun ?? false;
         if (!(await pathExists(sourceRoot))) {
             return {
@@ -91,7 +91,7 @@ export class SddImportOpenSpecCommand {
             };
         }
         if (options.remove && !options.yes) {
-            throw new Error('Refusing to remove openspec/. Re-run with --remove --yes after reviewing the import report.');
+            throw new Error('Refusing to remove legacy-spec/. Re-run with --remove --yes after reviewing the import report.');
         }
         const absoluteFiles = await listFiles(sourceRoot);
         const snapshot = await loadStateSnapshot(paths, config);
@@ -102,10 +102,10 @@ export class SddImportOpenSpecCommand {
         let filesCopied = 0;
         let sourcesIndexed = 0;
         for (const absoluteSource of absoluteFiles) {
-            const relativeOpenSpec = normalizePath(path.relative(sourceRoot, absoluteSource));
-            const relativeTarget = targetRelativePath(relativeOpenSpec);
+            const relativeLegacySpec = normalizePath(path.relative(sourceRoot, absoluteSource));
+            const relativeTarget = targetRelativePath(relativeLegacySpec);
             const absoluteTarget = path.join(targetRoot, relativeTarget);
-            const category = categoryForOpenSpecPath(relativeOpenSpec);
+            const category = categoryForLegacySpecPath(relativeLegacySpec);
             const sourceHash = await sha256(absoluteSource);
             const indexedPath = normalizePath(path.relative(projectRoot, absoluteTarget));
             const now = new Date().toISOString();
@@ -116,7 +116,7 @@ export class SddImportOpenSpecCommand {
                     id: nextSourceId(sourceIndex.sources.map((source) => source.id)),
                     type: 'legado',
                     path: indexedPath,
-                    title: titleFromOpenSpecPath(relativeOpenSpec),
+                    title: titleFromLegacySpecPath(relativeLegacySpec),
                     status: 'INDEXED',
                     source_version: 1,
                     source_fingerprint: sourceHash.hash,
@@ -128,7 +128,7 @@ export class SddImportOpenSpecCommand {
                     verification_status: 'verified',
                     verification_notes: 'Imported from repository-local legacy spec corpus.',
                     legal_validation_required: false,
-                    summary: `Imported from legacy-spec/${relativeOpenSpec}`,
+                    summary: `Imported from legacy-spec/${relativeLegacySpec}`,
                     imported_at: now,
                     updated_at: now,
                     used_by: [],
@@ -142,30 +142,22 @@ export class SddImportOpenSpecCommand {
             }
             sourceRecord.type = 'legado';
             sourceRecord.status = 'INDEXED';
-            sourceRecord.source_version = sourceRecord.source_version || 1;
             sourceRecord.source_fingerprint = sourceHash.hash;
-            sourceRecord.authority = sourceRecord.authority || 'internal';
-            sourceRecord.source_url = sourceRecord.source_url || '';
-            sourceRecord.source_classification = sourceRecord.source_classification || 'technical_best_practice';
-            sourceRecord.jurisdiction_tags = Array.isArray(sourceRecord.jurisdiction_tags)
-                ? sourceRecord.jurisdiction_tags
-                : [];
             sourceRecord.last_verified_at = sourceRecord.last_verified_at || now.slice(0, 10);
-            sourceRecord.verification_status = sourceRecord.verification_status || 'verified';
             sourceRecord.verification_notes =
                 sourceRecord.verification_notes || 'Imported from repository-local legacy spec corpus.';
             sourceRecord.legal_validation_required = Boolean(sourceRecord.legal_validation_required);
-            sourceRecord.summary = `Imported from legacy-spec/${relativeOpenSpec}`;
+            sourceRecord.summary = `Imported from legacy-spec/${relativeLegacySpec}`;
             sourceRecord.updated_at = now;
             sourceRecord.notes = Array.from(new Set([
-                ...sourceRecord.notes.filter((note) => !note.startsWith('openspec-import:') && !note.startsWith('legacy-spec-import:')),
-                `legacy-spec-import:source=legacy-spec/${relativeOpenSpec}`,
+                ...sourceRecord.notes.filter((note) => !note.startsWith('legacy-spec-import:')),
+                `legacy-spec-import:source=legacy-spec/${relativeLegacySpec}`,
                 `legacy-spec-import:category=${category}`,
                 `legacy-spec-import:sha256=${sourceHash.hash}`,
                 `legacy-spec-import:bytes=${sourceHash.bytes}`,
             ]));
             sourceRecord.consolidation_targets = Array.from(new Set([
-                ...sourceRecord.consolidation_targets.filter((target) => target !== 'legacy-openspec-import' && target !== 'legacy-spec-corpus-import'),
+                ...sourceRecord.consolidation_targets.filter((target) => target !== 'legacy-spec-corpus-import'),
                 'source-index',
                 'legacy-spec-corpus-import',
                 category,
@@ -175,12 +167,12 @@ export class SddImportOpenSpecCommand {
                 await fs.copyFile(absoluteSource, absoluteTarget);
                 const copiedHash = await sha256(absoluteTarget);
                 if (copiedHash.hash !== sourceHash.hash) {
-                    throw new Error(`OpenSpec import checksum mismatch for ${relativeOpenSpec}`);
+                    throw new Error(`Legacy spec import checksum mismatch for ${relativeLegacySpec}`);
                 }
                 filesCopied += 1;
             }
             imported.push({
-                source_path: `legacy-spec/${relativeOpenSpec}`,
+                source_path: `legacy-spec/${relativeLegacySpec}`,
                 target_path: indexedPath,
                 sha256: sourceHash.hash,
                 bytes: sourceHash.bytes,
@@ -229,4 +221,4 @@ export class SddImportOpenSpecCommand {
         };
     }
 }
-//# sourceMappingURL=import-openspec.js.map
+//# sourceMappingURL=import-legacy-spec.js.map

package/dist/core/sdd/init.d.ts

@@ -20,6 +20,9 @@ export interface SddInitContextOptions {
     mode?: 'merge' | 'replace';
     deep?: boolean;
     render?: boolean;
+    frontendEnabled?: boolean;
+    language?: SddLanguage;
+    layout?: SddLayout;
 }
 export interface SddInitContextResult {
     projectRoot: string;

package/dist/core/sdd/init.js

@@ -1,4 +1,4 @@
-import { loadProjectSddConfig, loadStateSnapshot, ensureBaseFiles, ensureBaseStructure, resolveSddPaths, upsertProjectSddConfig, } from './state.js';
+import { loadStateSnapshot, ensureBaseFiles, ensureBaseStructure, resolveSddPaths, upsertProjectSddConfig, } from './state.js';
 import { renderViews } from './views.js';
 import { syncSddGuideDocs } from './docs-sync.js';
 import { bootstrapInitialContext } from './bootstrap.js';
@@ -39,9 +39,12 @@ export class SddInitCommand {
 }
 export class SddInitContextCommand {
     async execute(projectRoot, options = {}) {
-        const config = await loadProjectSddConfig(projectRoot);
+        const config = await upsertProjectSddConfig(projectRoot, {
+            frontendEnabled: options.frontendEnabled,
+            language: options.language,
+            layout: options.layout,
+        });
         const paths = resolveSddPaths(projectRoot, config);
-        const stores = createSddStores(paths);
         await ensureBaseStructure(paths);
         await ensureBaseFiles(paths, config);
         const sddBootstrap = await bootstrapInitialContext(projectRoot, paths, config, {

package/dist/core/sdd/intent-guard.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const sddIntentGuardInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    featureRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const sddIntentGuardResultSchema: z.ZodObject<{
+    request: z.ZodString;
+    classification: z.ZodEnum<{
+        change_request: "change_request";
+        read_only: "read_only";
+        outside_codesdd: "outside_codesdd";
+    }>;
+    requires_codesdd_planning: z.ZodBoolean;
+    feature_ref: z.ZodOptional<z.ZodString>;
+    reason: z.ZodString;
+    required_commands: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SddIntentGuardInput = z.input<typeof sddIntentGuardInputSchema>;
+export type SddIntentGuardResult = z.infer<typeof sddIntentGuardResultSchema>;
+export declare function evaluateSddIntentGuard(input: SddIntentGuardInput): SddIntentGuardResult;
+//# sourceMappingURL=intent-guard.d.ts.map