@devtrack-solution/codesdd 1.2.4-rc3 → 1.2.4

package/dist/core/sdd/services/historical-quality-regression.service.js

@@ -0,0 +1,228 @@
+import { existsSync, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { parseWorkspaceYamlDocument } from '../workspace-schemas.js';
+const PLACEHOLDER_PATTERNS = [
+    /\(fill in/i,
+    /\(placeholder/i,
+    /\btodo\b/i,
+    /\btbd\b/i,
+    /\bpending\b/i,
+    /\bmust implement\b/i,
+    /\bto be executed\b/i,
+    /\bplanned\b/i,
+    /\bwill be\b/i,
+    /\bto do\b/i,
+];
+const DEFAULT_RECENT_WINDOW_SIZE = 25;
+const DEFAULT_GRANDFATHER_MAX_FEAT = 451;
+function featNumericId(featureId) {
+    const match = featureId.match(/^FEAT-(\d{4,})$/);
+    if (!match)
+        return null;
+    return Number.parseInt(match[1] || '', 10);
+}
+function hasPlaceholderSignal(text) {
+    return PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(text));
+}
+function hasPlaceholderEvidence(document) {
+    const evidenceTexts = [
+        ...document.evidence_log.flatMap((entry) => [entry.kind, entry.result, entry.artifact ?? '']),
+        ...document.acceptance_matrix.flatMap((entry) => [entry.criterion, entry.evidence]),
+    ];
+    return evidenceTexts.some((text) => text && hasPlaceholderSignal(text));
+}
+function sortFeaturesByRecency(featureIds) {
+    return [...featureIds].sort((left, right) => {
+        const leftNum = featNumericId(left);
+        const rightNum = featNumericId(right);
+        if (leftNum !== null && rightNum !== null && leftNum !== rightNum) {
+            return rightNum - leftNum;
+        }
+        if (leftNum !== null && rightNum === null)
+            return -1;
+        if (leftNum === null && rightNum !== null)
+            return 1;
+        return right.localeCompare(left);
+    });
+}
+async function loadBacklogEvidence(backlogPath) {
+    const map = new Map();
+    if (!existsSync(backlogPath))
+        return map;
+    const raw = await fs.readFile(backlogPath, 'utf-8').catch(() => '');
+    if (!raw.trim())
+        return map;
+    const parsed = parseYaml(raw);
+    for (const item of parsed.items ?? []) {
+        const id = typeof item.id === 'string' ? item.id : '';
+        if (!id.startsWith('FEAT-'))
+            continue;
+        map.set(id, {
+            id,
+            status: typeof item.status === 'string' ? item.status : undefined,
+            frontend_impact_status: typeof item.frontend_impact_status === 'string' ? item.frontend_impact_status : undefined,
+            done_at: typeof item.done_at === 'string' ? item.done_at : undefined,
+            archived_at: typeof item.archived_at === 'string' ? item.archived_at : undefined,
+        });
+    }
+    return map;
+}
+export class HistoricalQualityRegressionService {
+    async execute(projectRoot, options = {}) {
+        const mode = options.mode ?? 'recent-window';
+        const recentWindowSize = options.recentWindowSize ?? DEFAULT_RECENT_WINDOW_SIZE;
+        const grandfatherMaxFeat = options.grandfatherMaxFeat ?? DEFAULT_GRANDFATHER_MAX_FEAT;
+        const archivedDir = path.join(projectRoot, '.sdd', 'archived');
+        const backlogPath = path.join(projectRoot, '.sdd', 'state', 'backlog.yaml');
+        const adrsDir = path.join(projectRoot, '.sdd', 'core', 'adrs');
+        const backlogByFeature = await loadBacklogEvidence(backlogPath);
+        if (!existsSync(archivedDir)) {
+            return {
+                generated_at: new Date().toISOString(),
+                mode,
+                recent_window_size: mode === 'recent-window' ? recentWindowSize : null,
+                scanned: 0,
+                considered: 0,
+                analyzed: 0,
+                grandfathered: 0,
+                issue_count: 0,
+                grandfathering: {
+                    enabled: true,
+                    max_feat_id: grandfatherMaxFeat,
+                    policy: `Skip blocking regression checks for archived FEAT ids <= FEAT-${String(grandfatherMaxFeat).padStart(4, '0')}.`,
+                },
+                issues: [],
+            };
+        }
+        const entries = await fs.readdir(archivedDir, { withFileTypes: true });
+        const scannedFeatures = entries
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith('FEAT-'))
+            .map((entry) => entry.name);
+        const orderedFeatures = sortFeaturesByRecency(scannedFeatures);
+        const consideredFeatures = mode === 'recent-window' ? orderedFeatures.slice(0, Math.max(1, recentWindowSize)) : orderedFeatures;
+        let analyzed = 0;
+        let grandfathered = 0;
+        const issues = [];
+        for (const featureId of consideredFeatures) {
+            const numericId = featNumericId(featureId);
+            if (numericId !== null && numericId <= grandfatherMaxFeat) {
+                grandfathered += 1;
+                continue;
+            }
+            const backlog = backlogByFeature.get(featureId);
+            const qualityPath = path.join(archivedDir, featureId, '5-quality.yaml');
+            const adrPath = path.join(adrsDir, `ADR-${featureId}.md`);
+            if (!backlog) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'STATE_CORE_DIVERGENCE',
+                    message: `${featureId} is archived but missing from .sdd/state/backlog.yaml.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && backlog.status && !['DONE', 'ARCHIVED'].includes(backlog.status)) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'STATE_CORE_DIVERGENCE',
+                    message: `${featureId} is archived on disk but backlog status is ${backlog.status}.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && (backlog.frontend_impact_status ?? 'unknown') === 'unknown') {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'FRONTEND_IMPACT_UNKNOWN',
+                    message: `${featureId} has frontend_impact_status=unknown in backlog state.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && !backlog.done_at) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'MISSING_DONE_AT',
+                    message: `${featureId} is archived without done_at in backlog state.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && !backlog.archived_at) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'MISSING_ARCHIVED_AT',
+                    message: `${featureId} is archived without archived_at in backlog state.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (!existsSync(adrPath)) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'MISSING_ADR',
+                    message: `${featureId} is missing required ADR file at .sdd/core/adrs/ADR-${featureId}.md.`,
+                    adr_path: adrPath,
+                });
+                issues.push({
+                    feature_id: featureId,
+                    code: 'STATE_CORE_DIVERGENCE',
+                    message: `${featureId} has no ADR in .sdd/core/adrs while archived state exists.`,
+                    adr_path: adrPath,
+                });
+            }
+            if (!existsSync(qualityPath)) {
+                continue;
+            }
+            const rawQuality = await fs.readFile(qualityPath, 'utf-8').catch(() => '');
+            if (!rawQuality.trim()) {
+                continue;
+            }
+            let quality;
+            try {
+                quality = parseWorkspaceYamlDocument('5-quality.yaml', rawQuality);
+            }
+            catch {
+                continue;
+            }
+            analyzed += 1;
+            if (quality.acceptance_matrix.some((entry) => entry.status === 'not_met')) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'ACCEPTANCE_NOT_MET',
+                    message: `${featureId} contains acceptance_matrix.status=not_met in archived quality evidence.`,
+                    quality_path: qualityPath,
+                });
+            }
+            if (quality.requirement_validation_evidence_risk_matrix.some((entry) => entry.risk_status === 'open')) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'OPEN_RISK',
+                    message: `${featureId} contains requirement risk_status=open in archived quality evidence.`,
+                    quality_path: qualityPath,
+                });
+            }
+            if (hasPlaceholderEvidence(quality)) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'PLACEHOLDER_EVIDENCE',
+                    message: `${featureId} still includes placeholder or future-tense evidence markers.`,
+                    quality_path: qualityPath,
+                });
+            }
+        }
+        return {
+            generated_at: new Date().toISOString(),
+            mode,
+            recent_window_size: mode === 'recent-window' ? recentWindowSize : null,
+            scanned: orderedFeatures.length,
+            considered: consideredFeatures.length,
+            analyzed,
+            grandfathered,
+            issue_count: issues.length,
+            grandfathering: {
+                enabled: true,
+                max_feat_id: grandfatherMaxFeat,
+                policy: `Skip blocking regression checks for archived FEAT ids <= FEAT-${String(grandfatherMaxFeat).padStart(4, '0')}.`,
+            },
+            issues,
+        };
+    }
+}
+//# sourceMappingURL=historical-quality-regression.service.js.map

package/dist/core/sdd/services/ingest-deposito.service.js

@@ -224,7 +224,7 @@ export class IngestDepositoService {
                 'frontend-extractor-sdd',
                 'planning-normalizer-sdd',
             ],
-            recommended_prompt: relProjectPath(paths, path.join(paths.promptsDir, '01-ingestao-deposito.md')),
+            recommended_prompt: relProjectPath(paths, path.join(paths.promptsDir, config.layout === 'en-US' ? '01-source-intake.md' : '01-ingestao-deposito.md')),
         };
     }
 }

package/dist/core/sdd/services/planning-execution-coherence.service.d.ts

@@ -0,0 +1,45 @@
+import { type WorkspaceChangelogDocument, type WorkspacePlanDocument, type WorkspaceQualityDocument, type WorkspaceSpecDocument, type WorkspaceTasksDocument } from '../workspace-schemas.js';
+export type PlanningExecutionCoherenceIssueCode = 'MISSING_FILE_EVIDENCE' | 'MISSING_COMMAND_EVIDENCE' | 'ACCEPTANCE_NOT_MET' | 'RISK_STATUS_OPEN' | 'ADR_MISSING';
+export interface PlanningExecutionCoherenceIssue {
+    code: PlanningExecutionCoherenceIssueCode;
+    severity: 'error' | 'warning';
+    message: string;
+    evidence: Record<string, unknown>;
+}
+export interface PlanningExecutionCoherenceReport {
+    schema_version: 1;
+    feature_id: string;
+    generated_at: string;
+    workspace_path: string;
+    adr_path: string;
+    healthy: boolean;
+    planned: {
+        files: string[];
+        commands: string[];
+    };
+    execution: {
+        files: string[];
+        commands: string[];
+    };
+    issues: PlanningExecutionCoherenceIssue[];
+}
+export interface EvaluatePlanningExecutionCoherenceInput {
+    featureId: string;
+    workspacePath: string;
+    adrPath: string;
+    adrExists: boolean;
+    spec: WorkspaceSpecDocument;
+    plan: WorkspacePlanDocument;
+    tasks: WorkspaceTasksDocument;
+    changelog: WorkspaceChangelogDocument;
+    quality: WorkspaceQualityDocument;
+    changedFiles: string[];
+}
+export interface PlanningExecutionCoherenceOptions {
+    changedFiles?: string[];
+}
+export declare function evaluatePlanningExecutionCoherence(input: EvaluatePlanningExecutionCoherenceInput): PlanningExecutionCoherenceReport;
+export declare class PlanningExecutionCoherenceService {
+    execute(projectRoot: string, featureId: string, options?: PlanningExecutionCoherenceOptions): Promise<PlanningExecutionCoherenceReport>;
+}
+//# sourceMappingURL=planning-execution-coherence.service.d.ts.map

package/dist/core/sdd/services/planning-execution-coherence.service.js

@@ -0,0 +1,225 @@
+import path from 'node:path';
+import { existsSync, promises as fs } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { activeDocNamesForLayout, ensureMemoryInitialized, relProjectPath } from '../legacy-operations.js';
+import { loadProjectSddConfig, resolveSddPaths } from '../state.js';
+import { parseWorkspaceYamlDocument, } from '../workspace-schemas.js';
+const execFileAsync = promisify(execFile);
+function uniqueSorted(values) {
+    return Array.from(new Set(values.filter(Boolean))).sort((a, b) => a.localeCompare(b));
+}
+function normalizeCommand(value) {
+    return value.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+function normalizePathForCoherence(value) {
+    const normalized = value.replace(/\\/g, '/').trim();
+    return normalized.replace(/\.sdd\/(planned|active|archived)\/(FEAT-\d{4})\//, '.sdd/*/$2/');
+}
+function pathCovered(plannedPath, evidencePaths) {
+    const planned = normalizePathForCoherence(plannedPath);
+    return evidencePaths.some((candidate) => {
+        const normalizedCandidate = normalizePathForCoherence(candidate);
+        return (normalizedCandidate === planned ||
+            normalizedCandidate.endsWith(`/${planned}`) ||
+            planned.endsWith(`/${normalizedCandidate}`));
+    });
+}
+function collectPlannedFiles(plan, tasks, quality) {
+    const includePath = (value) => {
+        const normalized = value.replace(/\\/g, '/');
+        if (normalized.startsWith('.sdd/state/'))
+            return false;
+        if (normalized.startsWith('.sdd/archived/'))
+            return false;
+        return true;
+    };
+    return uniqueSorted([
+        ...plan.execution_plan.command_sequence.flatMap((step) => step.expected_state_writes.filter(includePath)),
+        ...tasks.tasks
+            .filter((task) => task.phase !== 'finalization')
+            .flatMap((task) => task.files_touched.filter(includePath)),
+        ...quality.traceability.requirements.flatMap((req) => req.code_refs.map((ref) => ref.path)),
+    ]);
+}
+function collectPlannedCommands(plan, tasks, quality) {
+    return uniqueSorted([
+        ...plan.governance.validation_gates.map((gate) => gate.command),
+        ...tasks.tasks.flatMap((task) => task.test_scripts.map((script) => script.command)),
+        ...quality.validation_strategies.map((strategy) => strategy.command),
+    ]).map(normalizeCommand);
+}
+function collectExecutionFiles(quality, changelog, changedFiles) {
+    const changelogRefs = changelog.entries.flatMap((entry) => entry.refs);
+    return uniqueSorted([
+        ...changedFiles,
+        ...quality.evidence_log.map((entry) => entry.artifact ?? '').filter(Boolean),
+        ...quality.traceability.requirements.flatMap((req) => req.evidence_refs),
+        ...changelogRefs,
+    ]);
+}
+function collectExecutionCommands(quality) {
+    return uniqueSorted(quality.evidence_log
+        .map((entry) => entry.provenance?.command ?? '')
+        .filter(Boolean)
+        .map(normalizeCommand));
+}
+function expectsAdr(spec, tasks) {
+    const corpus = [spec.objective, spec.expected_outcome, ...tasks.tasks.map((task) => `${task.title} ${task.description}`)]
+        .join(' ')
+        .toLowerCase();
+    return corpus.includes('adr');
+}
+export function evaluatePlanningExecutionCoherence(input) {
+    const plannedFiles = collectPlannedFiles(input.plan, input.tasks, input.quality);
+    const plannedCommands = collectPlannedCommands(input.plan, input.tasks, input.quality);
+    const executionFiles = collectExecutionFiles(input.quality, input.changelog, input.changedFiles);
+    const executionCommands = collectExecutionCommands(input.quality);
+    const issues = [];
+    const missingFiles = plannedFiles.filter((plannedFile) => !pathCovered(plannedFile, executionFiles));
+    if (missingFiles.length > 0) {
+        issues.push({
+            code: 'MISSING_FILE_EVIDENCE',
+            severity: 'error',
+            message: 'Planned files are not reflected in diff/evidence artifacts.',
+            evidence: {
+                missing_files: missingFiles,
+            },
+        });
+    }
+    const missingCommands = plannedCommands.filter((command) => !executionCommands.includes(command));
+    if (missingCommands.length > 0) {
+        issues.push({
+            code: 'MISSING_COMMAND_EVIDENCE',
+            severity: 'warning',
+            message: 'Planned validation commands are missing from evidence provenance.',
+            evidence: {
+                missing_commands: missingCommands,
+            },
+        });
+    }
+    const notMetAcceptance = input.quality.acceptance_matrix.filter((entry) => entry.status === 'not_met');
+    if (notMetAcceptance.length > 0) {
+        issues.push({
+            code: 'ACCEPTANCE_NOT_MET',
+            severity: 'error',
+            message: 'Quality acceptance matrix still has not_met criteria.',
+            evidence: {
+                criteria: notMetAcceptance.map((entry) => entry.criterion),
+            },
+        });
+    }
+    const openRisks = input.quality.requirement_validation_evidence_risk_matrix.filter((entry) => entry.risk_status === 'open');
+    if (openRisks.length > 0) {
+        issues.push({
+            code: 'RISK_STATUS_OPEN',
+            severity: 'warning',
+            message: 'Requirement risk matrix still has open risk entries.',
+            evidence: {
+                requirements: openRisks.map((entry) => entry.requirement_ref),
+            },
+        });
+    }
+    if (expectsAdr(input.spec, input.tasks) && !input.adrExists) {
+        issues.push({
+            code: 'ADR_MISSING',
+            severity: 'error',
+            message: 'Planning requires ADR coherence but ADR file is missing.',
+            evidence: {
+                expected_adr: input.adrPath,
+            },
+        });
+    }
+    const healthy = !issues.some((issue) => issue.severity === 'error');
+    return {
+        schema_version: 1,
+        feature_id: input.featureId,
+        generated_at: new Date().toISOString(),
+        workspace_path: input.workspacePath,
+        adr_path: input.adrPath,
+        healthy,
+        planned: {
+            files: plannedFiles,
+            commands: plannedCommands,
+        },
+        execution: {
+            files: executionFiles,
+            commands: executionCommands,
+        },
+        issues,
+    };
+}
+async function listChangedFiles(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['status', '--porcelain'], {
+            cwd: projectRoot,
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        return uniqueSorted(stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => line.slice(3).trim())
+            .map((line) => (line.includes('->') ? line.split('->').pop() ?? line : line))
+            .map((line) => line.trim())
+            .filter(Boolean));
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveWorkspacePath(projectRoot, featureId) {
+    const config = await loadProjectSddConfig(projectRoot);
+    const paths = resolveSddPaths(projectRoot, config);
+    await ensureMemoryInitialized(paths);
+    const roots = [paths.activeDir, paths.plannedDir, paths.archivedDir];
+    for (const root of roots) {
+        const workspacePath = path.join(root, featureId);
+        if (existsSync(workspacePath)) {
+            return {
+                workspacePath,
+                adrPath: path.join(paths.coreDir, 'adrs', `ADR-${featureId}.md`),
+            };
+        }
+    }
+    throw new Error(`Workspace not found for ${featureId}.`);
+}
+export class PlanningExecutionCoherenceService {
+    async execute(projectRoot, featureId, options = {}) {
+        if (!/^FEAT-\d{4}$/.test(featureId)) {
+            throw new Error('Invalid feature id. Use FEAT-####.');
+        }
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        const names = activeDocNamesForLayout(config);
+        const { workspacePath, adrPath } = await resolveWorkspacePath(projectRoot, featureId);
+        const readDoc = async (name) => {
+            const filePath = path.join(workspacePath, name);
+            if (!existsSync(filePath)) {
+                throw new Error(`${name} not found for ${featureId}.`);
+            }
+            return fs.readFile(filePath, 'utf-8');
+        };
+        const [specRaw, planRaw, tasksRaw, changelogRaw, qualityRaw] = await Promise.all([
+            readDoc(names.spec),
+            readDoc(names.plan),
+            readDoc(names.tasks),
+            readDoc(names.changelog),
+            readDoc(names.quality),
+        ]);
+        const report = evaluatePlanningExecutionCoherence({
+            featureId,
+            workspacePath: relProjectPath(paths, workspacePath),
+            adrPath: relProjectPath(paths, adrPath),
+            adrExists: existsSync(adrPath),
+            spec: parseWorkspaceYamlDocument('1-spec.yaml', specRaw),
+            plan: parseWorkspaceYamlDocument('2-plan.yaml', planRaw),
+            tasks: parseWorkspaceYamlDocument('3-tasks.yaml', tasksRaw),
+            changelog: parseWorkspaceYamlDocument('4-changelog.yaml', changelogRaw),
+            quality: parseWorkspaceYamlDocument('5-quality.yaml', qualityRaw),
+            changedFiles: options.changedFiles ?? (await listChangedFiles(projectRoot)),
+        });
+        return report;
+    }
+}
+//# sourceMappingURL=planning-execution-coherence.service.js.map

package/dist/core/sdd/state.js

@@ -305,9 +305,9 @@ export function defaultFoldersForLayout(layout) {
 const DEFAULT_SDD_CONFIG = {
     enabled: true,
     memoryDir: '.sdd',
-    language: 'pt-BR',
-    layout: 'legacy',
-    folders: defaultFoldersForLayout('legacy'),
+    language: 'en-US',
+    layout: 'en-US',
+    folders: defaultFoldersForLayout('en-US'),
     frontend: { enabled: false },
     views: { autoRender: true },
 };
@@ -358,8 +358,18 @@ export function mergeRuntimeConfig(raw) {
     }
     const frontend = isRecord(raw.frontend) ? raw.frontend : {};
     const views = isRecord(raw.views) ? raw.views : {};
-    const language = raw.language === 'en-US' ? 'en-US' : 'pt-BR';
-    const layout = raw.layout === 'pt-BR' ? 'pt-BR' : raw.layout === 'en-US' ? 'en-US' : 'legacy';
+    const language = raw.language === 'pt-BR'
+        ? 'pt-BR'
+        : raw.language === 'en-US'
+            ? 'en-US'
+            : DEFAULT_SDD_CONFIG.language;
+    const layout = raw.layout === 'pt-BR'
+        ? 'pt-BR'
+        : raw.layout === 'en-US'
+            ? 'en-US'
+            : raw.layout === 'legacy'
+                ? 'legacy'
+                : DEFAULT_SDD_CONFIG.layout;
     const folderDefaults = defaultFoldersForLayout(layout);
     const rawFolders = isRecord(raw.folders) ? raw.folders : {};
     // compatibilidade retroativa para nome legado "pendencias"

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

@@ -92,8 +92,8 @@ export declare const SourceClassificationSchema: z.ZodEnum<{
     other: "other";
 }>;
 export declare const SourceVerificationStatusSchema: z.ZodEnum<{
-    verified: "verified";
     stale: "stale";
+    verified: "verified";
     unverified: "unverified";
     needs_review: "needs_review";
 }>;
@@ -616,8 +616,8 @@ export declare const SourceDocumentRecordSchema: z.ZodObject<{
     jurisdiction_tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     last_verified_at: z.ZodOptional<z.ZodString>;
     verification_status: z.ZodDefault<z.ZodEnum<{
-        verified: "verified";
         stale: "stale";
+        verified: "verified";
         unverified: "unverified";
         needs_review: "needs_review";
     }>>;
@@ -1235,8 +1235,8 @@ export declare const SourceIndexStateSchema: z.ZodObject<{
         jurisdiction_tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
         last_verified_at: z.ZodOptional<z.ZodString>;
         verification_status: z.ZodDefault<z.ZodEnum<{
-            verified: "verified";
             stale: "stale";
+            verified: "verified";
             unverified: "unverified";
             needs_review: "needs_review";
         }>>;

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

@@ -449,8 +449,8 @@ export declare const workspaceQualityLedgerSchema: z.ZodObject<{
 export declare const workspaceTokenTelemetrySchema: z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
         standard: "standard";
-        compact: "compact";
         full: "full";
+        compact: "compact";
     }>>;
     budget_chars: z.ZodOptional<z.ZodNumber>;
     actual_chars: z.ZodOptional<z.ZodNumber>;
@@ -470,8 +470,8 @@ export declare const workspaceTokenBudgetGatesSchema: z.ZodObject<{
     telemetry: z.ZodDefault<z.ZodArray<z.ZodObject<{
         mode: z.ZodOptional<z.ZodEnum<{
             standard: "standard";
-            compact: "compact";
             full: "full";
+            compact: "compact";
         }>>;
         budget_chars: z.ZodOptional<z.ZodNumber>;
         actual_chars: z.ZodOptional<z.ZodNumber>;
@@ -553,6 +553,29 @@ export declare const workspaceRuntimeQualityGatesSchema: z.ZodObject<{
         notes: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+export declare const workspaceCriticalEvidenceProvenanceSchema: z.ZodObject<{
+    command: z.ZodString;
+    exit_code: z.ZodNumber;
+    timestamp_iso: z.ZodString;
+    commit_sha: z.ZodString;
+    artifact_path: z.ZodString;
+    artifact_hash: z.ZodString;
+}, z.core.$strip>;
+export declare const workspaceEvidenceLogEntrySchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    kind: z.ZodString;
+    result: z.ZodString;
+    artifact: z.ZodOptional<z.ZodString>;
+    critical: z.ZodOptional<z.ZodBoolean>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        command: z.ZodString;
+        exit_code: z.ZodNumber;
+        timestamp_iso: z.ZodString;
+        commit_sha: z.ZodString;
+        artifact_path: z.ZodString;
+        artifact_hash: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const workspaceQualitySchema: z.ZodObject<{
     schema_version: z.ZodLiteral<1>;
     feature_id: z.ZodString;
@@ -571,6 +594,15 @@ export declare const workspaceQualitySchema: z.ZodObject<{
         kind: z.ZodString;
         result: z.ZodString;
         artifact: z.ZodOptional<z.ZodString>;
+        critical: z.ZodOptional<z.ZodBoolean>;
+        provenance: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            exit_code: z.ZodNumber;
+            timestamp_iso: z.ZodString;
+            commit_sha: z.ZodString;
+            artifact_path: z.ZodString;
+            artifact_hash: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     skill_evidence: z.ZodDefault<z.ZodObject<{
         required_skill_ids: z.ZodArray<z.ZodString>;
@@ -702,8 +734,8 @@ export declare const workspaceQualitySchema: z.ZodObject<{
         telemetry: z.ZodDefault<z.ZodArray<z.ZodObject<{
             mode: z.ZodOptional<z.ZodEnum<{
                 standard: "standard";
-                compact: "compact";
                 full: "full";
+                compact: "compact";
             }>>;
             budget_chars: z.ZodOptional<z.ZodNumber>;
             actual_chars: z.ZodOptional<z.ZodNumber>;
@@ -1024,6 +1056,15 @@ export declare const workspaceDocumentSchemas: {
             kind: z.ZodString;
             result: z.ZodString;
             artifact: z.ZodOptional<z.ZodString>;
+            critical: z.ZodOptional<z.ZodBoolean>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                command: z.ZodString;
+                exit_code: z.ZodNumber;
+                timestamp_iso: z.ZodString;
+                commit_sha: z.ZodString;
+                artifact_path: z.ZodString;
+                artifact_hash: z.ZodString;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         skill_evidence: z.ZodDefault<z.ZodObject<{
             required_skill_ids: z.ZodArray<z.ZodString>;
@@ -1155,8 +1196,8 @@ export declare const workspaceDocumentSchemas: {
             telemetry: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 mode: z.ZodOptional<z.ZodEnum<{
                     standard: "standard";
-                    compact: "compact";
                     full: "full";
+                    compact: "compact";
                 }>>;
                 budget_chars: z.ZodOptional<z.ZodNumber>;
                 actual_chars: z.ZodOptional<z.ZodNumber>;