@devtrack-solution/codesdd 1.2.2

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

@@ -0,0 +1,73 @@
+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 { withStateLock } from "../state-lock.js";
+export class DebateService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, insightId, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const insight = findDiscoveryRecord(snapshot.discoveryIndex.records, insightId);
+            if (!insight || insight.type !== 'INS') {
+                throw new Error(`Insight ${insightId} nao encontrado.`);
+            }
+            const existingDebate = snapshot.discoveryIndex.records.find((record) => record.type === 'DEB' && record.related_ids.includes(insight.id));
+            if (existingDebate) {
+                return {
+                    id: existingDebate.id,
+                    title: existingDebate.title,
+                    filePath: path.join(paths.discoveryDebatesDir, `${existingDebate.id}-${slugify(existingDebate.title)}.md`),
+                    reused: true,
+                };
+            }
+            TransitionEngine.assertValid(insight.type, insight.status, 'DEBATED');
+            const id = await allocateEntityId(paths, 'DEB');
+            syncCounterFromId(snapshot.discoveryIndex, id);
+            const now = nowIso();
+            const title = (options?.title || `Debate: ${insight.title}`).slice(0, 120);
+            const titleCanonical = computeCanonicalTitle(options?.title || insight.title_canonical || insight.title);
+            const debate = {
+                id,
+                type: 'DEB',
+                title,
+                title_canonical: titleCanonical,
+                status: 'OPEN',
+                origin_prompt: `Debate originado de ${insight.id}${options?.agent ? ` por ${options.agent}` : ''}`,
+                related_ids: [insight.id],
+                warning_links: [],
+                created_at: now,
+                updated_at: now,
+                quality_contract: buildDefaultQualityContract({
+                    inheritedFrom: insight.id,
+                    scope: 'decision_scope',
+                }),
+            };
+            applyLoggedTransition(snapshot.transitionLog.events, insight.type, insight, 'DEBATED', {
+                sourceCommand: 'sdd debate',
+                actor: options?.agent || 'system',
+                reason: `Insight promovido para debate ${id}`,
+                timestamp: now,
+                afterTransition: (currentInsight) => {
+                    currentInsight.related_ids = Array.from(new Set([...currentInsight.related_ids, id]));
+                    currentInsight.updated_at = now;
+                },
+            });
+            snapshot.discoveryIndex.records.push(debate);
+            await saveStateTransaction(paths, {
+                discoveryIndex: snapshot.discoveryIndex,
+                transitionLog: snapshot.transitionLog,
+            });
+            const filePath = path.join(paths.discoveryDebatesDir, `${id}-${slugify(title)}.md`);
+            await fs.writeFile(filePath, markdownDebateTemplate(insight, id), 'utf-8');
+            await persistAndRender(paths, config, options?.render);
+            return { id, title, filePath, reused: false };
+        });
+    }
+}
+//# sourceMappingURL=debate.service.js.map

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

