@mcoda/core 0.1.27 → 0.1.28

package/dist/services/planning/CreateTasksService.js

@@ -13,6 +13,7 @@ import { TaskOrderingService } from "../backlog/TaskOrderingService.js";
 import { QaTestCommandBuilder } from "../execution/QaTestCommandBuilder.js";
 import { createEpicKeyGenerator, createStoryKeyGenerator, createTaskKeyGenerator, } from "./KeyHelpers.js";
 import { TaskSufficiencyService } from "./TaskSufficiencyService.js";
+import { SdsPreflightService } from "./SdsPreflightService.js";
 const formatBullets = (items, fallback) => {
     if (!items || items.length === 0)
         return `- ${fallback}`;
@@ -257,6 +258,14 @@ const extractMarkdownHeadings = (value, limit) => {
             !line.startsWith("*")) {
             headings.push(line);
         }
+        else {
+            const numberedHeading = line.match(/^(\d+(?:\.\d+)+)\s+(.+)$/);
+            if (numberedHeading) {
+                const headingText = `${numberedHeading[1]} ${numberedHeading[2]}`.trim();
+                if (/[a-z]/i.test(headingText))
+                    headings.push(headingText);
+            }
+        }
         if (headings.length >= limit)
             break;
     }
@@ -398,6 +407,89 @@ const extractJsonObjects = (value) => {
     }
     return results;
 };
