@devtrack-solution/codesdd 1.2.3 → 1.2.4

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

@@ -20,6 +20,65 @@ export const workspacePolicyInjectionSchema = z.object({
     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,
@@ -52,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()),
@@ -65,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()),
@@ -156,25 +217,165 @@ 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 workspaceCriticalEvidenceProvenanceSchema = z.object({
+    command: z.string().min(1),
+    exit_code: z.number().int(),
+    timestamp_iso: z.string().datetime(),
+    commit_sha: z.string().regex(/^[0-9a-f]{7,40}$/i),
+    artifact_path: z.string().min(1),
+    artifact_hash: z.string().min(1),
+});
+export const workspaceEvidenceLogEntrySchema = z
+    .object({
+    timestamp: z.string(),
+    kind: z.string(),
+    result: z.string(),
+    artifact: z.string().optional(),
+    critical: z.boolean().optional(),
+    provenance: workspaceCriticalEvidenceProvenanceSchema.optional(),
+})
+    .superRefine((entry, ctx) => {
+    if (entry.critical === true && !entry.provenance) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['provenance'],
+            message: 'critical evidence entries must include provenance with command, exit_code, timestamp_iso, commit_sha, artifact_path, and artifact_hash.',
+        });
+    }
+});
 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(),
         command: z.string(),
         expected: z.string(),
     })),
