@devtrack-solution/codesdd 1.2.2

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

@@ -0,0 +1,346 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class ContextService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, ref: string): Promise<{
+        sdd_pack_version: number;
+        target_id: string;
+        target_type: "FEAT";
+        summary: string;
+        objective: string;
+        expected_outcome: string;
+        system_impact: string;
+        architectural_impact: {
+            description: string;
+            affected_modules: string[];
+        } | null;
+        workspace_frontend_impact: {
+            status: "unknown" | "none" | "required";
+            description: string;
+        } | null;
+        affected_contracts: {
+            name: string;
+            change_type: string;
+        }[];
+        quality_strategy: {
+            unit_target: number;
+            integration_target: number;
+            approach: string;
+        } | null;
+        workspace: {
+            path: string;
+            state: "" | "active" | "planned" | "archived";
+            docs: string[];
+            schema_errors: string[];
+        };
+        origin: {
+            type: "radar" | "epic" | "direct" | "fast_track" | "frontend_gap" | "tech_debt";
+            ref: string;
+        };
+        related_discovery: string[];
+        related_gaps: string[];
+        recommended_skills: string[];
+        recommended_bundles: string[];
+        skill_execution_contract: {
+            required: boolean;
+            required_skill_ids: string[];
+            verification_location: string;
+            verification_rule: string;
+        };
+        change_name: string;
+        blocked_by: string[];
+        lock_domains: string[];
+        parallel_group: string | undefined;
+        planning_mode: "local_plan" | "direct_tasks";
+        flow_mode: "direto" | "padrao" | "rigoroso";
+        current_stage: "proposta" | "planejamento" | "tarefas" | "execucao" | "consolidacao";
+        gates: {
+            proposta: {
+                status: "nao_exigida" | "rascunho" | "pronta" | "aprovada";
+                approved_at?: string | undefined;
+                approved_by?: string | undefined;
+                note?: string | undefined;
+            };
+            planejamento: {
+                status: "nao_exigida" | "rascunho" | "pronta" | "aprovada";
+                approved_at?: string | undefined;
+                approved_by?: string | undefined;
+                note?: string | undefined;
+            };
+            tarefas: {
+                status: "nao_exigida" | "rascunho" | "pronta" | "aprovada";
+                approved_at?: string | undefined;
+                approved_by?: string | undefined;
+                note?: string | undefined;
+            };
+        };
+        frontend_impact_status: "unknown" | "none" | "required";
+        frontend_impact_reason: string;
+        frontend_impact_declared_at: string;
+        frontend_surface_tokens: string[];
+        quality_contract: {
+            version: 1;
+            enabled: boolean;
+            scope: string;
+            unit_target_percent: number;
+            integration_target_percent: number;
+            evidence_mode: "coverage" | "equivalence" | "hybrid";
+            enforcement: "advisory" | "blocking";
+            stack_profile: string;
+            required_axes: string[];
+            required_evidence: {
+                kind: string;
+                required: boolean;
+                status: "planned" | "provided" | "waived";
+                command?: string | undefined;
+                artifact?: string | undefined;
+                notes?: string | undefined;
+            }[];
+            exceptions: {
+                id: string;
+                scope: string;
+                reason: string;
+                accepted_risk: string;
+                compensating_control: string;
+                review_deadline: string;
+                approved_by: string;
+                approved_at?: string | undefined;
+            }[];
+            inherited_from?: string | undefined;
+            updated_at?: string | undefined;
+        } | null;
+        quality_artifact: string;
+        start_commit_sha: string;
+        next_action: string;
+        execution_kind: "documentation" | "feature" | "infra" | "migration" | "frontend_coverage";
+        produces: string[];
+        consumes: string[];
+        predecessor_outputs: {
+            feature_id: string;
+            status: "ARCHIVED" | "READY" | "IN_PROGRESS" | "DONE" | "BLOCKED" | "SYNC_REQUIRED" | "VERIFY_FAILED";
+            produces: string[];
+            summary: string;
+        }[];
+        relevant_adrs: string[];
+        relevant_services: {
+            id: string;
+            name: string;
+            contracts: string[];
+        }[];
+        relevant_contracts: string[];
+        relevant_frontend_decisions: {
+            id: string;
+            title: string;
+            status: "APPROVED" | "DISCARDED" | "SUPERSEDED" | "PROPOSED";
+            route_refs: string[];
+        }[];
+        read_order: string[];
+        active_path: string;
+        unresolved_blocked_by: string[];
+        lock_conflicts_with: string[];
+        readiness: "READY" | "BLOCKED" | "LOCK_CONFLICT";
+        core_docs: string[];
+        related_features?: undefined;
+        related_debates?: undefined;
+        source_feature?: undefined;
+        resolved_by_feature?: undefined;
+        routes?: undefined;
+        related_refs?: undefined;
+    } | {
+        sdd_pack_version: number;
+        target_id: string;
+        target_type: "RAD" | "EPIC";
+        summary: string;
+        quality_contract: {
+            version: 1;
+            enabled: boolean;
+            scope: string;
+            unit_target_percent: number;
+            integration_target_percent: number;
+            evidence_mode: "coverage" | "equivalence" | "hybrid";
+            enforcement: "advisory" | "blocking";
+            stack_profile: string;
+            required_axes: string[];
+            required_evidence: {
+                kind: string;
+                required: boolean;
+                status: "planned" | "provided" | "waived";
+                command?: string | undefined;
+                artifact?: string | undefined;
+                notes?: string | undefined;
+            }[];
+            exceptions: {
+                id: string;
+                scope: string;
+                reason: string;
+                accepted_risk: string;
+                compensating_control: string;
+                review_deadline: string;
+                approved_by: string;
+                approved_at?: string | undefined;
+            }[];
+            inherited_from?: string | undefined;
+            updated_at?: string | undefined;
+        } | null;
+        related_features: string[];
+        related_debates: string[];
+        read_order: string[];
+        core_docs: string[];
+        objective?: undefined;
+        expected_outcome?: undefined;
+        system_impact?: undefined;
+        architectural_impact?: undefined;
+        workspace_frontend_impact?: undefined;
+        affected_contracts?: undefined;
+        quality_strategy?: undefined;
+        workspace?: undefined;
+        origin?: undefined;
+        related_discovery?: undefined;
+        related_gaps?: undefined;
+        recommended_skills?: undefined;
+        recommended_bundles?: undefined;
+        skill_execution_contract?: undefined;
+        change_name?: undefined;
+        blocked_by?: undefined;
+        lock_domains?: undefined;
+        parallel_group?: undefined;
+        planning_mode?: undefined;
+        flow_mode?: undefined;
+        current_stage?: undefined;
+        gates?: undefined;
+        frontend_impact_status?: undefined;
+        frontend_impact_reason?: undefined;
+        frontend_impact_declared_at?: undefined;
+        frontend_surface_tokens?: undefined;
+        quality_artifact?: undefined;
+        start_commit_sha?: undefined;
+        next_action?: undefined;
+        execution_kind?: undefined;
+        produces?: undefined;
+        consumes?: undefined;
+        predecessor_outputs?: undefined;
+        relevant_adrs?: undefined;
+        relevant_services?: undefined;
+        relevant_contracts?: undefined;
+        relevant_frontend_decisions?: undefined;
+        active_path?: undefined;
+        unresolved_blocked_by?: undefined;
+        lock_conflicts_with?: undefined;
+        readiness?: undefined;
+        source_feature?: undefined;
+        resolved_by_feature?: undefined;
+        routes?: undefined;
+        related_refs?: undefined;
+    } | {
+        sdd_pack_version: number;
+        target_id: string;
+        target_type: "FGAP";
+        summary: string;
+        source_feature: string;
+        resolved_by_feature: string;
+        routes: string[];
+        read_order: string[];
+        core_docs: string[];
+        objective?: undefined;
+        expected_outcome?: undefined;
+        system_impact?: undefined;
+        architectural_impact?: undefined;
+        workspace_frontend_impact?: undefined;
+        affected_contracts?: undefined;
+        quality_strategy?: undefined;
+        workspace?: undefined;
+        origin?: undefined;
+        related_discovery?: undefined;
+        related_gaps?: undefined;
+        recommended_skills?: undefined;
+        recommended_bundles?: undefined;
+        skill_execution_contract?: undefined;
+        change_name?: undefined;
+        blocked_by?: undefined;
+        lock_domains?: undefined;
+        parallel_group?: undefined;
+        planning_mode?: undefined;
+        flow_mode?: undefined;
+        current_stage?: undefined;
+        gates?: undefined;
+        frontend_impact_status?: undefined;
+        frontend_impact_reason?: undefined;
+        frontend_impact_declared_at?: undefined;
+        frontend_surface_tokens?: undefined;
+        quality_contract?: undefined;
+        quality_artifact?: undefined;
+        start_commit_sha?: undefined;
+        next_action?: undefined;
+        execution_kind?: undefined;
+        produces?: undefined;
+        consumes?: undefined;
+        predecessor_outputs?: undefined;
+        relevant_adrs?: undefined;
+        relevant_services?: undefined;
+        relevant_contracts?: undefined;
+        relevant_frontend_decisions?: undefined;
+        active_path?: undefined;
+        unresolved_blocked_by?: undefined;
+        lock_conflicts_with?: undefined;
+        readiness?: undefined;
+        related_features?: undefined;
+        related_debates?: undefined;
+        related_refs?: undefined;
+    } | {
+        sdd_pack_version: number;
+        target_id: string;
+        target_type: "TD";
+        summary: string;
+        related_refs: string[];
+        read_order: string[];
+        core_docs: string[];
+        objective?: undefined;
+        expected_outcome?: undefined;
+        system_impact?: undefined;
+        architectural_impact?: undefined;
+        workspace_frontend_impact?: undefined;
+        affected_contracts?: undefined;
+        quality_strategy?: undefined;
+        workspace?: undefined;
+        origin?: undefined;
+        related_discovery?: undefined;
+        related_gaps?: undefined;
+        recommended_skills?: undefined;
+        recommended_bundles?: undefined;
+        skill_execution_contract?: undefined;
+        change_name?: undefined;
+        blocked_by?: undefined;
+        lock_domains?: undefined;
+        parallel_group?: undefined;
+        planning_mode?: undefined;
+        flow_mode?: undefined;
+        current_stage?: undefined;
+        gates?: undefined;
+        frontend_impact_status?: undefined;
+        frontend_impact_reason?: undefined;
+        frontend_impact_declared_at?: undefined;
+        frontend_surface_tokens?: undefined;
+        quality_contract?: undefined;
+        quality_artifact?: undefined;
+        start_commit_sha?: undefined;
+        next_action?: undefined;
+        execution_kind?: undefined;
+        produces?: undefined;
+        consumes?: undefined;
+        predecessor_outputs?: undefined;
+        relevant_adrs?: undefined;
+        relevant_services?: undefined;
+        relevant_contracts?: undefined;
+        relevant_frontend_decisions?: undefined;
+        active_path?: undefined;
+        unresolved_blocked_by?: undefined;
+        lock_conflicts_with?: undefined;
+        readiness?: undefined;
+        related_features?: undefined;
+        related_debates?: undefined;
+        source_feature?: undefined;
+        resolved_by_feature?: undefined;
+        routes?: undefined;
+    }>;
+}
+//# sourceMappingURL=context.service.d.ts.map

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