+const normalizeAgentFailoverEvents = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    const events = [];
+    for (const entry of value) {
+        if (!isPlainObject(entry))
+            continue;
+        if (typeof entry.type !== "string" || entry.type.trim().length === 0)
+            continue;
+        events.push({ ...entry });
+    }
+    return events;
+};
+const mergeAgentFailoverEvents = (left, right) => {
+    if (!left.length)
+        return right;
+    if (!right.length)
+        return left;
+    const seen = new Set();
+    const merged = [];
+    const signature = (event) => [
+        event.type ?? "",
+        event.fromAgentId ?? "",
+        event.toAgentId ?? "",
+        event.at ?? "",
+        event.until ?? "",
+        event.durationMs ?? "",
+    ].join("|");
+    for (const event of [...left, ...right]) {
+        const key = signature(event);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(event);
+    }
+    return merged;
+};
+const mergeAgentInvocationMetadata = (current, incoming) => {
+    if (!current && !incoming)
+        return undefined;
+    if (!incoming)
+        return current;
+    if (!current)
+        return { ...incoming };
+    const merged = { ...current, ...incoming };
+    const currentEvents = normalizeAgentFailoverEvents(current.failoverEvents);
+    const incomingEvents = normalizeAgentFailoverEvents(incoming.failoverEvents);
+    if (currentEvents.length > 0 || incomingEvents.length > 0) {
+        merged.failoverEvents = mergeAgentFailoverEvents(currentEvents, incomingEvents);
+    }
+    return merged;
+};
+const summarizeAgentFailoverEvent = (event) => {
+    const type = String(event.type ?? "unknown");
+    if (type === "switch_agent") {
+        const from = typeof event.fromAgentId === "string" ? event.fromAgentId : "unknown";
+        const to = typeof event.toAgentId === "string" ? event.toAgentId : "unknown";
+        return `switch_agent ${from} -> ${to}`;
+    }
+    if (type === "sleep_until_reset") {
+        const duration = typeof event.durationMs === "number" && Number.isFinite(event.durationMs)
+            ? `${Math.round(event.durationMs / 1000)}s`
+            : "unknown duration";
+        const until = typeof event.until === "string" ? event.until : "unknown";
+        return `sleep_until_reset ${duration} (until ${until})`;
+    }
+    if (type === "stream_restart_after_limit") {
+        const from = typeof event.fromAgentId === "string" ? event.fromAgentId : "unknown";
+        return `stream_restart_after_limit from ${from}`;
+    }
+    return type;
+};
+const resolveTerminalFailoverAgentId = (events, fallbackAgentId) => {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type !== "switch_agent")
+            continue;
+        if (typeof event.toAgentId === "string" && event.toAgentId.trim().length > 0) {
+            return event.toAgentId;
+        }
+    }
+    return fallbackAgentId;
+};
 const compactNarrative = (value, fallback, maxLines = 5) => {
     if (!value || value.trim().length === 0)
         return fallback;
@@ -721,6 +813,7 @@ export class CreateTasksService {
         this.ratingService = deps.ratingService;
         this.taskOrderingFactory = deps.taskOrderingFactory ?? TaskOrderingService.create;
         this.taskSufficiencyFactory = deps.taskSufficiencyFactory ?? TaskSufficiencyService.create;
+        this.sdsPreflightFactory = deps.sdsPreflightFactory ?? SdsPreflightService.create;
     }
     static async create(workspace) {
         const repo = await GlobalRepository.create();
@@ -742,6 +835,7 @@ export class CreateTasksService {
             workspaceRepo,
             routingService,
             taskSufficiencyFactory: TaskSufficiencyService.create,
+            sdsPreflightFactory: SdsPreflightService.create,
         });
     }
     async close() {
@@ -830,6 +924,20 @@ export class CreateTasksService {
         const resolved = path.isAbsolute(input) ? input : path.join(this.workspace.workspaceRoot, input);
         return path.resolve(resolved).toLowerCase();
     }
+    mergeDocInputs(primary, extras) {
+        const merged = [];
+        const seen = new Set();
+        for (const input of [...primary, ...extras]) {
+            if (!input?.trim())
+                continue;
+            const key = this.normalizeDocInputForSet(input);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            merged.push(input);
+        }
+        return merged;
+    }
     docIdentity(doc) {
         const pathKey = `${doc.path ?? ""}`.trim().toLowerCase();
         const idKey = `${doc.id ?? ""}`.trim().toLowerCase();
@@ -2100,8 +2208,11 @@ export class CreateTasksService {
             const segmentHeadings = (doc.segments ?? [])
                 .map((segment) => segment.heading?.trim())
                 .filter((heading) => Boolean(heading));
+            const segmentContentHeadings = (doc.segments ?? [])
+                .flatMap((segment) => extractMarkdownHeadings(segment.content ?? "", Math.max(6, Math.ceil(limit / 4))))
+                .slice(0, limit);
             const contentHeadings = extractMarkdownHeadings(doc.content ?? "", limit);
-            for (const heading of [...segmentHeadings, ...contentHeadings]) {
+            for (const heading of [...segmentHeadings, ...segmentContentHeadings, ...contentHeadings]) {
                 const normalized = heading.replace(/[`*_]/g, "").trim();
                 if (!normalized)
                     continue;
@@ -2345,6 +2456,7 @@ export class CreateTasksService {
     async invokeAgentWithRetry(agent, prompt, action, stream, jobId, commandRunId, metadata) {
         const startedAt = Date.now();
         let output = "";
+        let invocationMetadata;
         const logChunk = async (chunk) => {
             if (!chunk)
                 return;
@@ -2352,17 +2464,51 @@ export class CreateTasksService {
             if (stream)
                 process.stdout.write(chunk);
         };
+        const baseInvocationMetadata = {
+            command: "create-tasks",
+            action,
+            phase: `create_tasks_${action}`,
+        };
+        const logFailoverEvents = async (events) => {
+            if (!events.length)
+                return;
+            for (const event of events) {
+                await this.jobService.appendLog(jobId, `[create-tasks] agent failover (${action}): ${summarizeAgentFailoverEvent(event)}\n`);
+            }
+        };
+        const resolveUsageAgent = async (events) => {
+            const agentId = resolveTerminalFailoverAgentId(events, agent.id);
+            if (agentId === agent.id) {
+                return { id: agent.id, defaultModel: agent.defaultModel };
+            }
+            try {
+                const resolved = await this.agentService.resolveAgent(agentId);
+                return { id: resolved.id, defaultModel: resolved.defaultModel };
+            }
+            catch (error) {
+                await this.jobService.appendLog(jobId, `[create-tasks] unable to resolve failover agent (${agentId}) for usage accounting: ${error instanceof Error ? error.message : String(error)}\n`);
+                return { id: agent.id, defaultModel: agent.defaultModel };
+            }
+        };
         try {
             if (stream) {
-                const gen = await this.agentService.invokeStream(agent.id, { input: prompt });
+                const gen = await this.agentService.invokeStream(agent.id, {
+                    input: prompt,
+                    metadata: baseInvocationMetadata,
+                });
                 for await (const chunk of gen) {
                     output += chunk.output ?? "";
+                    invocationMetadata = mergeAgentInvocationMetadata(invocationMetadata, chunk.metadata);
                     await logChunk(chunk.output);
                 }
             }
             else {
-                const result = await this.agentService.invoke(agent.id, { input: prompt });
+                const result = await this.agentService.invoke(agent.id, {
+                    input: prompt,
+                    metadata: baseInvocationMetadata,
+                });
                 output = result.output ?? "";
+                invocationMetadata = mergeAgentInvocationMetadata(invocationMetadata, result.metadata);
                 await logChunk(output);
             }
         }
@@ -2379,10 +2525,22 @@ export class CreateTasksService {
                 `Original content:\n${output}`,
             ].join("\n\n");
             try {
-                const fix = await this.agentService.invoke(agent.id, { input: fixPrompt });
+                let retryInvocationMetadata;
+                const fix = await this.agentService.invoke(agent.id, {
+                    input: fixPrompt,
+                    metadata: {
+                        ...baseInvocationMetadata,
+                        attempt: 2,
+                        stage: "json_repair",
+                    },
+                });
                 output = fix.output ?? "";
+                retryInvocationMetadata = mergeAgentInvocationMetadata(retryInvocationMetadata, fix.metadata);
                 parsed = extractJson(output);
                 if (parsed) {
+                    const failoverEvents = normalizeAgentFailoverEvents(retryInvocationMetadata?.failoverEvents);
+                    await logFailoverEvents(failoverEvents);
+                    const usageAgent = await resolveUsageAgent(failoverEvents);
                     const promptTokens = estimateTokens(prompt);
                     const completionTokens = estimateTokens(output);
                     const durationSeconds = (Date.now() - startedAt) / 1000;
@@ -2391,8 +2549,8 @@ export class CreateTasksService {
                         workspaceId: this.workspace.workspaceId,
                         jobId,
                         commandRunId,
-                        agentId: agent.id,
-                        modelName: agent.defaultModel,
+                        agentId: usageAgent.id,
+                        modelName: usageAgent.defaultModel,
                         promptTokens,
                         completionTokens,
                         tokensPrompt: promptTokens,
@@ -2403,6 +2561,7 @@ export class CreateTasksService {
                             action: `create_tasks_${action}`,
                             phase: `create_tasks_${action}`,
                             attempt,
+                            failoverEvents: failoverEvents.length > 0 ? failoverEvents : undefined,
                             ...(metadata ?? {}),
                         },
                     });
@@ -2416,6 +2575,9 @@ export class CreateTasksService {
         if (!parsed) {
             throw new Error(`Agent output was not valid JSON for ${action}`);
         }
+        const failoverEvents = normalizeAgentFailoverEvents(invocationMetadata?.failoverEvents);
+        await logFailoverEvents(failoverEvents);
+        const usageAgent = await resolveUsageAgent(failoverEvents);
         const promptTokens = estimateTokens(prompt);
         const completionTokens = estimateTokens(output);
         const durationSeconds = (Date.now() - startedAt) / 1000;
@@ -2424,8 +2586,8 @@ export class CreateTasksService {
             workspaceId: this.workspace.workspaceId,
             jobId,
             commandRunId,
-            agentId: agent.id,
-            modelName: agent.defaultModel,
+            agentId: usageAgent.id,
+            modelName: usageAgent.defaultModel,
             promptTokens,
             completionTokens,
             tokensPrompt: promptTokens,
@@ -2436,6 +2598,7 @@ export class CreateTasksService {
                 action: `create_tasks_${action}`,
                 phase: `create_tasks_${action}`,
                 attempt: 1,
+                failoverEvents: failoverEvents.length > 0 ? failoverEvents : undefined,
                 ...(metadata ?? {}),
             },
         });
@@ -3032,6 +3195,7 @@ export class CreateTasksService {
                 inputs: options.inputs,
                 agent: options.agentName,
                 agentStream,
+                sdsPreflightCommit: options.sdsPreflightCommit === true,
             },
         });
         let lastError;
@@ -3042,8 +3206,110 @@ export class CreateTasksService {
                     name: options.projectKey,
                     description: `Workspace project ${options.projectKey}`,
                 });
-                const docs = await this.prepareDocs(options.inputs);
-                const { docSummary, warnings: docWarnings } = this.buildDocContext(docs);
+                let sdsPreflight;
+                let sdsPreflightError;
+                if (this.sdsPreflightFactory) {
+                    let sdsPreflightCloseError;
+                    try {
+                        const preflightService = await this.sdsPreflightFactory(this.workspace);
+                        try {
+                            sdsPreflight = await preflightService.runPreflight({
+                                workspace: options.workspace,
+                                projectKey: options.projectKey,
+                                inputPaths: options.inputs,
+                                sdsPaths: options.inputs,
+                                writeArtifacts: true,
+                                applyToSds: true,
+                                commitAppliedChanges: options.sdsPreflightCommit === true,
+                                commitMessage: options.sdsPreflightCommitMessage,
+                            });
+                        }
+                        finally {
+                            try {
+                                await preflightService.close();
+                            }
+                            catch (closeError) {
+                                sdsPreflightCloseError = closeError?.message ?? String(closeError);
+                                await this.jobService.appendLog(job.id, `SDS preflight close warning: ${sdsPreflightCloseError}\n`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        sdsPreflightError = error?.message ?? String(error);
+                    }
+                    if (!sdsPreflight) {
+                        const message = `create-tasks blocked: SDS preflight failed before backlog generation (${sdsPreflightError ?? "unknown error"}).`;
+                        await this.jobService.writeCheckpoint(job.id, {
+                            stage: "sds_preflight",
+                            timestamp: new Date().toISOString(),
+                            details: {
+                                status: "failed",
+                                error: message,
+                                readyForPlanning: false,
+                                qualityStatus: undefined,
+                                sourceSdsCount: 0,
+                                issueCount: 0,
+                                blockingIssueCount: 0,
+                                questionCount: 0,
+                                requiredQuestionCount: 0,
+                                reportPath: undefined,
+                                openQuestionsPath: undefined,
+                                gapAddendumPath: undefined,
+                                warnings: [],
+                            },
+                        });
+                        throw new Error(message);
+                    }
+                    const preflightWarnings = uniqueStrings([
+                        ...(sdsPreflight.warnings ?? []),
+                        ...(sdsPreflightCloseError ? [`SDS preflight close warning: ${sdsPreflightCloseError}`] : []),
+                    ]);
+                    const blockingReasons = [];
+                    if (sdsPreflight.qualityStatus === "fail") {
+                        blockingReasons.push("SDS quality gates failed.");
+                    }
+                    if (sdsPreflight.blockingIssueCount > 0) {
+                        blockingReasons.push(`Blocking SDS issues: ${sdsPreflight.blockingIssueCount}.`);
+                    }
+                    if (sdsPreflight.requiredQuestionCount > 0) {
+                        blockingReasons.push(`Required open questions remaining: ${sdsPreflight.requiredQuestionCount}.`);
+                    }
+                    if (!sdsPreflight.readyForPlanning) {
+                        blockingReasons.push("SDS preflight reported planning context is not ready.");
+                    }
+                    if (blockingReasons.length > 0) {
+                        sdsPreflightError = blockingReasons.join(" ");
+                    }
+                    await this.jobService.writeCheckpoint(job.id, {
+                        stage: "sds_preflight",
+                        timestamp: new Date().toISOString(),
+                        details: {
+                            status: blockingReasons.length > 0 ? "blocked" : "succeeded",
+                            error: sdsPreflightError,
+                            readyForPlanning: sdsPreflight.readyForPlanning,
+                            qualityStatus: sdsPreflight.qualityStatus,
+                            sourceSdsCount: sdsPreflight.sourceSdsPaths.length,
+                            issueCount: sdsPreflight.issueCount,
+                            blockingIssueCount: sdsPreflight.blockingIssueCount,
+                            questionCount: sdsPreflight.questionCount,
+                            requiredQuestionCount: sdsPreflight.requiredQuestionCount,
+                            reportPath: sdsPreflight.reportPath,
+                            openQuestionsPath: sdsPreflight.openQuestionsPath,
+                            gapAddendumPath: sdsPreflight.gapAddendumPath,
+                            appliedToSds: sdsPreflight.appliedToSds,
+                            appliedSdsCount: sdsPreflight.appliedSdsPaths.length,
+                            commitHash: sdsPreflight.commitHash,
+                            warnings: preflightWarnings,
+                        },
+                    });
+                    if (blockingReasons.length > 0) {
+                        throw new Error(`create-tasks blocked by SDS preflight. ${blockingReasons.join(" ")} Report: ${sdsPreflight.reportPath}`);
+                    }
+                }
+                const preflightDocInputs = this.mergeDocInputs(options.inputs, sdsPreflight ? [...sdsPreflight.sourceSdsPaths, ...sdsPreflight.generatedDocPaths] : []);
+                const docs = await this.prepareDocs(preflightDocInputs);
+                const { docSummary, warnings: indexedDocWarnings } = this.buildDocContext(docs);
+                const docWarnings = uniqueStrings([...(sdsPreflight?.warnings ?? []), ...indexedDocWarnings]);
                 const discoveryGraph = this.buildServiceDependencyGraph({ epics: [], stories: [], tasks: [] }, docs);
                 const projectBuildMethod = this.buildProjectConstructionMethod(docs, discoveryGraph);
                 const projectBuildPlan = this.buildProjectPlanArtifact(options.projectKey, docs, discoveryGraph, projectBuildMethod);
@@ -3139,57 +3405,83 @@ export class CreateTasksService {
                 let sufficiencyAudit;
                 let sufficiencyAuditError;
                 if (this.taskSufficiencyFactory) {
+                    let sufficiencyCloseError;
                     try {
                         const sufficiencyService = await this.taskSufficiencyFactory(this.workspace);
                         try {
-                            try {
-                                sufficiencyAudit = await sufficiencyService.runAudit({
-                                    workspace: options.workspace,
-                                    projectKey: options.projectKey,
-                                    sourceCommand: "create-tasks",
-                                });
-                            }
-                            catch (error) {
-                                sufficiencyAuditError = error?.message ?? String(error);
-                                await this.jobService.appendLog(job.id, `Task sufficiency audit failed; continuing with created backlog: ${sufficiencyAuditError}\n`);
-                            }
+                            sufficiencyAudit = await sufficiencyService.runAudit({
+                                workspace: options.workspace,
+                                projectKey: options.projectKey,
+                                sourceCommand: "create-tasks",
+                            });
                         }
                         finally {
                             try {
                                 await sufficiencyService.close();
                             }
                             catch (closeError) {
-                                const closeMessage = closeError?.message ?? String(closeError);
-                                const details = `Task sufficiency audit close failed; continuing with created backlog: ${closeMessage}`;
-                                sufficiencyAuditError = sufficiencyAuditError ? `${sufficiencyAuditError}; ${details}` : details;
-                                await this.jobService.appendLog(job.id, `${details}\n`);
+                                sufficiencyCloseError = closeError?.message ?? String(closeError);
+                                await this.jobService.appendLog(job.id, `Task sufficiency audit close warning: ${sufficiencyCloseError}\n`);
                             }
                         }
                     }
                     catch (error) {
                         sufficiencyAuditError = error?.message ?? String(error);
-                        await this.jobService.appendLog(job.id, `Task sufficiency audit setup failed; continuing with created backlog: ${sufficiencyAuditError}\n`);
+                    }
+                    if (!sufficiencyAudit) {
+                        const message = `create-tasks blocked: task sufficiency audit failed (${sufficiencyAuditError ?? "unknown error"}).`;
+                        await this.jobService.writeCheckpoint(job.id, {
+                            stage: "task_sufficiency_audit",
+                            timestamp: new Date().toISOString(),
+                            details: {
+                                status: "failed",
+                                error: message,
+                                jobId: undefined,
+                                commandRunId: undefined,
+                                satisfied: false,
+                                dryRun: undefined,
+                                totalTasksAdded: undefined,
+                                totalTasksUpdated: undefined,
+                                finalCoverageRatio: undefined,
+                                reportPath: undefined,
+                                remainingSectionCount: undefined,
+                                remainingFolderCount: undefined,
+                                remainingGapCount: undefined,
+                                warnings: [],
+                            },
+                        });
+                        throw new Error(message);
+                    }
+                    const sufficiencyWarnings = uniqueStrings([
+                        ...(sufficiencyAudit.warnings ?? []),
+                        ...(sufficiencyCloseError ? [`Task sufficiency audit close warning: ${sufficiencyCloseError}`] : []),
+                    ]);
+                    if (!sufficiencyAudit.satisfied) {
+                        sufficiencyAuditError = `SDS coverage target not reached (coverage=${sufficiencyAudit.finalCoverageRatio}, remaining gaps=${sufficiencyAudit.remainingGaps.total}).`;
                     }
                     await this.jobService.writeCheckpoint(job.id, {
                         stage: "task_sufficiency_audit",
                         timestamp: new Date().toISOString(),
                         details: {
-                            status: sufficiencyAudit ? "succeeded" : "failed",
+                            status: sufficiencyAudit.satisfied ? "succeeded" : "blocked",
                             error: sufficiencyAuditError,
-                            jobId: sufficiencyAudit?.jobId,
-                            commandRunId: sufficiencyAudit?.commandRunId,
-                            satisfied: sufficiencyAudit?.satisfied,
-                            dryRun: sufficiencyAudit?.dryRun,
-                            totalTasksAdded: sufficiencyAudit?.totalTasksAdded,
-                            totalTasksUpdated: sufficiencyAudit?.totalTasksUpdated,
-                            finalCoverageRatio: sufficiencyAudit?.finalCoverageRatio,
-                            reportPath: sufficiencyAudit?.reportPath,
-                            remainingSectionCount: sufficiencyAudit?.remainingSectionHeadings.length,
-                            remainingFolderCount: sufficiencyAudit?.remainingFolderEntries.length,
-                            remainingGapCount: sufficiencyAudit?.remainingGaps.total,
-                            warnings: sufficiencyAudit?.warnings,
+                            jobId: sufficiencyAudit.jobId,
+                            commandRunId: sufficiencyAudit.commandRunId,
+                            satisfied: sufficiencyAudit.satisfied,
+                            dryRun: sufficiencyAudit.dryRun,
+                            totalTasksAdded: sufficiencyAudit.totalTasksAdded,
+                            totalTasksUpdated: sufficiencyAudit.totalTasksUpdated,
+                            finalCoverageRatio: sufficiencyAudit.finalCoverageRatio,
+                            reportPath: sufficiencyAudit.reportPath,
+                            remainingSectionCount: sufficiencyAudit.remainingSectionHeadings.length,
+                            remainingFolderCount: sufficiencyAudit.remainingFolderEntries.length,
+                            remainingGapCount: sufficiencyAudit.remainingGaps.total,
+                            warnings: sufficiencyWarnings,
                         },
                     });
+                    if (!sufficiencyAudit.satisfied) {
+                        throw new Error(`create-tasks blocked: task sufficiency audit did not reach full coverage. Report: ${sufficiencyAudit.reportPath}`);
+                    }
                 }
                 await this.jobService.updateJobStatus(job.id, "completed", {
                     payload: {
@@ -3201,6 +3493,25 @@ export class CreateTasksService {
                         planFolder: folder,
                         planSource,
                         fallbackReason,
+                        sdsPreflight: sdsPreflight
+                            ? {
+                                readyForPlanning: sdsPreflight.readyForPlanning,
+                                qualityStatus: sdsPreflight.qualityStatus,
+                                sourceSdsCount: sdsPreflight.sourceSdsPaths.length,
+                                issueCount: sdsPreflight.issueCount,
+                                blockingIssueCount: sdsPreflight.blockingIssueCount,
+                                questionCount: sdsPreflight.questionCount,
+                                requiredQuestionCount: sdsPreflight.requiredQuestionCount,
+                                appliedToSds: sdsPreflight.appliedToSds,
+                                appliedSdsPaths: sdsPreflight.appliedSdsPaths,
+                                commitHash: sdsPreflight.commitHash,
+                                reportPath: sdsPreflight.reportPath,
+                                openQuestionsPath: sdsPreflight.openQuestionsPath,
+                                gapAddendumPath: sdsPreflight.gapAddendumPath,
+                                warnings: sdsPreflight.warnings,
+                            }
+                            : undefined,
+                        sdsPreflightError,
                         sufficiencyAudit: sufficiencyAudit
                             ? {
                                 jobId: sufficiencyAudit.jobId,

package/dist/services/planning/SdsPreflightService.d.ts

@@ -0,0 +1,98 @@
+import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+import { type ReviewSeverity } from "../docs/review/ReviewTypes.js";
+export interface SdsPreflightQuestionAnswer {
+    question: string;
+    normalized: string;
+    required: boolean;
+    target: string;
+    sourcePath?: string;
+    line?: number;
+    answer: string;
+    rationale: string;
+    assumptions: string[];
+}
+export interface SdsPreflightIssueSummary {
+    gateId: string;
+    gateName: string;
+    severity: ReviewSeverity;
+    category: string;
+    message: string;
+    remediation: string;
+    location: string;
+}
+export interface SdsPreflightResult {
+    projectKey: string;
+    generatedAt: string;
+    readyForPlanning: boolean;
+    qualityStatus: "pass" | "warn" | "fail";
+    sourceSdsPaths: string[];
+    reportPath: string;
+    openQuestionsPath: string;
+    gapAddendumPath: string;
+    generatedDocPaths: string[];
+    questionCount: number;
+    requiredQuestionCount: number;
+    issueCount: number;
+    blockingIssueCount: number;
+    appliedToSds: boolean;
+    appliedSdsPaths: string[];
+    commitHash?: string;
+    issues: SdsPreflightIssueSummary[];
+    questions: SdsPreflightQuestionAnswer[];
+    warnings: string[];
+}
+export interface SdsPreflightOptions {
+    workspace: WorkspaceResolution;
+    projectKey: string;
+    inputPaths?: string[];
+    sdsPaths?: string[];
+    writeArtifacts?: boolean;
+    applyToSds?: boolean;
+    commitAppliedChanges?: boolean;
+    commitMessage?: string;
+}
+export declare class SdsPreflightService {
+    private readonly workspace;
+    constructor(workspace: WorkspaceResolution);
+    static create(workspace: WorkspaceResolution): Promise<SdsPreflightService>;
+    close(): Promise<void>;
+    private walkCandidates;
+    private collectPathCandidates;
+    private discoverSdsPaths;
+    private isLikelySdsPath;
+    private resolveSdsPaths;
+    private buildArtifacts;
+    private getGateRunners;
+    private dedupeIssues;
+    private resolveWorkspacePath;
+    private collectSignalsFromContent;
+    private collectSignalsByPath;
+    private signalsForPath;
+    private answerForQuestion;
+    private managedFolderTreeSection;
+    private managedTechnologySection;
+    private managedPolicyTelemetrySection;
+    private managedOperationsSection;
+    private managedAdapterSection;
+    private shouldReplaceIssueLine;
+    private replacementForIssue;
+    private extractQuestionAnswers;
+    private issueSection;
+    private remediationLines;
+    private verificationLines;
+    private buildAddendum;
+    private buildQuestionsDoc;
+    private summarizeIssues;
+    private collectGateResults;
+    private issueMatchesPath;
+    private questionMatchesPath;
+    private normalizeResolvedText;
+    private buildLineReplacementsForPath;
+    private applyLineReplacements;
+    private buildManagedSdsBlock;
+    private upsertManagedSdsBlock;
+    private applyPreflightRemediationsToSds;
+    private commitAppliedSdsChanges;
+    runPreflight(options: SdsPreflightOptions): Promise<SdsPreflightResult>;
+}
+//# sourceMappingURL=SdsPreflightService.d.ts.map

package/dist/services/planning/SdsPreflightService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdsPreflightService.d.ts","sourceRoot":"","sources":["../../../src/services/planning/SdsPreflightService.ts"],"names":[],"mappings":"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"}