-    evidence_log: z.array(z.object({
-        timestamp: z.string(),
-        kind: z.string(),
-        result: z.string(),
-        artifact: z.string().optional(),
-    })),
+    evidence_log: z.array(workspaceEvidenceLogEntrySchema),
     skill_evidence: z
         .object({
         required_skill_ids: z.array(z.string()),
@@ -234,65 +435,17 @@ export const workspaceQualitySchema = z.object({
         notes: z.string().optional(),
     })
         .optional(),
-    q95_ledger: z
-        .object({
-        threshold: z.number().default(95),
-        score: z.number().default(0),
-        status: z.enum(['pass', 'fail', 'pending']).default('pending'),
-        computed_at: z.string().default(''),
-        weights: z
-            .object({
-            coverage: z.number().default(30),
-            traceability: z.number().default(20),
-            integrity: z.number().default(20),
-            naming: z.number().default(10),
-            token: z.number().default(20),
-        })
-            .default({
-            coverage: 30,
-            traceability: 20,
-            integrity: 20,
-            naming: 10,
-            token: 20,
-        }),
-        axes: z
-            .object({
-            coverage: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            traceability: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            integrity: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            naming: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            token: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-        })
-            .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.'),
-    })
-        .default({
+    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',

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

@@ -5,6 +5,8 @@
  */
 import { getOpsxExploreCommandTemplate, type SkillTemplate } from '../templates/skill-templates.js';
 import type { CommandContent } from '../command-generation/index.js';
+export declare const CODESDD_CANONICAL_LLM_ANNOUNCE_HEADING = "## CodeSDD Canonical Workflow";
+export declare const CODESDD_CANONICAL_LLM_ANNOUNCE = "## CodeSDD Canonical Workflow\n\n- In projects with `.sdd/`, treat CodeSDD SDD commands as the canonical lifecycle.\n- Start new work with `codesdd sdd insight \"describe the change or initiative\"`; then use `codesdd sdd debate`, `codesdd sdd decide`, `codesdd sdd breakdown`, `codesdd sdd next`, `codesdd sdd start`, `codesdd sdd context`, `codesdd sdd finalize`, and `codesdd sdd check --render` as state requires.\n- Use `codesdd sdd init-context` as the default project capability bootstrap/repair entrypoint. Use `codesdd install --tools <tool>` only to generate or refresh agent assets after project context exists.\n- OPSX slash prompts are compatibility surfaces for legacy workflows. Do not present them as the first or preferred path when `.sdd/` exists, even if generated prompt files still mention `/opsx:*` or tool-specific `/opsx-*`.\n- When older project instructions conflict with this announcement, trust `.sdd/state/*.yaml`, current CLI output, and the repository's CodeSDD governance files.";
 /**
  * Skill template with directory name and workflow ID mapping.
  */

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

@@ -5,12 +5,29 @@
  */
 import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getOpsxProposeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, getOpsxOnboardCommandTemplate, getOpsxProposeCommandTemplate, getSddSkillTemplate, getOpsxSddCommandTemplate, } from '../templates/skill-templates.js';
 const PT_BR_GUARDRAIL = '**Idioma obrigatorio:** responda em portugues do Brasil (pt-BR), salvo solicitacao explicita em outro idioma.';
+export const CODESDD_CANONICAL_LLM_ANNOUNCE_HEADING = '## CodeSDD Canonical Workflow';
+export const CODESDD_CANONICAL_LLM_ANNOUNCE = `${CODESDD_CANONICAL_LLM_ANNOUNCE_HEADING}
+
+- In projects with \`.sdd/\`, treat CodeSDD SDD commands as the canonical lifecycle.
+- Start new work with \`codesdd sdd insight "describe the change or initiative"\`; then use \`codesdd sdd debate\`, \`codesdd sdd decide\`, \`codesdd sdd breakdown\`, \`codesdd sdd next\`, \`codesdd sdd start\`, \`codesdd sdd context\`, \`codesdd sdd finalize\`, and \`codesdd sdd check --render\` as state requires.
+- Use \`codesdd sdd init-context\` as the default project capability bootstrap/repair entrypoint. Use \`codesdd install --tools <tool>\` only to generate or refresh agent assets after project context exists.
+- OPSX slash prompts are compatibility surfaces for legacy workflows. Do not present them as the first or preferred path when \`.sdd/\` exists, even if generated prompt files still mention \`/opsx:*\` or tool-specific \`/opsx-*\`.
+- When older project instructions conflict with this announcement, trust \`.sdd/state/*.yaml\`, current CLI output, and the repository's CodeSDD governance files.`;
 function ensurePtBrGuardrail(content) {
     if (content.toLowerCase().includes('idioma obrigatorio')) {
         return content;
     }
     return `${PT_BR_GUARDRAIL}\n\n${content}`;
 }
+function ensureCanonicalLlmAnnounce(content) {
+    if (content.includes(CODESDD_CANONICAL_LLM_ANNOUNCE_HEADING)) {
+        return content;
+    }
+    return `${CODESDD_CANONICAL_LLM_ANNOUNCE}\n\n${content}`;
+}
+function prepareGeneratedAgentInstructions(content) {
+    return ensureCanonicalLlmAnnounce(ensurePtBrGuardrail(content));
+}
 /**
  * Gets skill templates with their directory names, optionally filtered by workflow IDs.
  *
@@ -74,7 +91,7 @@ export function getCommandContents(workflowFilter) {
         description: template.description,
         category: template.category,
         tags: template.tags,
-        body: ensurePtBrGuardrail(template.content),
+        body: prepareGeneratedAgentInstructions(template.content),
     }));
 }
 /**
@@ -88,7 +105,7 @@ export function generateSkillContent(template, generatedByVersion, transformInst
     const transformedInstructions = transformInstructions
         ? transformInstructions(template.instructions)
         : template.instructions;
-    const instructions = ensurePtBrGuardrail(transformedInstructions);
+    const instructions = prepareGeneratedAgentInstructions(transformedInstructions);
     return `---
 name: ${template.name}
 description: ${template.description}

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

@@ -39,6 +39,24 @@ export interface ToolVersionStatus {
     /** Whether the tool needs updating (version mismatch or missing) */
     needsUpdate: boolean;
 }
+export interface GeneratedInstructionDriftEntry {
+    toolId: string;
+    toolName: string;
+    kind: 'skill' | 'command';
+    path: string;
+    issue: 'missing_canonical_announcement';
+}
+export interface GeneratedInstructionDriftReport {
+    schema_version: 1;
+    status: 'not_configured' | 'clean' | 'stale';
+    checked_count: number;
+    stale_count: number;
+    canonical_heading: string;
+    compatibility_warning: string;
+    stale_files: GeneratedInstructionDriftEntry[];
+    warnings: string[];
+    next_action: string;
+}
 /**
  * Gets the list of tools with skillsDir configured.
  */
@@ -68,4 +86,5 @@ export declare function getConfiguredTools(projectRoot: string): string[];
  * Gets version status for all configured tools.
  */
 export declare function getAllToolVersionStatus(projectRoot: string, currentVersion: string): ToolVersionStatus[];
+export declare function buildGeneratedInstructionDriftReport(projectRoot: string): GeneratedInstructionDriftReport;
 //# sourceMappingURL=tool-detection.d.ts.map

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

@@ -6,6 +6,8 @@
 import path from 'path';
 import * as fs from 'fs';
 import { AI_TOOLS } from '../config.js';
+import { CommandAdapterRegistry } from '../command-generation/registry.js';
+import { CODESDD_CANONICAL_LLM_ANNOUNCE_HEADING } from './skill-generation.js';
 /**
  * Names of skill directories created by codesdd init.
  */
@@ -155,4 +157,91 @@ export function getAllToolVersionStatus(projectRoot, currentVersion) {
     const configuredTools = getConfiguredTools(projectRoot);
     return configuredTools.map((toolId) => getToolVersionStatus(projectRoot, toolId, currentVersion));
 }
+function formatInstructionPath(projectRoot, filePath) {
+    if (!path.isAbsolute(filePath)) {
+        return filePath;
+    }
+    const relative = path.relative(projectRoot, filePath);
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+        return relative;
+    }
+    return filePath;
+}
+function inspectGeneratedInstructionFile(projectRoot, toolId, toolName, kind, filePath) {
+    if (!fs.existsSync(filePath)) {
+        return { checked: false };
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const checked = true;
+        if (content.includes(CODESDD_CANONICAL_LLM_ANNOUNCE_HEADING)) {
+            return { checked };
+        }
+        return {
+            checked,
+            stale: {
+                toolId,
+                toolName,
+                kind,
+                path: formatInstructionPath(projectRoot, filePath),
+                issue: 'missing_canonical_announcement',
+            },
+        };
+    }
+    catch {
+        return { checked: false };
+    }
+}
+export function buildGeneratedInstructionDriftReport(projectRoot) {
+    const staleFiles = [];
+    let checkedCount = 0;
+    for (const tool of AI_TOOLS.filter((item) => item.skillsDir)) {
+        if (!tool.skillsDir)
+            continue;
+        const skillStatus = getToolSkillStatus(projectRoot, tool.value);
+        const skillsDir = path.join(projectRoot, tool.skillsDir, 'skills');
+        for (const skillName of SKILL_NAMES) {
+            const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
+            const result = inspectGeneratedInstructionFile(projectRoot, tool.value, tool.name, 'skill', skillFile);
+            if (result.checked)
+                checkedCount++;
+            if (result.stale)
+                staleFiles.push(result.stale);
+        }
+        const adapter = CommandAdapterRegistry.get(tool.value);
+        if (!adapter)
+            continue;
+        for (const commandId of COMMAND_IDS) {
+            const adapterPath = adapter.getFilePath(commandId);
+            if (path.isAbsolute(adapterPath) && !skillStatus.configured) {
+                continue;
+            }
+            const commandFile = path.isAbsolute(adapterPath) ? adapterPath : path.join(projectRoot, adapterPath);
+            const result = inspectGeneratedInstructionFile(projectRoot, tool.value, tool.name, 'command', commandFile);
+            if (result.checked)
+                checkedCount++;
+            if (result.stale)
+                staleFiles.push(result.stale);
+        }
+    }
+    const staleCount = staleFiles.length;
+    const status = checkedCount === 0 ? 'not_configured' : staleCount > 0 ? 'stale' : 'clean';
+    const warnings = staleCount > 0
+        ? [
+            `${staleCount} generated CodeSDD instruction file(s) are missing the canonical LLM announcement.`,
+            'Regenerate instructions with `codesdd update` or rerun `codesdd install --tools <tool>` for the affected tools.',
+        ]
+        : [];
+    return {
+        schema_version: 1,
+        status,
+        checked_count: checkedCount,
+        stale_count: staleCount,
+        canonical_heading: CODESDD_CANONICAL_LLM_ANNOUNCE_HEADING,
+        compatibility_warning: 'OPSX slash prompts are compatibility surfaces; prefer CodeSDD SDD commands when .sdd/ exists.',
+        stale_files: staleFiles,
+        warnings,
+        next_action: staleCount > 0 ? 'codesdd update' : 'none',
+    };
+}
 //# sourceMappingURL=tool-detection.js.map

package/dist/domains/sdd/index.d.ts

@@ -0,0 +1,6 @@
+export { buildFeatureTitle, computeCanonicalTitle, markdownInsightTemplate, slugify, stripFunctionalTitlePrefixes, } from '../../core/sdd/domain/helpers.js';
+export { evaluateFeatureFinalizeGuardrails, evaluateFeatureStartGuardrails, type FeatureFinalizeGuardrails, type FeatureStartGuardrails, type LifecycleDependencyCheck, type LifecycleLockCheck, } from '../../core/sdd/domain/lifecycle-guardrails.js';
+export { clearLifecycleHooks, registerLifecycleHook, runLifecycleHooks, unregisterLifecycleHook, type LifecycleHook, type LifecycleHookContext, type LifecycleHookEvent, } from '../../core/sdd/domain/lifecycle-hooks.js';
+export { TransitionEngine, type EntityStatus } from '../../core/sdd/domain/transition-engine.js';
+export { evaluateWorkspaceTraceability } from '../../core/sdd/domain/traceability.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domains/sdd/index.js

@@ -0,0 +1,6 @@
+export { buildFeatureTitle, computeCanonicalTitle, markdownInsightTemplate, slugify, stripFunctionalTitlePrefixes, } from '../../core/sdd/domain/helpers.js';
+export { evaluateFeatureFinalizeGuardrails, evaluateFeatureStartGuardrails, } from '../../core/sdd/domain/lifecycle-guardrails.js';
+export { clearLifecycleHooks, registerLifecycleHook, runLifecycleHooks, unregisterLifecycleHook, } from '../../core/sdd/domain/lifecycle-hooks.js';
+export { TransitionEngine } from '../../core/sdd/domain/transition-engine.js';
+export { evaluateWorkspaceTraceability } from '../../core/sdd/domain/traceability.js';
+//# sourceMappingURL=index.js.map

package/dist/infrastructures/sdd/index.d.ts

@@ -0,0 +1,7 @@
+export { FileSystemLockAdapter, InMemoryCoordinationCache, InMemoryCoordinationEventBus, InMemoryCoordinationQueue, MultiTierCoordinationCache, createFilesystemFirstCoordinationAdapters, type CoordinationCacheAdapter, type CoordinationEvent, type CoordinationEventBusAdapter, type CoordinationLockAdapter, type CoordinationQueueAdapter, type SddCoordinationAdapters, } from '../../core/sdd/coordination/coordination-adapters.js';
+export { RedisClientFactory, RedisCoordinationCache, RedisEventBusAdapter, RedisLockAdapter, RedisQueueAdapter, RedisWorkDeduper, buildRedisKey, hashRedisKey, redactRedisUrl, resolveRedisBoundaryConfig, resolveRedisRuntimeConfig, sanitizeRedisError, type RedisOperationalReport, type RedisRuntimeConfig, type RedisRuntimeStatus, } from '../../core/sdd/coordination/redis-runtime.js';
+export { InMemoryAdapter } from '../../core/sdd/store/in-memory-adapter.js';
+export { YamlFileAdapter } from '../../core/sdd/store/yaml-file-adapter.js';
+export { createInMemorySddStores, createSddStores, type SddStores } from '../../core/sdd/store/sdd-stores.js';
+export type { StateStore } from '../../core/sdd/store/state-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/infrastructures/sdd/index.js

@@ -0,0 +1,6 @@
+export { FileSystemLockAdapter, InMemoryCoordinationCache, InMemoryCoordinationEventBus, InMemoryCoordinationQueue, MultiTierCoordinationCache, createFilesystemFirstCoordinationAdapters, } from '../../core/sdd/coordination/coordination-adapters.js';
+export { RedisClientFactory, RedisCoordinationCache, RedisEventBusAdapter, RedisLockAdapter, RedisQueueAdapter, RedisWorkDeduper, buildRedisKey, hashRedisKey, redactRedisUrl, resolveRedisBoundaryConfig, resolveRedisRuntimeConfig, sanitizeRedisError, } from '../../core/sdd/coordination/redis-runtime.js';
+export { InMemoryAdapter } from '../../core/sdd/store/in-memory-adapter.js';
+export { YamlFileAdapter } from '../../core/sdd/store/yaml-file-adapter.js';
+export { createInMemorySddStores, createSddStores } from '../../core/sdd/store/sdd-stores.js';
+//# sourceMappingURL=index.js.map

package/dist/presentations/cli/sdd/index.d.ts

@@ -0,0 +1,3 @@
+export { registerSddCommand } from '../../../commands/sdd.js';
+export { registerPluginCommands } from '../../../commands/sdd/plugin.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/presentations/cli/sdd/index.js

@@ -0,0 +1,3 @@
+export { registerSddCommand } from '../../../commands/sdd.js';
+export { registerPluginCommands } from '../../../commands/sdd/plugin.js';
+//# sourceMappingURL=index.js.map

package/dist/shared/sdd/index.d.ts

@@ -0,0 +1,3 @@
+export type { BacklogItem, BacklogState, DiscoveryIndexState, DiscoveryRecord, FinalizeQueueState, FrontendGapsState, FrontendMapState, RepoMapState, ServiceCatalogState, TransitionLogState, } from '../../core/sdd/types.js';
+export { stringifyWorkspaceYamlDocument, workspaceDocumentSchemas, workspaceSchemaForFile, type WorkspaceChangelogDocument, type WorkspaceDocumentFileName, type WorkspacePlanDocument, type WorkspaceQualityDocument, type WorkspaceSpecDocument, type WorkspaceTasksDocument, } from '../../core/sdd/workspace-schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/sdd/index.js

@@ -0,0 +1,2 @@
+export { stringifyWorkspaceYamlDocument, workspaceDocumentSchemas, workspaceSchemaForFile, } from '../../core/sdd/workspace-schemas.js';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devtrack-solution/codesdd",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "codesdd",
@@ -22,7 +22,8 @@
   "type": "module",
   "packageManager": "pnpm@10.33.2",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "pnpm": {
     "overrides": {
@@ -64,15 +65,15 @@
     "build": "node build.js",
     "dev": "tsc --watch",
     "dev:cli": "pnpm build && node bin/codesdd.js",
-    "test": "vitest run",
+    "test": "vitest run --silent=passed-only",
     "test:watch": "vitest",
-    "test:e2e": "vitest run test/e2e test/cli-e2e",
+    "test:e2e": "vitest run test/e2e test/cli-e2e --silent=passed-only",
     "test:deepagents-smoke": "vitest run test/e2e/deepagents-agent-run-smoke.test.ts",
     "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage",
-    "coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage --silent=passed-only",
+    "coverage": "vitest run --coverage --silent=passed-only",
     "quality": "pnpm run cleanup:install && pnpm run build && pnpm run lint && pnpm run test && pnpm run test:e2e && pnpm run coverage",
-    "quality:review": "pnpm run build && pnpm run lint && pnpm run test && pnpm run test:e2e && pnpm run coverage && pnpm run sdd:validate && pnpm run check:pack-version",
+    "quality:review": "pnpm run build && pnpm run lint && pnpm run test && pnpm run test:e2e && pnpm run coverage && pnpm run sdd:validate && pnpm run check:pack-version && node bin/codesdd.js sdd check --render --strict",
     "prepublishOnly": "node build.js",
     "prepare": "node scripts/install-git-hooks.mjs",
     "check:pack-version": "node scripts/pack-version-check.mjs",
@@ -80,11 +81,13 @@
     "sdd:schema:check": "node scripts/export-sdd-schemas.mjs --check",
     "sdd:scan-naming": "node bin/codesdd.js sdd scan-naming",
     "sdd:scan-naming:strict": "node bin/codesdd.js sdd scan-naming --strict",
+    "sdd:service-catalog:maturity": "node scripts/audit-service-catalog-maturity.mjs",
     "sdd:precommit:fast": "node scripts/pre-commit-sdd-fast.mjs",
     "sdd:validate:no-build": "node bin/codesdd.js sdd check --render --strict && node bin/codesdd.js sdd diagnose --strict && node bin/codesdd.js sdd scan-naming",
     "sdd:validate": "pnpm run build && pnpm run sdd:schema:check && pnpm run sdd:validate:no-build",
     "release": "pnpm run release:ci",
     "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
+    "release:sbom": "npm sbom --sbom-format cyclonedx",
     "changeset": "changeset"
   },
   "engines": {
@@ -94,13 +97,13 @@
     "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.31.0",
     "@mermaid-js/mermaid-cli": "^11.15.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
+    "@vitest/coverage-v8": "^4.1.8",
+    "@vitest/ui": "^4.1.8",
     "eslint": "^10.4.0",
     "puppeteer": "24.43.1",
     "ts-morph": "^28.0.0",
     "typescript-eslint": "^8.59.4",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.8"
   },
   "dependencies": {
     "@inquirer/core": "^11.1.10",
@@ -114,6 +117,7 @@
     "fast-glob": "^3.3.3",
     "ora": "^9.4.0",
     "posthog-node": "^5.35.1",
+    "redis": "^6.0.0",
     "typescript": "^6.0.3",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"