@@ -0,0 +1,278 @@
+import path from "node:path";
+import { existsSync, promises as fs } from "node:fs";
+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 { workspacePlanSchema, workspaceSpecSchema } from "../workspace-schemas.js";
+async function readYamlWorkspaceDoc(filePath, schema) {
+    const content = await fs.readFile(filePath, 'utf-8').catch(() => '');
+    if (!content.trim())
+        return { data: null, error: null };
+    try {
+        const result = schema.safeParse(parse(content));
+        if (result.success)
+            return { data: result.data, error: null };
+        return { data: null, error: result.error.message };
+    }
+    catch (error) {
+        return { data: null, error: error.message };
+    }
+}
+async function loadFeatureWorkspaceContext(paths, config, featureId) {
+    const names = activeDocNamesForLayout(config);
+    const roots = [
+        { state: 'active', dir: paths.activeDir },
+        { state: 'planned', dir: paths.plannedDir },
+        { state: 'archived', dir: paths.archivedDir },
+    ];
+    const root = roots.find((candidate) => existsSync(path.join(candidate.dir, featureId)));
+    if (!root) {
+        return { workspace_path: '', workspace_state: '', docs: [], spec: null, plan: null, schema_errors: [] };
+    }
+    const workspacePath = path.join(root.dir, featureId);
+    const canonicalDocs = [names.spec, names.plan, names.quality, names.tasks, names.changelog];
+    const docs = canonicalDocs
+        .map((name) => path.join(workspacePath, name))
+        .filter((filePath) => existsSync(filePath))
+        .map((filePath) => relProjectPath(paths, filePath));
+    const schemaErrors = [];
+    const specPath = path.join(workspacePath, names.spec);
+    const planPath = path.join(workspacePath, names.plan);
+    const spec = await readYamlWorkspaceDoc(specPath, workspaceSpecSchema);
+    const plan = await readYamlWorkspaceDoc(planPath, workspacePlanSchema);
+    if (spec.error)
+        schemaErrors.push(`${names.spec}: ${spec.error}`);
+    if (plan.error)
+        schemaErrors.push(`${names.plan}: ${plan.error}`);
+    return {
+        workspace_path: relProjectPath(paths, workspacePath),
+        workspace_state: root.state,
+        docs,
+        spec: spec.data,
+        plan: plan.data,
+        schema_errors: schemaErrors,
+    };
+}
+export class ContextService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, ref) {
+        const { config, paths } = await getRuntime(projectRoot);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const type = detectContextType(ref);
+        if (!type) {
+            throw new Error(`Referencia ${ref} invalida. Use FEAT/EPIC/RAD/FGAP/TD.`);
+        }
+        const coreDocs = [
+            coreDocRef(paths, 'index.md'),
+            coreDocRef(paths, 'arquitetura.md'),
+            coreDocRef(paths, 'servicos.md'),
+            coreDocRef(paths, 'spec-tecnologica.md'),
+            coreDocRef(paths, 'repo-map.md'),
+        ];
+        if (config.frontend.enabled) {
+            coreDocs.push(coreDocRef(paths, 'frontend-map.md'));
+            coreDocs.push(coreDocRef(paths, 'frontend-sitemap.md'));
+            coreDocs.push(coreDocRef(paths, 'frontend-decisions.md'));
+            coreDocs.push(planningDocRef(paths, 'frontend-auditoria.md'));
+        }
+        if (type === 'FEAT') {
+            const item = snapshot.backlog.items.find((entry) => entry.id === ref);
+            if (!item)
+                throw new Error(`Feature ${ref} nao encontrada.`);
+            const unresolved = unresolvedDependencies(item, snapshot.backlog.items);
+            const lockConflicts = lockConflictWithActive(item, snapshot.backlog.items);
+            const predecessorOutputs = item.blocked_by
+                .map((depId) => snapshot.backlog.items.find((entry) => entry.id === depId))
+                .filter((dep) => Boolean(dep))
+                .map((dep) => ({
+                feature_id: dep.id,
+                status: dep.status,
+                produces: dep.produces,
+                summary: dep.summary || '',
+            }));
+            const relevantServices = snapshot.serviceCatalog.services
+                .filter((service) => item.touches.includes(service.id) || item.title.includes(service.name))
+                .map((service) => ({
+                id: service.id,
+                name: service.name,
+                contracts: service.contracts,
+            }));
+            const relevantContracts = snapshot.integrationContracts.contracts.filter((contract) => [item.id, ...item.consumes, ...item.produces].some((token) => contract.includes(token)));
+            const frontendDecisionRefs = [item.id, item.origin_ref].filter((v) => Boolean(v));
+            const relevantFrontendDecisions = (snapshot.frontendDecisions?.items ?? [])
+                .filter((decision) => decision.related_refs.some((refId) => frontendDecisionRefs.includes(refId)))
+                .map((decision) => ({
+                id: decision.id,
+                title: decision.title,
+                status: decision.status,
+                route_refs: decision.route_refs,
+            }));
+            const relevantAdrs = await listAdrRefs(paths, [item.id, item.origin_ref || '', ...item.blocked_by]);
+            const workspace = await loadFeatureWorkspaceContext(paths, config, item.id);
+            const activePathAbs = featureActiveDir(paths, item.id);
+            const activePath = (await pathExists(activePathAbs))
+                ? relProjectPath(paths, activePathAbs)
+                : '';
+            const nextAction = item.status === 'IN_PROGRESS'
+                ? `${CLI_NAME} sdd finalize --ref ${item.id}`
+                : item.status === 'DONE'
+                    ? `${CLI_NAME} sdd next`
+                    : item.flow_mode === 'rigoroso' && !gateSatisfied(item.gates.proposta.status)
+                        ? `${CLI_NAME} sdd aprovar ${item.id} --etapa proposta`
+                        : item.flow_mode === 'rigoroso' && !gateSatisfied(item.gates.planejamento.status)
+                            ? `${CLI_NAME} sdd aprovar ${item.id} --etapa planejamento`
+                            : item.flow_mode === 'rigoroso' && !gateSatisfied(item.gates.tarefas.status)
+                                ? `${CLI_NAME} sdd aprovar ${item.id} --etapa tarefas`
+                                : `${CLI_NAME} sdd start ${item.id}`;
+            const readOrder = [
+                'README.md',
+                relProjectPath(paths, path.join(paths.memoryRoot, 'AGENT.md')),
+                coreDocRef(paths, 'index.md'),
+                coreDocRef(paths, 'arquitetura.md'),
+                coreDocRef(paths, 'servicos.md'),
+                coreDocRef(paths, 'spec-tecnologica.md'),
+                coreDocRef(paths, 'repo-map.md'),
+                ...relevantAdrs,
+                ...coreDocs.filter((doc) => doc.includes('frontend')),
+                ...workspace.docs,
+            ];
+            const docNames = activeDocNamesForLayout(config);
+            const qualityArtifact = workspace.workspace_path
+                ? relProjectPath(paths, path.join(paths.projectRoot, workspace.workspace_path, docNames.quality))
+                : '';
+            const requiredSkillEvidence = item.recommended_skills.filter(Boolean);
+            return {
+                sdd_pack_version: 1,
+                target_id: ref,
+                target_type: type,
+                summary: `${item.title} [${item.status}]`,
+                objective: workspace.spec?.objective || item.summary || '',
+                expected_outcome: workspace.spec?.expected_outcome || '',
+                system_impact: workspace.spec?.system_impact || '',
+                architectural_impact: workspace.plan?.architectural_impact || null,
+                workspace_frontend_impact: workspace.plan?.frontend_impact || null,
+                affected_contracts: workspace.plan?.affected_contracts || [],
+                quality_strategy: workspace.plan?.quality_strategy || null,
+                workspace: {
+                    path: workspace.workspace_path,
+                    state: workspace.workspace_state,
+                    docs: workspace.docs,
+                    schema_errors: workspace.schema_errors,
+                },
+                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))
+                        .map((record) => record.id)
+                    : [],
+                related_gaps: item.frontend_gap_refs,
+                recommended_skills: item.recommended_skills,
+                recommended_bundles: bundlesForSkills(snapshot.skillCatalog, item.recommended_skills),
+                skill_execution_contract: {
+                    required: requiredSkillEvidence.length > 0,
+                    required_skill_ids: requiredSkillEvidence,
+                    verification_location: qualityArtifact,
+                    verification_rule: requiredSkillEvidence.length > 0
+                        ? 'Record one skill_evidence entry per required skill before finalize.'
+                        : 'No skill evidence required for this feature.',
+                },
+                change_name: item.change_name || '',
+                blocked_by: item.blocked_by,
+                lock_domains: item.lock_domains,
+                parallel_group: item.parallel_group,
+                planning_mode: item.planning_mode,
+                flow_mode: item.flow_mode,
+                current_stage: item.current_stage,
+                gates: item.gates,
+                frontend_impact_status: item.frontend_impact_status,
+                frontend_impact_reason: item.frontend_impact_reason || '',
+                frontend_impact_declared_at: item.frontend_impact_declared_at || '',
+                frontend_surface_tokens: item.frontend_surface_tokens,
+                quality_contract: item.quality_contract || null,
+                quality_artifact: qualityArtifact,
+                start_commit_sha: item.start_commit_sha || '',
+                next_action: nextAction,
+                execution_kind: item.execution_kind,
+                produces: item.produces,
+                consumes: item.consumes,
+                predecessor_outputs: predecessorOutputs,
+                relevant_adrs: relevantAdrs,
+                relevant_services: relevantServices,
+                relevant_contracts: relevantContracts,
+                relevant_frontend_decisions: relevantFrontendDecisions,
+                read_order: Array.from(new Set(readOrder)),
+                active_path: activePath,
+                unresolved_blocked_by: unresolved,
+                lock_conflicts_with: lockConflicts,
+                readiness: featureReadiness(item, snapshot.backlog.items),
+                core_docs: coreDocs,
+            };
+        }
+        if (type === 'RAD' || type === 'EPIC') {
+            const radar = snapshot.discoveryIndex.records.find((record) => record.id === ref && (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);
+            return {
+                sdd_pack_version: 1,
+                target_id: ref,
+                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))
+                    .map((record) => record.id),
+                read_order: [
+                    'README.md',
+                    relProjectPath(paths, path.join(paths.memoryRoot, 'AGENT.md')),
+                    coreDocRef(paths, 'index.md'),
+                    planningDocRef(paths, 'backlog-graph.md'),
+                ],
+                core_docs: coreDocs,
+            };
+        }
+        if (type === 'FGAP') {
+            const gap = snapshot.frontendGaps?.items.find((item) => item.id === ref);
+            if (!gap)
+                throw new Error(`Gap de frontend ${ref} nao encontrado.`);
+            return {
+                sdd_pack_version: 1,
+                target_id: ref,
+                target_type: type,
+                summary: `${gap.title} [${gap.status}]`,
+                source_feature: gap.origin_feature || '',
+                resolved_by_feature: gap.resolved_by_feature || '',
+                routes: gap.route_targets,
+                read_order: [
+                    'README.md',
+                    relProjectPath(paths, path.join(paths.memoryRoot, 'AGENT.md')),
+                    coreDocRef(paths, 'frontend-map.md'),
+                    planningDocRef(paths, 'frontend-gaps.md'),
+                ],
+                core_docs: coreDocs,
+            };
+        }
+        const debt = snapshot.techDebt.items.find((item) => item.id === ref);
+        if (!debt)
+            throw new Error(`Divida tecnica ${ref} nao encontrada.`);
+        return {
+            sdd_pack_version: 1,
+            target_id: ref,
+            target_type: type,
+            summary: `${debt.title} [${debt.status}]`,
+            related_refs: debt.related_refs,
+            read_order: [
+                'README.md',
+                relProjectPath(paths, path.join(paths.memoryRoot, 'AGENT.md')),
+                planningDocRef(paths, 'tech-debt.md'),
+            ],
+            core_docs: coreDocs,
+        };
+    }
+}
+//# sourceMappingURL=context.service.js.map

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

@@ -0,0 +1,16 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class DebateService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, insightId: string, options?: {
+        title?: string;
+        render?: boolean;
+        agent?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+        filePath: string;
+        reused: boolean;
+    }>;
+}
+//# sourceMappingURL=debate.service.d.ts.map