@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/sdd/services/agent-run.service.js

@@ -0,0 +1,189 @@
+import { createDeepAgentsRuntimeAdapter, } from '../deepagents/runtime-factory.js';
+import { createCodeSddDeepAgentsRuntimeTools } from '../deepagents/codesdd-tools.js';
+import { mapDeepAgentsRunEvidence, mapDeepAgentsRunPlan, } from '../deepagents/evidence-mapper.js';
+import { buildDeepAgentsOperationalPreflight, createDeepAgentsPolicySnapshot, } from '../deepagents/policy.js';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+const DEEPAGENTS_RUN_MODES = [
+    'read-only',
+    'plan',
+    'validate',
+    'apply-sandbox',
+    'apply-approved',
+];
+const DEEPAGENTS_MUTATION_MODES = new Set(['apply-sandbox', 'apply-approved']);
+const REQUIRED_PLUGIN_BROKER_FLOW_BASE = [
+    'plugin-inspect',
+    'plugin-plan',
+    'plugin-dry-run',
+    'policy-evaluation',
+    'artifact-manifest',
+    'evidence-manifest',
+    'validation-manifest',
+    'rollback-manifest',
+];
+const DEEPAGENTS_PROVIDER = 'deepagents';
+export class DeepAgentsRunService {
+    async execute(featureId, request, options = {}) {
+        const generatedAt = new Date().toISOString();
+        const requestedProvider = request.provider.trim().toLowerCase();
+        const modeRequested = request.mode?.trim().toLowerCase() || 'plan';
+        const pluginExecutionPath = (request.plugin_execution_path || 'broker').trim().toLowerCase();
+        const completedPluginFlow = normalizeFlow(request.plugin_flow ?? []);
+        const operations = resolveOperations(request.operations, modeRequested);
+        const reasons = [];
+        const runId = `deepagents-${featureId}-${Date.now()}`;
+        if (!FEATURE_REF_PATTERN.test(featureId)) {
+            reasons.push('Feature ref must match FEAT-####.');
+        }
+        if (requestedProvider !== DEEPAGENTS_PROVIDER) {
+            reasons.push('Provider is not authorized. FEAT-0243 only allows --provider deepagents.');
+        }
+        const supportedModes = DEEPAGENTS_RUN_MODES;
+        const mode = supportedModes.includes(modeRequested)
+            ? modeRequested
+            : 'read-only';
+        if (!supportedModes.includes(modeRequested)) {
+            reasons.push(`Mode '${modeRequested}' is invalid. Allowed modes: ${DEEPAGENTS_RUN_MODES.join(', ')}.`);
+        }
+        const requiredPluginFlow = resolveRequiredPluginFlow(mode);
+        const missingPluginFlow = requiredPluginFlow.filter((step) => !completedPluginFlow.includes(step));
+        if (DEEPAGENTS_MUTATION_MODES.has(mode)) {
+            if (pluginExecutionPath !== 'broker') {
+                reasons.push('Direct plugin execution is forbidden. DeepAgents must use plugin broker envelopes only.');
+            }
+            if (missingPluginFlow.length > 0) {
+                reasons.push(`Mutation mode '${mode}' requires broker evidence flow: ${requiredPluginFlow.join(', ')}. Missing: ${missingPluginFlow.join(', ')}.`);
+            }
+        }
+        const runtime = reasons.length === 0
+            ? await this.executeRuntimePath(featureId, mode, runId, request, operations, options)
+            : undefined;
+        if (runtime?.adapter.status === 'blocked' && runtime.adapter.runtime !== 'disabled') {
+            reasons.push(...runtime.adapter.reasons);
+        }
+        if (runtime?.run.status === 'failed' && runtime.error) {
+            reasons.push(`DeepAgents runtime invocation failed: ${runtime.error}`);
+        }
+        const status = reasons.length === 0 ? 'allowed' : 'blocked';
+        return {
+            schema_version: 1,
+            feature_id: featureId,
+            provider: DEEPAGENTS_PROVIDER,
+            requested_provider: requestedProvider,
+            mode_requested: modeRequested,
+            mode,
+            status,
+            fail_closed: true,
+            reasons,
+            evidence: {
+                run_id: runId,
+                generated_at: generatedAt,
+                policy: 'deepagents-run-governance/v1',
+                direct_state_write_allowed: false,
+                plugin_execution: {
+                    broker_only: true,
+                    requested_path: pluginExecutionPath,
+                    required_flow: requiredPluginFlow,
+                    completed_flow: completedPluginFlow,
+                    missing_flow: missingPluginFlow,
+                },
+                runtime,
+            },
+        };
+    }
+    async executeRuntimePath(featureId, mode, runId, request, operations, options) {
+        const snapshot = createDeepAgentsPolicySnapshot(options.env);
+        const preflight = buildDeepAgentsOperationalPreflight(snapshot, options.env);
+        const tools = options.projectRoot && options.stores
+            ? createCodeSddDeepAgentsRuntimeTools(options.stores, options.projectRoot, {
+                profile: mode === 'apply-sandbox' || mode === 'apply-approved' ? 'all' : 'read-diagnostic',
+            })
+            : [];
+        const adapter = await createDeepAgentsRuntimeAdapter({
+            featureRef: featureId,
+            objective: `Run CodeSDD governed agent mode ${mode} for ${featureId}.`,
+            mode,
+            runId,
+            projectRoot: options.projectRoot,
+            tools,
+            operations,
+            writeScope: normalizeList(request.write_scope ?? []),
+            plannedWrites: normalizeList(request.planned_writes ?? []),
+            requestedEnv: normalizeList(request.requested_env ?? []),
+            networkDomains: normalizeList(request.network_domains ?? []),
+            approvalGrants: normalizeFlow(request.approval_grants ?? []),
+        }, { env: options.env, importer: options.importer, snapshot });
+        const envelope = adapter.describe();
+        const plan = mapDeepAgentsRunPlan({ adapter: envelope });
+        const invocation = envelope.status === 'ready'
+            ? await this.invokeReadyRuntime(adapter, mode, featureId)
+            : { result: undefined, error: undefined };
+        const run = mapDeepAgentsRunEvidence({
+            adapter: envelope,
+            status: invocation.error
+                ? 'failed'
+                : envelope.status === 'ready'
+                    ? 'completed'
+                    : 'blocked',
+            planRef: `${runId}:plan`,
+        });
+        return {
+            preflight,
+            adapter: envelope,
+            plan,
+            run,
+            agent_result: invocation.result,
+            fake_result: envelope.runtime === 'fake' ? invocation.result : undefined,
+            error: invocation.error,
+        };
+    }
+    async invokeReadyRuntime(adapter, mode, featureId) {
+        try {
+            const agent = await adapter.createAgent();
+            const result = await agent.invoke({
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Run ${mode} for ${featureId} under CodeSDD governance.`,
+                    },
+                ],
+            });
+            return { result };
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+}
+function resolveRequiredPluginFlow(mode) {
+    if (mode === 'apply-sandbox') {
+        return [...REQUIRED_PLUGIN_BROKER_FLOW_BASE, 'apply-sandbox'];
+    }
+    if (mode === 'apply-approved') {
+        return [...REQUIRED_PLUGIN_BROKER_FLOW_BASE, 'apply-approved'];
+    }
+    return [];
+}
+function normalizeFlow(flow) {
+    return [...new Set(flow.map((step) => step.trim().toLowerCase()).filter((step) => step.length > 0))].sort();
+}
+function normalizeList(values) {
+    return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort();
+}
+function resolveOperations(operations, modeRequested) {
+    const normalized = normalizeFlow(operations ?? []);
+    const candidates = normalized.length > 0
+        ? normalized
+        : modeRequested === 'apply-sandbox' || modeRequested === 'apply-approved'
+            ? ['plugin-apply', 'write']
+            : ['read'];
+    return candidates.filter((operation) => operation === 'read' ||
+        operation === 'write' ||
+        operation === 'execute' ||
+        operation === 'network' ||
+        operation === 'plugin-apply' ||
+        operation === 'finalize' ||
+        operation === 'dependency-change' ||
+        operation === 'process-spawn');
+}
+//# sourceMappingURL=agent-run.service.js.map

package/dist/core/sdd/services/breakdown.service.js

@@ -54,7 +54,8 @@ export class BreakdownService {
                 const id = await allocateEntityId(paths, 'FEAT');
                 syncCounterFromId(snapshot.discoveryIndex, id);
                 const recommended = resolveRoutedSkills(snapshot, shape.touches);
-                const item = buildBacklogItem(id, title, 'radar', radar.id, options?.scale || 'STANDARD', recommended, {
+                const originType = radar.type === 'RAD' ? 'radar' : 'epic';
+                const item = buildBacklogItem(id, title, originType, radar.id, options?.scale || 'STANDARD', recommended, {
                     parallelGroup,
                     executionKind: shape.executionKind,
                     planningMode: shape.planningMode,

package/dist/core/sdd/services/context.service.js

@@ -4,6 +4,7 @@ import { parse } from "yaml";
 import { CLI_NAME } from "../../branding.js";
 import { loadStateSnapshot } from "../state.js";
 import { bundlesForSkills, getRuntime, relProjectPath, coreDocRef, planningDocRef, featureActiveDir, activeDocNamesForLayout, unresolvedDependencies, lockConflictWithActive, featureReadiness, gateSatisfied, detectContextType, pathExists, listAdrRefs } from "../legacy-operations.js";
+import { normalizeSddEntityRef } from "../entity-reference.js";
 import { workspacePlanSchema, workspaceSpecSchema } from "../workspace-schemas.js";
 async function readYamlWorkspaceDoc(filePath, schema) {
     const content = await fs.readFile(filePath, 'utf-8').catch(() => '');
@@ -62,7 +63,8 @@ export class ContextService {
     async execute(projectRoot, ref) {
         const { config, paths } = await getRuntime(projectRoot);
         const snapshot = await loadStateSnapshot(paths, config);
-        const type = detectContextType(ref);
+        const normalizedRef = normalizeSddEntityRef(ref);
+        const type = detectContextType(normalizedRef);
         if (!type) {
             throw new Error(`Referencia ${ref} invalida. Use FEAT/EPIC/RAD/FGAP/TD.`);
         }
@@ -80,9 +82,9 @@ export class ContextService {
             coreDocs.push(planningDocRef(paths, 'frontend-auditoria.md'));
         }
         if (type === 'FEAT') {
-            const item = snapshot.backlog.items.find((entry) => entry.id === ref);
+            const item = snapshot.backlog.items.find((entry) => entry.id === normalizedRef);
             if (!item)
-                throw new Error(`Feature ${ref} nao encontrada.`);
+                throw new Error(`Feature ${normalizedRef} nao encontrada.`);
             const unresolved = unresolvedDependencies(item, snapshot.backlog.items);
             const lockConflicts = lockConflictWithActive(item, snapshot.backlog.items);
             const predecessorOutputs = item.blocked_by
@@ -147,7 +149,7 @@ export class ContextService {
             const requiredSkillEvidence = item.recommended_skills.filter(Boolean);
             return {
                 sdd_pack_version: 1,
-                target_id: ref,
+                target_id: normalizedRef,
                 target_type: type,
                 summary: `${item.title} [${item.status}]`,
                 objective: workspace.spec?.objective || item.summary || '',
@@ -166,7 +168,7 @@ export class ContextService {
                 origin: { type: item.origin_type, ref: item.origin_ref || '' },
                 related_discovery: item.origin_ref
                     ? snapshot.discoveryIndex.records
-                        .filter((record) => record.id === item.origin_ref || record.related_ids.includes(ref))
+                        .filter((record) => record.id === item.origin_ref || record.related_ids.includes(normalizedRef))
                         .map((record) => record.id)
                     : [],
                 related_gaps: item.frontend_gap_refs,
@@ -213,19 +215,19 @@ export class ContextService {
             };
         }
         if (type === 'RAD' || type === 'EPIC') {
-            const radar = snapshot.discoveryIndex.records.find((record) => record.id === ref && (record.type === 'RAD' || record.type === 'EPIC'));
+            const radar = snapshot.discoveryIndex.records.find((record) => record.id === normalizedRef && (record.type === 'RAD' || record.type === 'EPIC'));
             if (!radar)
-                throw new Error(`Epic/Radar ${ref} nao encontrado.`);
-            const relatedFeatures = snapshot.backlog.items.filter((item) => (item.origin_type === 'radar' || item.origin_type === 'epic') && item.origin_ref === ref);
+                throw new Error(`Epic/Radar ${normalizedRef} nao encontrado.`);
+            const relatedFeatures = snapshot.backlog.items.filter((item) => (item.origin_type === 'radar' || item.origin_type === 'epic') && item.origin_ref === normalizedRef);
             return {
                 sdd_pack_version: 1,
-                target_id: ref,
+                target_id: normalizedRef,
                 target_type: type,
                 summary: `${radar.title} [${radar.status}]`,
                 quality_contract: radar.quality_contract || null,
                 related_features: relatedFeatures.map((item) => item.id),
                 related_debates: snapshot.discoveryIndex.records
-                    .filter((record) => record.type === 'DEB' && record.related_ids.includes(ref))
+                    .filter((record) => record.type === 'DEB' && record.related_ids.includes(normalizedRef))
                     .map((record) => record.id),
                 read_order: [
                     'README.md',
@@ -237,12 +239,12 @@ export class ContextService {
             };
         }
         if (type === 'FGAP') {
-            const gap = snapshot.frontendGaps?.items.find((item) => item.id === ref);
+            const gap = snapshot.frontendGaps?.items.find((item) => item.id === normalizedRef);
             if (!gap)
-                throw new Error(`Gap de frontend ${ref} nao encontrado.`);
+                throw new Error(`Gap de frontend ${normalizedRef} nao encontrado.`);
             return {
                 sdd_pack_version: 1,
-                target_id: ref,
+                target_id: normalizedRef,
                 target_type: type,
                 summary: `${gap.title} [${gap.status}]`,
                 source_feature: gap.origin_feature || '',
@@ -257,12 +259,12 @@ export class ContextService {
                 core_docs: coreDocs,
             };
         }
-        const debt = snapshot.techDebt.items.find((item) => item.id === ref);
+        const debt = snapshot.techDebt.items.find((item) => item.id === normalizedRef);
         if (!debt)
-            throw new Error(`Divida tecnica ${ref} nao encontrada.`);
+            throw new Error(`Divida tecnica ${normalizedRef} nao encontrada.`);
         return {
             sdd_pack_version: 1,
-            target_id: ref,
+            target_id: normalizedRef,
             target_type: type,
             summary: `${debt.title} [${debt.status}]`,
             related_refs: debt.related_refs,

package/dist/core/sdd/services/debate.service.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { promises as fs } from "node:fs";
 import { TransitionEngine } from "../domain/transition-engine.js";
 import { allocateEntityId, loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
-import { slugify, computeCanonicalTitle, findDiscoveryRecord, markdownDebateTemplate, buildDefaultQualityContract, syncCounterFromId, getRuntime, persistAndRender, applyLoggedTransition } from "../legacy-operations.js";
+import { slugify, computeCanonicalTitle, findDiscoveryRecord, markdownDebateTemplate, buildDefaultQualityContract, findDebateFile, syncCounterFromId, getRuntime, persistAndRender, applyLoggedTransition } from "../legacy-operations.js";
 import { withStateLock } from "../state-lock.js";
 export class DebateService {
     stores;
@@ -19,10 +19,23 @@ export class DebateService {
             }
             const existingDebate = snapshot.discoveryIndex.records.find((record) => record.type === 'DEB' && record.related_ids.includes(insight.id));
             if (existingDebate) {
+                const existingFile = await findDebateFile(paths, existingDebate.id);
+                if (existingFile) {
+                    return {
+                        id: existingDebate.id,
+                        title: existingDebate.title,
+                        filePath: existingFile,
+                        reused: true,
+                    };
+                }
+                const repairedFilePath = path.join(paths.discoveryDebatesDir, `${existingDebate.id}-${slugify(existingDebate.title)}.md`);
+                await fs.mkdir(paths.discoveryDebatesDir, { recursive: true });
+                await fs.writeFile(repairedFilePath, markdownDebateTemplate(insight, existingDebate.id), 'utf-8');
+                await persistAndRender(paths, config, options?.render);
                 return {
                     id: existingDebate.id,
                     title: existingDebate.title,
-                    filePath: path.join(paths.discoveryDebatesDir, `${existingDebate.id}-${slugify(existingDebate.title)}.md`),
+                    filePath: repairedFilePath,
                     reused: true,
                 };
             }

package/dist/core/sdd/services/feature-lint.service.d.ts

@@ -1,3 +1,6 @@
+import { type SddPaths, type SddRuntimeConfig } from '../state.js';
+import type { BacklogItem } from '../types.js';
+import { type WorkspaceQualityDocument, type WorkspaceTasksDocument } from '../workspace-schemas.js';
 export interface FeatureLintOptions {
     strict?: boolean;
 }
@@ -22,6 +25,25 @@ export interface FeatureLintReport {
     };
     findings: FeatureLintFinding[];
 }
+export declare function isFoundationPrescriptiveFeature(feature: Pick<BacklogItem, 'title' | 'summary'>): boolean;
+export declare function loadTasksDocument(paths: SddPaths, config: SddRuntimeConfig, featureId: string): Promise<{
+    workspacePath: string;
+    tasks?: WorkspaceTasksDocument;
+    error?: string;
+}>;
+export declare function loadQualityDocument(paths: SddPaths, config: SddRuntimeConfig, featureId: string): Promise<{
+    workspacePath: string;
+    quality?: WorkspaceQualityDocument;
+    error?: string;
+}>;
+export declare function hasTemplatePlaceholder(content: string): boolean;
+export declare function collectTaskCommands(tasks: WorkspaceTasksDocument | undefined): string[];
+export declare function addFinding(findings: FeatureLintFinding[], severity: FeatureLintFinding['severity'], code: string, message: string, evidence: Record<string, unknown>): void;
+export declare function lintFeatureShape(feature: BacklogItem, taskCount: number, workspaceError: string | undefined, qualityDocument: WorkspaceQualityDocument | undefined, qualityError: string | undefined, commands: string[], adr: {
+    exists: boolean;
+    isTemplate: boolean;
+    path: string;
+}): FeatureLintFinding[];
 export declare class FeatureLintService {
     execute(projectRoot: string, featureId: string, options?: FeatureLintOptions): Promise<FeatureLintReport>;
 }

package/dist/core/sdd/services/feature-lint.service.js

@@ -2,8 +2,20 @@ import path from 'node:path';
 import { existsSync, promises as fs } from 'node:fs';
 import { loadProjectSddConfig, loadStateSnapshot, resolveSddPaths, } from '../state.js';
 import { activeDocNamesForLayout, ensureMemoryInitialized, relProjectPath } from '../legacy-operations.js';
-import { parseWorkspaceYamlDocument } from '../workspace-schemas.js';
-async function loadTasksDocument(paths, config, featureId) {
+import { parseWorkspaceYamlDocument, } from '../workspace-schemas.js';
+const FOUNDATION_PROFILE_TOKENS = ['foundation api', 'devtrack foundation api'];
+const FOUNDATION_ENFORCEMENT_TOKENS = ['prescriptive', 'enforcement', 'lint', 'scaffold'];
+const ADR_TEMPLATE_PLACEHOLDERS = [
+    'Describe the context that motivated this architecture decision',
+    'Document the decision, the change scope, and the alternatives rejected.',
+    'List positive impacts, residual risks, and mitigation actions.',
+];
+export function isFoundationPrescriptiveFeature(feature) {
+    const source = `${feature.title} ${feature.summary || ''}`.toLowerCase();
+    return (FOUNDATION_PROFILE_TOKENS.some((token) => source.includes(token)) &&
+        FOUNDATION_ENFORCEMENT_TOKENS.some((token) => source.includes(token)));
+}
+export async function loadTasksDocument(paths, config, featureId) {
     const names = activeDocNamesForLayout(config);
     const roots = [paths.activeDir, paths.plannedDir, paths.archivedDir];
     for (const root of roots) {
@@ -30,10 +42,47 @@ async function loadTasksDocument(paths, config, featureId) {
     }
     return { workspacePath: '', error: 'Feature workspace not found.' };
 }
-function addFinding(findings, severity, code, message, evidence) {
+export async function loadQualityDocument(paths, config, featureId) {
+    const names = activeDocNamesForLayout(config);
+    const roots = [paths.activeDir, paths.plannedDir, paths.archivedDir];
+    for (const root of roots) {
+        const workspacePath = path.join(root, featureId);
+        if (!existsSync(workspacePath))
+            continue;
+        const qualityPath = path.join(workspacePath, names.quality);
+        if (!existsSync(qualityPath)) {
+            return { workspacePath: relProjectPath(paths, workspacePath), error: `${names.quality} not found.` };
+        }
+        const content = await fs.readFile(qualityPath, 'utf-8');
+        try {
+            return {
+                workspacePath: relProjectPath(paths, workspacePath),
+                quality: parseWorkspaceYamlDocument('5-quality.yaml', content),
+            };
+        }
+        catch (error) {
+            return {
+                workspacePath: relProjectPath(paths, workspacePath),
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    return { workspacePath: '', error: 'Feature workspace not found.' };
+}
+export function hasTemplatePlaceholder(content) {
+    return ADR_TEMPLATE_PLACEHOLDERS.some((placeholder) => content.includes(placeholder));
+}
+export function collectTaskCommands(tasks) {
+    if (!tasks)
+        return [];
+    return tasks.tasks
+        .flatMap((task) => task.test_scripts.map((script) => script.command.toLowerCase().trim()))
+        .filter(Boolean);
+}
+export function addFinding(findings, severity, code, message, evidence) {
     findings.push({ severity, code, message, evidence });
 }
-function lintFeatureShape(feature, taskCount, workspaceError) {
+export function lintFeatureShape(feature, taskCount, workspaceError, qualityDocument, qualityError, commands, adr) {
     const findings = [];
     if (workspaceError) {
         addFinding(findings, 'error', 'workspace_tasks_unreadable', 'Feature tasks could not be read from the workspace.', {
@@ -87,6 +136,49 @@ function lintFeatureShape(feature, taskCount, workspaceError) {
             touches: feature.touches,
         });
     }
+    if (isFoundationPrescriptiveFeature(feature)) {
+        if ((feature.quality_contract?.enforcement || 'blocking') !== 'blocking') {
+            addFinding(findings, 'error', 'foundation_enforcement_not_blocking', 'Foundation API prescriptive features must use blocking quality enforcement.', {
+                feature_id: feature.id,
+                enforcement: feature.quality_contract?.enforcement || 'undefined',
+            });
+        }
+        if (qualityError) {
+            addFinding(findings, 'error', 'foundation_quality_unreadable', 'Foundation API prescriptive features require a readable 5-quality.yaml workspace document.', {
+                feature_id: feature.id,
+                error: qualityError,
+            });
+        }
+        if (!commands.some((command) => command.includes('sdd lint feature'))) {
+            addFinding(findings, 'error', 'foundation_lint_blocker_missing', 'Foundation API prescriptive features must include a feature-lint blocker command in tasks.', {
+                feature_id: feature.id,
+            });
+        }
+        if (!commands.some((command) => command.includes('sdd plugin devtrack-api scaffold-dry-run'))) {
+            addFinding(findings, 'error', 'foundation_scaffold_blocker_missing', 'Foundation API prescriptive features must include a devtrack-api scaffold dry-run blocker command in tasks.', {
+                feature_id: feature.id,
+            });
+        }
+        const exceptionCount = qualityDocument?.exceptions.length || feature.quality_contract?.exceptions.length || 0;
+        if (exceptionCount > 0 && !feature.requires_adr) {
+            addFinding(findings, 'error', 'foundation_exception_requires_adr_flag', 'Foundation API exceptions require requires_adr=true in backlog state.', {
+                feature_id: feature.id,
+                exceptions: exceptionCount,
+            });
+        }
+        if (exceptionCount > 0 && !adr.exists) {
+            addFinding(findings, 'error', 'foundation_exception_missing_adr', 'Foundation API exceptions require ADR documentation before execution can proceed.', {
+                feature_id: feature.id,
+                expected_adr: adr.path,
+            });
+        }
+        if (exceptionCount > 0 && adr.isTemplate) {
+            addFinding(findings, 'error', 'foundation_exception_adr_template', 'Foundation API exception ADR must be completed with concrete context, decision, and consequences.', {
+                feature_id: feature.id,
+                adr_path: adr.path,
+            });
+        }
+    }
     return findings;
 }
 export class FeatureLintService {
@@ -103,8 +195,16 @@ export class FeatureLintService {
             throw new Error(`Feature ${featureId} not found in backlog.`);
         }
         const workspace = await loadTasksDocument(paths, config, featureId);
+        const qualityWorkspace = await loadQualityDocument(paths, config, featureId);
         const taskCount = workspace.tasks?.tasks.length ?? 0;
-        const findings = lintFeatureShape(feature, taskCount, workspace.error);
+        const commandList = collectTaskCommands(workspace.tasks);
+        const adrPath = path.join(paths.coreDir, 'adrs', `ADR-${feature.id}.md`);
+        const adrContent = await fs.readFile(adrPath, 'utf-8').catch(() => '');
+        const findings = lintFeatureShape(feature, taskCount, workspace.error, qualityWorkspace.quality, qualityWorkspace.error, commandList, {
+            exists: !!adrContent.trim(),
+            isTemplate: hasTemplatePlaceholder(adrContent),
+            path: relProjectPath(paths, adrPath),
+        });
         const hasErrors = findings.some((finding) => finding.severity === 'error');
         const hasWarnings = findings.some((finding) => finding.severity === 'warning');
         const ok = !hasErrors && !(options.strict && hasWarnings);

package/dist/core/sdd/services/finalize.service.d.ts

@@ -1,4 +1,7 @@
+import { SddPaths, SddRuntimeConfig } from "../state.js";
+import { BacklogItem, FinalizeQueueItem } from "../types.js";
 import { SddStores } from "../store/sdd-stores.js";
+import { type WorkspaceQualityDocument } from "../workspace-schemas.js";
 export declare class FinalizeService {
     private readonly stores;
     constructor(stores: SddStores);
@@ -30,4 +33,81 @@ export declare class FinalizeService {
         }[];
     }>;
 }
+export type WorkspaceQualityFeedbackResult = {
+    ok: boolean;
+    reasons: string[];
+    artifact: string;
+};
+export type WorkspaceTraceabilityFeedbackResult = {
+    ok: boolean;
+    reasons: string[];
+    artifact: string;
+};
+export type PrivacyFinalizeGuardrailResult = {
+    ok: boolean;
+    reasons: string[];
+};
+export type DevTrackApiPolicyGatesResult = {
+    ok: boolean;
+    reasons: string[];
+};
+export declare function inferFinalizeTarget(paths: SddPaths, pending: FinalizeQueueItem[], explicitRef?: string, cwd?: string): Promise<string | undefined>;
+export declare function isPrivacyComplianceFeature(feature: BacklogItem): boolean;
+export declare function evaluatePrivacyFinalizeGuardrail(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem): Promise<PrivacyFinalizeGuardrailResult>;
+export declare function evaluateDevTrackApiPolicyGates(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem): Promise<DevTrackApiPolicyGatesResult>;
+export declare function evaluateDevTrackApiPolicyEvidence(quality: WorkspaceQualityDocument): string[];
+export declare function evaluateWorkspaceQualityFeedback(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem): Promise<WorkspaceQualityFeedbackResult>;
+export declare function evaluateWorkspaceTraceabilityFeedback(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem): Promise<WorkspaceTraceabilityFeedbackResult>;
+export type Q95AxisKey = 'coverage' | 'traceability' | 'integrity' | 'naming' | 'token';
+export type Q95AxisResult = {
+    raw_score: number;
+    weighted_score: number;
+    rationale: string;
+};
+export type Q95Ledger = {
+    threshold: number;
+    score: number;
+    status: 'pass' | 'fail' | 'pending';
+    computed_at: string;
+    weights: Record<Q95AxisKey, number>;
+    axes: Record<Q95AxisKey, Q95AxisResult>;
+    next_best_action: string;
+};
+export declare function computeQ95Ledger(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem, document: WorkspaceQualityDocument): Promise<Q95Ledger>;
+export declare function weightedAxis(input: {
+    raw_score: number;
+    rationale: string;
+}, weight: number): Q95AxisResult;
+export declare function computeCoverageAxis(document: WorkspaceQualityDocument): {
+    raw_score: number;
+    rationale: string;
+};
+export declare function computeTraceabilityAxis(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem, document: WorkspaceQualityDocument): Promise<{
+    raw_score: number;
+    rationale: string;
+}>;
+export declare function computeIntegrityAxis(document: WorkspaceQualityDocument): {
+    raw_score: number;
+    rationale: string;
+};
+export declare function computeNamingAxis(feature: BacklogItem, document: WorkspaceQualityDocument): {
+    raw_score: number;
+    rationale: string;
+};
+export declare function computeTokenAxis(document: WorkspaceQualityDocument): {
+    raw_score: number;
+    rationale: string;
+};
+export declare function extractCoveragePerformance(document: WorkspaceQualityDocument, kind: 'unit' | 'integration'): number;
+export declare function integritySignalScore(value: 'not_applicable' | 'pending' | 'passed' | 'failed'): number;
+export declare function inferQ95NextAction(axes: Record<Q95AxisKey, Q95AxisResult>): string;
+export declare function clampPercent(value: number): number;
+export declare function round2(value: number): number;
+export declare function missingCoverageTargets(document: WorkspaceQualityDocument): Array<{
+    kind: 'unit' | 'integration';
+    target: number;
+}>;
+export declare function coverageTargetMet(document: WorkspaceQualityDocument, kind: 'unit' | 'integration', target: number): boolean;
+export declare function countQualityEvidenceRounds(document: WorkspaceQualityDocument): number;
+export declare function missingSkillEvidence(document: WorkspaceQualityDocument): string[];
 //# sourceMappingURL=finalize.service.d.ts.map