@@ -0,0 +1,23 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class DecideService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, debateId: string, outcome: 'radar' | 'epic' | 'discard', options?: {
+        title?: string;
+        rationale?: string;
+        render?: boolean;
+    }): Promise<{
+        outcome: "discard";
+        debateId: string;
+        discardPath: string;
+        radarId?: undefined;
+        radarPath?: undefined;
+    } | {
+        outcome: "radar" | "epic";
+        debateId: string;
+        radarId: string;
+        radarPath: string;
+        discardPath?: undefined;
+    }>;
+}
+//# sourceMappingURL=decide.service.d.ts.map

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

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { allocateEntityId, loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
+import { slugify, findDiscoveryRecord, markdownRadarTemplate, markdownDiscardTemplate, buildDefaultQualityContract, findDebateFile, validateDebateDocument, syncCounterFromId, getRuntime, persistAndRender, applyLoggedTransition } from "../legacy-operations.js";
+import { withStateLock } from "../state-lock.js";
+export class DecideService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, debateId, outcome, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const debate = findDiscoveryRecord(snapshot.discoveryIndex.records, debateId);
+            if (!debate || debate.type !== 'DEB') {
+                throw new Error(`Debate ${debateId} nao encontrado.`);
+            }
+            const debateFile = await findDebateFile(paths, debateId);
+            if (!debateFile) {
+                throw new Error(`Arquivo do debate ${debateId} nao encontrado em ${path.relative(projectRoot, paths.discoveryDebatesDir)}.`);
+            }
+            const debateContent = await fs.readFile(debateFile, 'utf-8');
+            const missingSections = validateDebateDocument(debateContent);
+            if (missingSections.length > 0) {
+                throw new Error(`Debate ${debateId} is incomplete. Fill required sections before deciding:\n- ${missingSections.join('\n- ')}`);
+            }
+            const now = nowIso();
+            const targetStatus = outcome === 'radar' || outcome === 'epic' ? 'APPROVED' : 'DISCARDED';
+            applyLoggedTransition(snapshot.transitionLog.events, debate.type, debate, targetStatus, {
+                sourceCommand: 'sdd decide',
+                reason: outcome === 'discard'
+                    ? `Debate descartado por ${debate.id}`
+                    : `Debate aprovado e promovido para ${outcome === 'epic' ? 'epic' : 'radar'}`,
+                timestamp: now,
+                afterTransition: (currentDebate) => {
+                    currentDebate.updated_at = now;
+                },
+            });
+            if (outcome === 'discard') {
+                const discardPath = path.join(paths.discoveryDiscardedDir, `${debate.id}-${slugify(debate.title)}.md`);
+                await fs.writeFile(discardPath, markdownDiscardTemplate(debate, options?.rationale), 'utf-8');
+                await saveStateTransaction(paths, {
+                    discoveryIndex: snapshot.discoveryIndex,
+                    transitionLog: snapshot.transitionLog,
+                });
+                await persistAndRender(paths, config, options?.render);
+                return { outcome, debateId, discardPath };
+            }
+            const radarId = await allocateEntityId(paths, 'EPIC');
+            syncCounterFromId(snapshot.discoveryIndex, radarId);
+            const radarTitle = (options?.title || debate.title_canonical || debate.title).slice(0, 120);
+            const radarRecord = {
+                id: radarId,
+                type: 'EPIC',
+                title: radarTitle,
+                status: 'READY',
+                origin_prompt: options?.rationale,
+                related_ids: [debate.id, ...debate.related_ids],
+                warning_links: [],
+                created_at: now,
+                updated_at: now,
+                quality_contract: buildDefaultQualityContract({
+                    inheritedFrom: debate.id,
+                    scope: 'epic_touched_scope',
+                }),
+            };
+            debate.related_ids = Array.from(new Set([...debate.related_ids, radarId]));
+            snapshot.discoveryIndex.records.push(radarRecord);
+            await saveStateTransaction(paths, {
+                discoveryIndex: snapshot.discoveryIndex,
+                transitionLog: snapshot.transitionLog,
+            });
+            const radarPath = path.join(paths.discoveryEpicDir, `${radarId}-${slugify(radarTitle)}.md`);
+            await fs.writeFile(radarPath, markdownRadarTemplate(debate, radarId, options?.rationale), 'utf-8');
+            await persistAndRender(paths, config, options?.render);
+            return { outcome, debateId, radarId, radarPath };
+        });
+    }
+}
+//# sourceMappingURL=decide.service.js.map

package/dist/core/sdd/services/dedup-apply.service.d.ts

@@ -0,0 +1,39 @@
+export interface SddDedupApplyOptions {
+    apply?: boolean;
+    dryRun?: boolean;
+    render?: boolean;
+}
+export interface SddDedupCandidate {
+    id: string;
+    title: string;
+    status: string;
+    warning_links: string[];
+    valid_links: string[];
+    missing_links: string[];
+    primary_link: string;
+    action: 'reconcile' | 'skip-active' | 'skip-missing';
+}
+export interface SddDedupSectionReport {
+    scanned: number;
+    candidates: SddDedupCandidate[];
+    reconciled: string[];
+    skipped_active: string[];
+    missing_links: string[];
+    canonical_updates: string[];
+    reference_updates: string[];
+}
+export interface SddDedupApplyReport {
+    dry_run: boolean;
+    applied: boolean;
+    rendered: boolean;
+    changed: boolean;
+    generated_at: string;
+    backlog: SddDedupSectionReport;
+    discovery: SddDedupSectionReport;
+    warnings: string[];
+}
+export declare class SddDedupApplyService {
+    execute(projectRoot?: string, options?: SddDedupApplyOptions): Promise<SddDedupApplyReport>;
+}
+export declare function formatSddDedupApplyReport(report: SddDedupApplyReport): string;
+//# sourceMappingURL=dedup-apply.service.d.ts.map

package/dist/core/sdd/services/dedup-apply.service.js

@@ -0,0 +1,259 @@
+import { isDeepStrictEqual } from 'node:util';
+import { loadProjectSddConfig, loadStateSnapshot, nowIso, resolveSddPaths, saveStateTransaction, } from '../state.js';
+import { BacklogStateSchema, DiscoveryIndexStateSchema, } from '../types.js';
+import { ensureMemoryInitialized } from '../legacy-operations.js';
+import { renderViews } from '../views.js';
+const BACKLOG_HISTORICAL_STATUSES = new Set(['DONE', 'ARCHIVED']);
+const DISCOVERY_HISTORICAL_STATUSES = new Set([
+    'DISCARDED',
+    'SUPERSEDED',
+    'DONE',
+    'CANCELLED',
+]);
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function unique(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        result.push(trimmed);
+    }
+    return result;
+}
+function defaultSectionReport() {
+    return {
+        scanned: 0,
+        candidates: [],
+        reconciled: [],
+        skipped_active: [],
+        missing_links: [],
+        canonical_updates: [],
+        reference_updates: [],
+    };
+}
+function appendSummary(summary, note) {
+    const existing = summary?.trim();
+    if (!existing)
+        return note;
+    if (existing.includes(note))
+        return existing;
+    return `${existing}\n${note}`;
+}
+function replaceRefs(values, fromId, toId, ownerId) {
+    return unique(values.map((value) => (value === fromId ? toId : value))).filter((value) => value !== ownerId);
+}
+function shouldRender(config, options, changed) {
+    if (!changed)
+        return false;
+    if (options.dryRun)
+        return false;
+    if (options.render === false)
+        return false;
+    return options.render === true || config.views.autoRender;
+}
+function candidateFor(entity, existingIds, historicalStatuses) {
+    const warningLinks = unique(entity.warning_links ?? []);
+    const validLinks = warningLinks.filter((link) => link !== entity.id && existingIds.has(link));
+    const missingLinks = warningLinks.filter((link) => link === entity.id || !existingIds.has(link));
+    const historical = historicalStatuses.has(entity.status);
+    const action = validLinks.length === 0 ? 'skip-missing' : historical ? 'reconcile' : 'skip-active';
+    return {
+        id: entity.id,
+        title: entity.title,
+        status: entity.status,
+        warning_links: warningLinks,
+        valid_links: validLinks,
+        missing_links: missingLinks,
+        primary_link: validLinks[0] ?? '',
+        action,
+    };
+}
+function mergeBacklogIntoCanonical(canonical, duplicate, timestamp) {
+    canonical.acceptance_refs = unique([...canonical.acceptance_refs, ...duplicate.acceptance_refs]);
+    canonical.spec_refs = unique([...canonical.spec_refs, ...duplicate.spec_refs]);
+    canonical.touches = unique([...canonical.touches, ...duplicate.touches]);
+    canonical.lock_domains = unique([...canonical.lock_domains, ...duplicate.lock_domains]);
+    canonical.produces = unique([...canonical.produces, ...duplicate.produces]);
+    canonical.consumes = unique([...canonical.consumes, ...duplicate.consumes]);
+    canonical.recommended_skills = unique([...canonical.recommended_skills, ...duplicate.recommended_skills]);
+    canonical.frontend_surface_tokens = unique([
+        ...canonical.frontend_surface_tokens,
+        ...duplicate.frontend_surface_tokens,
+    ]);
+    canonical.frontend_gap_refs = unique([...canonical.frontend_gap_refs, ...duplicate.frontend_gap_refs]);
+    canonical.blocked_by = unique([...canonical.blocked_by, ...duplicate.blocked_by]).filter((id) => id !== canonical.id && id !== duplicate.id);
+    canonical.last_sync_at = timestamp;
+    if (canonical.quality_contract) {
+        canonical.quality_contract.updated_at = timestamp;
+    }
+}
+function applyBacklogDedup(state, timestamp) {
+    const report = defaultSectionReport();
+    const byId = new Map(state.items.map((item) => [item.id, item]));
+    const ids = new Set(byId.keys());
+    const candidates = state.items
+        .filter((item) => item.warning_links.length > 0)
+        .map((item) => candidateFor(item, ids, BACKLOG_HISTORICAL_STATUSES));
+    report.scanned = candidates.length;
+    report.candidates = candidates;
+    for (const candidate of candidates) {
+        if (candidate.missing_links.length > 0) {
+            report.missing_links.push(`${candidate.id}:${candidate.missing_links.join(',')}`);
+        }
+        if (candidate.action === 'skip-missing')
+            continue;
+        if (candidate.action === 'skip-active') {
+            report.skipped_active.push(candidate.id);
+            continue;
+        }
+        const duplicate = byId.get(candidate.id);
+        const canonical = byId.get(candidate.primary_link);
+        if (!duplicate || !canonical)
+            continue;
+        mergeBacklogIntoCanonical(canonical, duplicate, timestamp);
+        canonical.summary = appendSummary(canonical.summary, `[dedup] Reconciled warning-linked historical duplicate ${duplicate.id} on ${timestamp}.`);
+        duplicate.summary = appendSummary(duplicate.summary, `[dedup] Reconciled into ${canonical.id} via warning_links on ${timestamp}.`);
+        duplicate.warning_links = duplicate.warning_links.filter((link) => !candidate.valid_links.includes(link));
+        duplicate.last_sync_at = timestamp;
+        report.reconciled.push(duplicate.id);
+        report.canonical_updates.push(canonical.id);
+        for (const item of state.items) {
+            const nextBlockedBy = replaceRefs(item.blocked_by, duplicate.id, canonical.id, item.id);
+            if (!isDeepStrictEqual(item.blocked_by, nextBlockedBy)) {
+                item.blocked_by = nextBlockedBy;
+                item.last_sync_at = timestamp;
+                report.reference_updates.push(item.id);
+            }
+        }
+    }
+    report.reconciled = unique(report.reconciled);
+    report.skipped_active = unique(report.skipped_active);
+    report.missing_links = unique(report.missing_links);
+    report.canonical_updates = unique(report.canonical_updates);
+    report.reference_updates = unique(report.reference_updates);
+    return report;
+}
+function mergeDiscoveryIntoCanonical(canonical, duplicate, timestamp) {
+    canonical.related_ids = unique([...canonical.related_ids, duplicate.id, ...duplicate.related_ids]);
+    canonical.updated_at = timestamp;
+}
+function applyDiscoveryDedup(state, timestamp) {
+    const report = defaultSectionReport();
+    const byId = new Map(state.records.map((record) => [record.id, record]));
+    const ids = new Set(byId.keys());
+    const candidates = state.records
+        .filter((record) => record.warning_links.length > 0)
+        .map((record) => candidateFor(record, ids, DISCOVERY_HISTORICAL_STATUSES));
+    report.scanned = candidates.length;
+    report.candidates = candidates;
+    for (const candidate of candidates) {
+        if (candidate.missing_links.length > 0) {
+            report.missing_links.push(`${candidate.id}:${candidate.missing_links.join(',')}`);
+        }
+        if (candidate.action === 'skip-missing')
+            continue;
+        if (candidate.action === 'skip-active') {
+            report.skipped_active.push(candidate.id);
+            continue;
+        }
+        const duplicate = byId.get(candidate.id);
+        const canonical = byId.get(candidate.primary_link);
+        if (!duplicate || !canonical)
+            continue;
+        mergeDiscoveryIntoCanonical(canonical, duplicate, timestamp);
+        duplicate.related_ids = unique([...duplicate.related_ids, ...candidate.valid_links]);
+        duplicate.warning_links = duplicate.warning_links.filter((link) => !candidate.valid_links.includes(link));
+        duplicate.updated_at = timestamp;
+        report.reconciled.push(duplicate.id);
+        report.canonical_updates.push(canonical.id);
+    }
+    report.reconciled = unique(report.reconciled);
+    report.skipped_active = unique(report.skipped_active);
+    report.missing_links = unique(report.missing_links);
+    report.canonical_updates = unique(report.canonical_updates);
+    report.reference_updates = unique(report.reference_updates);
+    return report;
+}
+function hasReconciliations(report) {
+    return report.backlog.reconciled.length > 0 || report.discovery.reconciled.length > 0;
+}
+export class SddDedupApplyService {
+    async execute(projectRoot = '.', options = {}) {
+        if (!options.apply) {
+            throw new Error('Use --apply to reconcile historical duplicate warning_links.');
+        }
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        await ensureMemoryInitialized(paths);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const timestamp = nowIso();
+        const backlogState = clone(snapshot.backlog);
+        const discoveryState = clone(snapshot.discoveryIndex);
+        const backlog = applyBacklogDedup(backlogState, timestamp);
+        const discovery = applyDiscoveryDedup(discoveryState, timestamp);
+        const warnings = [
+            ...backlog.skipped_active.map((id) => `${id} has warning_links but is not historical; left unchanged.`),
+            ...discovery.skipped_active.map((id) => `${id} has warning_links but is not historical; left unchanged.`),
+            ...backlog.missing_links.map((entry) => `Backlog warning_links not found: ${entry}`),
+            ...discovery.missing_links.map((entry) => `Discovery warning_links not found: ${entry}`),
+        ];
+        const report = {
+            dry_run: options.dryRun === true,
+            applied: options.dryRun !== true,
+            rendered: false,
+            changed: false,
+            generated_at: timestamp,
+            backlog,
+            discovery,
+            warnings,
+        };
+        report.changed = hasReconciliations(report);
+        const render = shouldRender(config, options, report.changed);
+        report.rendered = render;
+        if (!options.dryRun && report.changed) {
+            const parsedBacklog = BacklogStateSchema.parse(backlogState);
+            const parsedDiscovery = DiscoveryIndexStateSchema.parse(discoveryState);
+            await saveStateTransaction(paths, {
+                backlog: parsedBacklog,
+                discoveryIndex: parsedDiscovery,
+            });
+            if (render) {
+                const renderedSnapshot = {
+                    ...snapshot,
+                    backlog: parsedBacklog,
+                    discoveryIndex: parsedDiscovery,
+                };
+                await renderViews(paths, config, renderedSnapshot);
+            }
+        }
+        return report;
+    }
+}
+export function formatSddDedupApplyReport(report) {
+    const lines = [
+        `Dry run: ${report.dry_run ? 'yes' : 'no'}`,
+        `Changed: ${report.changed ? 'yes' : 'no'}`,
+        `Views rendered: ${report.rendered ? 'yes' : 'no'}`,
+        `Backlog candidates: ${report.backlog.scanned}`,
+        `Backlog reconciled: ${report.backlog.reconciled.join(', ') || '-'}`,
+        `Backlog skipped active: ${report.backlog.skipped_active.join(', ') || '-'}`,
+        `Backlog canonical updates: ${report.backlog.canonical_updates.join(', ') || '-'}`,
+        `Discovery candidates: ${report.discovery.scanned}`,
+        `Discovery reconciled: ${report.discovery.reconciled.join(', ') || '-'}`,
+        `Discovery skipped active: ${report.discovery.skipped_active.join(', ') || '-'}`,
+        `Discovery canonical updates: ${report.discovery.canonical_updates.join(', ') || '-'}`,
+    ];
+    if (report.warnings.length > 0) {
+        lines.push('Warnings:');
+        for (const warning of report.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=dedup-apply.service.js.map

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

@@ -0,0 +1,29 @@
+export interface FeatureLintOptions {
+    strict?: boolean;
+}
+export interface FeatureLintFinding {
+    severity: 'warning' | 'error';
+    code: string;
+    message: string;
+    evidence: Record<string, unknown>;
+}
+export interface FeatureLintReport {
+    feature_id: string;
+    title: string;
+    status: string;
+    ok: boolean;
+    level: 'pass' | 'warning' | 'error';
+    workspace_path: string;
+    counts: {
+        tasks: number;
+        lock_domains: number;
+        frontend_surfaces: number;
+        touched_modules: number;
+    };
+    findings: FeatureLintFinding[];
+}
+export declare class FeatureLintService {
+    execute(projectRoot: string, featureId: string, options?: FeatureLintOptions): Promise<FeatureLintReport>;
+}
+export declare function formatFeatureLintReport(report: FeatureLintReport): string;
+//# sourceMappingURL=feature-lint.service.d.ts.map

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

@@ -0,0 +1,146 @@
+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) {
+    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 tasksPath = path.join(workspacePath, names.tasks);
+        if (!existsSync(tasksPath)) {
+            return { workspacePath: relProjectPath(paths, workspacePath), error: `${names.tasks} not found.` };
+        }
+        const content = await fs.readFile(tasksPath, 'utf-8');
+        try {
+            return {
+                workspacePath: relProjectPath(paths, workspacePath),
+                tasks: parseWorkspaceYamlDocument('3-tasks.yaml', content),
+            };
+        }
+        catch (error) {
+            return {
+                workspacePath: relProjectPath(paths, workspacePath),
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    return { workspacePath: '', error: 'Feature workspace not found.' };
+}
+function addFinding(findings, severity, code, message, evidence) {
+    findings.push({ severity, code, message, evidence });
+}
+function lintFeatureShape(feature, taskCount, workspaceError) {
+    const findings = [];
+    if (workspaceError) {
+        addFinding(findings, 'error', 'workspace_tasks_unreadable', 'Feature tasks could not be read from the workspace.', {
+            error: workspaceError,
+        });
+    }
+    if (taskCount > 12) {
+        addFinding(findings, 'error', 'too_many_tasks', 'Feature has more than 12 tasks and should be split before execution.', {
+            tasks: taskCount,
+            threshold: 12,
+        });
+    }
+    else if (taskCount > 8) {
+        addFinding(findings, 'warning', 'many_tasks', 'Feature has more than 8 tasks; consider splitting if tasks touch different concerns.', {
+            tasks: taskCount,
+            threshold: 8,
+        });
+    }
+    if (feature.lock_domains.length > 3) {
+        addFinding(findings, 'error', 'too_many_lock_domains', 'Feature spans more than 3 lock domains.', {
+            lock_domains: feature.lock_domains,
+            threshold: 3,
+        });
+    }
+    else if (feature.lock_domains.length > 2) {
+        addFinding(findings, 'warning', 'many_lock_domains', 'Feature spans more than 2 lock domains.', {
+            lock_domains: feature.lock_domains,
+            threshold: 2,
+        });
+    }
+    if (feature.frontend_surface_tokens.length > 5) {
+        addFinding(findings, 'error', 'too_many_frontend_surfaces', 'Feature targets more than 5 frontend surfaces.', {
+            frontend_surface_tokens: feature.frontend_surface_tokens,
+            threshold: 5,
+        });
+    }
+    else if (feature.frontend_surface_tokens.length > 3) {
+        addFinding(findings, 'warning', 'many_frontend_surfaces', 'Feature targets more than 3 frontend surfaces.', {
+            frontend_surface_tokens: feature.frontend_surface_tokens,
+            threshold: 3,
+        });
+    }
+    if (feature.touches.length > 5) {
+        addFinding(findings, 'warning', 'broad_touched_modules', 'Feature touches more than 5 modules.', {
+            touches: feature.touches,
+            threshold: 5,
+        });
+    }
+    if (feature.touches.length > 3 && feature.lock_domains.length === 0) {
+        addFinding(findings, 'warning', 'missing_lock_domains', 'Broad feature has no lock domains declared.', {
+            touches: feature.touches,
+        });
+    }
+    return findings;
+}
+export class FeatureLintService {
+    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);
+        await ensureMemoryInitialized(paths);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const feature = snapshot.backlog.items.find((item) => item.id === featureId);
+        if (!feature) {
+            throw new Error(`Feature ${featureId} not found in backlog.`);
+        }
+        const workspace = await loadTasksDocument(paths, config, featureId);
+        const taskCount = workspace.tasks?.tasks.length ?? 0;
+        const findings = lintFeatureShape(feature, taskCount, workspace.error);
+        const hasErrors = findings.some((finding) => finding.severity === 'error');
+        const hasWarnings = findings.some((finding) => finding.severity === 'warning');
+        const ok = !hasErrors && !(options.strict && hasWarnings);
+        return {
+            feature_id: feature.id,
+            title: feature.title,
+            status: feature.status,
+            ok,
+            level: hasErrors ? 'error' : hasWarnings ? 'warning' : 'pass',
+            workspace_path: workspace.workspacePath,
+            counts: {
+                tasks: taskCount,
+                lock_domains: feature.lock_domains.length,
+                frontend_surfaces: feature.frontend_surface_tokens.length,
+                touched_modules: feature.touches.length,
+            },
+            findings,
+        };
+    }
+}
+export function formatFeatureLintReport(report) {
+    const lines = [
+        `Feature lint: ${report.feature_id} (${report.level})`,
+        `Status: ${report.status}`,
+        `Workspace: ${report.workspace_path || '-'}`,
+        `Counts: tasks=${report.counts.tasks}, locks=${report.counts.lock_domains}, surfaces=${report.counts.frontend_surfaces}, touched=${report.counts.touched_modules}`,
+    ];
+    if (report.findings.length === 0) {
+        lines.push('Findings: none');
+    }
+    else {
+        lines.push('Findings:');
+        for (const finding of report.findings) {
+            lines.push(`- [${finding.severity}] ${finding.code}: ${finding.message}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=feature-lint.service.js.map