@jamesaphoenix/tx-core 0.8.1 → 0.9.2

package/dist/internal/cycle-scan-service-impl.js

@@ -0,0 +1,877 @@
+/**
+ * CycleScanService — Cycle-Based Issue Discovery
+ *
+ * Orchestrates sub-agent swarms via AgentService to scan for codebase issues,
+ * deduplicates findings against known issues using an LLM-as-judge, and
+ * optionally fixes them. Repeats in rounds within each cycle until convergence.
+ */
+import { Context, Effect, Layer } from "effect";
+import { mkdirSync } from "node:fs";
+import { appendFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { LOSS_WEIGHTS } from "@jamesaphoenix/tx-types";
+import { CycleScanError } from "../errors.js";
+import { AgentService } from "../services/agent-service.js";
+import { SqliteClient } from "../db.js";
+// =============================================================================
+// JSON Schemas for Structured Output
+// =============================================================================
+const FINDINGS_SCHEMA = {
+    type: "object",
+    properties: {
+        findings: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    title: { type: "string", description: "Short, descriptive issue title" },
+                    description: { type: "string", description: "Detailed explanation of the issue and why it matters" },
+                    severity: { type: "string", enum: ["high", "medium", "low"] },
+                    issueType: { type: "string", description: "Category: bug, anti-pattern, security, performance, testing, ddd, etc." },
+                    file: { type: "string", description: "File path relative to project root" },
+                    line: { type: "number", description: "Approximate line number" },
+                },
+                required: ["title", "description", "severity", "issueType", "file", "line"],
+            },
+        },
+    },
+    required: ["findings"],
+};
+const DEDUP_SCHEMA = {
+    type: "object",
+    properties: {
+        newIssues: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    title: { type: "string" },
+                    description: { type: "string" },
+                    severity: { type: "string", enum: ["high", "medium", "low"] },
+                    issueType: { type: "string" },
+                    file: { type: "string" },
+                    line: { type: "number" },
+                },
+                required: ["title", "description", "severity", "issueType", "file", "line"],
+            },
+        },
+        duplicates: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    findingIdx: { type: "number", description: "Index into the findings array" },
+                    existingIssueId: { type: "string", description: "Task ID of the existing issue this duplicates" },
+                    reason: { type: "string", description: "Why this is considered a duplicate" },
+                },
+                required: ["findingIdx", "existingIssueId", "reason"],
+            },
+        },
+    },
+    required: ["newIssues", "duplicates"],
+};
+// =============================================================================
+// Helpers
+// =============================================================================
+function composeScanPrompt(task, scan) {
+    return `## Context
+${task}
+
+## Your Mission
+${scan}
+
+## Instructions
+Explore the codebase thoroughly using Read, Glob, and Grep.
+Look for real issues — not style nits. Focus on bugs, logic errors,
+missing error handling, security vulnerabilities, and structural problems.
+
+Return your findings as structured JSON. Only report issues you are
+confident about after reading the actual code.`;
+}
+function composeDedupPrompt(findings, existingIssues) {
+    return `## Task
+Compare these new findings against known issues. Return only genuinely new issues.
+
+## New Findings (${findings.length} total)
+${JSON.stringify(findings, null, 2)}
+
+## Known Issues (${existingIssues.length} total)
+${JSON.stringify(existingIssues, null, 2)}
+
+## Instructions
+For each new finding, check if it describes the same problem as any known issue.
+Use semantic understanding — the same issue might be worded differently or reference
+a slightly different line number in the same file. Be conservative: if in doubt,
+treat it as new rather than duplicate.
+
+Return your analysis as structured JSON.`;
+}
+function composeFixPrompt(issues) {
+    const issuesSummary = issues
+        .map((i, idx) => `${idx + 1}. [${i.severity.toUpperCase()}] ${i.title} (${i.file}:${i.line})\n   ${i.description}`)
+        .join("\n\n");
+    return `## Task
+Fix these ${issues.length} issues found in the codebase:
+
+${issuesSummary}
+
+## Instructions
+Work through the issues above. For each one:
+1. Read the relevant file to understand context
+2. Make the minimal fix needed
+3. Move to the next issue
+
+Focus on correctness. Skip issues you're not confident about fixing safely.`;
+}
+function resolvePrompt(value) {
+    const filePath = resolve(value);
+    if (existsSync(filePath) && statSync(filePath).isFile()) {
+        return readFileSync(filePath, "utf-8").trim();
+    }
+    return value;
+}
+function generateId(prefix) {
+    return `${prefix}-${randomBytes(4).toString("hex")}`;
+}
+// =============================================================================
+// Transcript Logging
+// =============================================================================
+const LOGS_DIR = resolve(".tx", "logs");
+const RUNS_DIR = resolve(".tx", "runs");
+function ensureLogsDir() {
+    mkdirSync(LOGS_DIR, { recursive: true });
+}
+function logPath(runId) {
+    return resolve(LOGS_DIR, `${runId}.jsonl`);
+}
+function writeTranscriptLine(runId, message) {
+    try {
+        const line = JSON.stringify(message) + "\n";
+        // Use async appendFile to avoid blocking the event loop during concurrent scans
+        appendFile(logPath(runId), line).catch(() => {
+            // Don't let transcript writing break the scan
+        });
+    }
+    catch {
+        // Don't let transcript writing break the scan
+    }
+}
+function writeOrchestratorLog(runId, text) {
+    writeTranscriptLine(runId, {
+        type: "assistant",
+        message: {
+            role: "assistant",
+            content: [{ type: "text", text }],
+        },
+        timestamp: new Date().toISOString(),
+    });
+}
+function asNonEmptyPath(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function extractRunLogPathHints(message) {
+    if (!message || typeof message !== "object") {
+        return {};
+    }
+    const queue = [{ value: message, depth: 0 }];
+    const seen = new Set();
+    let stdoutPath = null;
+    let stderrPath = null;
+    while (queue.length > 0 && (!stdoutPath || !stderrPath)) {
+        const next = queue.shift();
+        if (!next)
+            break;
+        const { value, depth } = next;
+        if (!value || typeof value !== "object" || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        const record = value;
+        if (!stdoutPath) {
+            stdoutPath = asNonEmptyPath(record.stdout_path) ?? asNonEmptyPath(record.stdoutPath);
+        }
+        if (!stderrPath) {
+            stderrPath = asNonEmptyPath(record.stderr_path) ?? asNonEmptyPath(record.stderrPath);
+        }
+        if (depth >= 2)
+            continue;
+        for (const child of Object.values(record)) {
+            if (child && typeof child === "object") {
+                queue.push({ value: child, depth: depth + 1 });
+            }
+        }
+    }
+    return {
+        ...(stdoutPath ? { stdoutPath } : {}),
+        ...(stderrPath ? { stderrPath } : {}),
+    };
+}
+function buildRunLogPathCandidates(runId, stream) {
+    const suffixes = stream === "stdout" ? ["stdout", "stdout.log"] : ["stderr", "stderr.log"];
+    return [
+        resolve(LOGS_DIR, `${runId}.${suffixes[0]}`),
+        resolve(LOGS_DIR, `${runId}.${suffixes[1]}`),
+        resolve(RUNS_DIR, `${runId}.${suffixes[0]}`),
+        resolve(RUNS_DIR, `${runId}.${suffixes[1]}`),
+    ];
+}
+function discoverRunLogPath(runId, stream) {
+    const candidates = buildRunLogPathCandidates(runId, stream);
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function parseRunMetadata(raw) {
+    if (!raw)
+        return {};
+    if (typeof raw === "object" && !Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw !== "string")
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+// =============================================================================
+// Service Definition
+// =============================================================================
+/**
+ * CycleScanService orchestrates cycle-based issue discovery.
+ */
+export class CycleScanService extends Context.Tag("CycleScanService")() {
+}
+// =============================================================================
+// Live Implementation
+// =============================================================================
+/**
+ * Live implementation of CycleScanService.
+ * Depends on AgentService for sub-agent dispatch and SqliteClient for DB ops.
+ */
+export const CycleScanServiceLive = Layer.effect(CycleScanService, Effect.gen(function* () {
+    const agentService = yield* AgentService;
+    const sqliteClient = yield* SqliteClient;
+    const computeLoss = (findings) => {
+        let loss = 0;
+        for (const f of findings) {
+            loss += LOSS_WEIGHTS[f.severity] ?? 1;
+        }
+        return loss;
+    };
+    const extractErrorReason = (error, fallback) => {
+        if (error && typeof error === "object") {
+            const record = error;
+            if (typeof record.reason === "string" && record.reason.trim().length > 0) {
+                return record.reason.trim();
+            }
+            if (typeof record.message === "string" && record.message.trim().length > 0) {
+                return record.message.trim();
+            }
+            if (typeof record.error === "string" && record.error.trim().length > 0) {
+                return record.error.trim();
+            }
+        }
+        const text = String(error);
+        if (text && text !== "[object Object]") {
+            return text;
+        }
+        return fallback;
+    };
+    const countBySeverity = (findings) => {
+        let high = 0, medium = 0, low = 0;
+        for (const f of findings) {
+            if (f.severity === "high")
+                high++;
+            else if (f.severity === "medium")
+                medium++;
+            else
+                low++;
+        }
+        return { high, medium, low };
+    };
+    // DB helpers
+    const db = sqliteClient;
+    const dbReadRunPathRow = (runId) => db.prepare(`SELECT transcript_path, stdout_path, stderr_path, metadata
+         FROM runs
+         WHERE id = ?`).get(runId);
+    const classifyRunLogPath = (path) => {
+        if (!path) {
+            return {
+                state: "not_reported",
+                reason: "path_not_reported",
+            };
+        }
+        if (existsSync(path)) {
+            return {
+                state: "captured",
+                reason: "path_reported_file_exists",
+            };
+        }
+        return {
+            state: "missing_file",
+            reason: "path_reported_file_missing",
+        };
+    };
+    const buildLogCaptureMetadata = (row, failureReason) => {
+        const stdout = classifyRunLogPath(row.stdout_path);
+        const stderr = classifyRunLogPath(row.stderr_path);
+        const mode = (() => {
+            if (stdout.state === "captured" || stderr.state === "captured")
+                return "stdio_captured";
+            if (stdout.state === "missing_file" || stderr.state === "missing_file")
+                return "stdio_path_missing_file";
+            if (row.transcript_path)
+                return "transcript_only";
+            return "no_capture";
+        })();
+        const reason = (() => {
+            if (mode === "stdio_captured")
+                return "stdio_paths_reported";
+            if (mode === "stdio_path_missing_file")
+                return "reported_stdio_path_missing_file";
+            if (mode === "transcript_only" && failureReason)
+                return "failed_without_stdio_capture";
+            if (mode === "transcript_only")
+                return "stdio_paths_not_reported";
+            return "no_capture_paths_reported";
+        })();
+        return {
+            mode,
+            reason,
+            transcriptPath: row.transcript_path,
+            stdout: {
+                path: row.stdout_path,
+                state: stdout.state,
+                reason: stdout.reason,
+            },
+            stderr: {
+                path: row.stderr_path,
+                state: stderr.state,
+                reason: stderr.reason,
+            },
+            failureReason,
+            updatedAt: new Date().toISOString(),
+        };
+    };
+    const dbUpdateRunMetadata = (runId, metadataPatch) => {
+        const existing = dbReadRunPathRow(runId);
+        const currentMetadata = parseRunMetadata(existing?.metadata);
+        const mergedMetadata = {
+            ...currentMetadata,
+            ...metadataPatch,
+        };
+        db.prepare(`UPDATE runs SET metadata = ? WHERE id = ?`).run(JSON.stringify(mergedMetadata), runId);
+    };
+    const dbSyncRunLogPaths = (runId, hints = {}) => {
+        const current = dbReadRunPathRow(runId);
+        if (!current)
+            return null;
+        const hintedStdoutPath = asNonEmptyPath(hints.stdoutPath);
+        const hintedStderrPath = asNonEmptyPath(hints.stderrPath);
+        const nextStdoutPath = current.stdout_path
+            ?? hintedStdoutPath
+            ?? discoverRunLogPath(runId, "stdout");
+        const nextStderrPath = current.stderr_path
+            ?? hintedStderrPath
+            ?? discoverRunLogPath(runId, "stderr");
+        if (nextStdoutPath !== current.stdout_path || nextStderrPath !== current.stderr_path) {
+            db.prepare(`UPDATE runs
+           SET stdout_path = ?, stderr_path = ?
+           WHERE id = ?`).run(nextStdoutPath, nextStderrPath, runId);
+        }
+        return {
+            transcript_path: current.transcript_path,
+            stdout_path: nextStdoutPath,
+            stderr_path: nextStderrPath,
+            metadata: current.metadata,
+        };
+    };
+    const dbRecordRunLogPathHints = (runId, hints) => {
+        const row = dbSyncRunLogPaths(runId, hints);
+        if (!row)
+            return;
+        dbUpdateRunMetadata(runId, {
+            logCapture: buildLogCaptureMetadata(row, null),
+        });
+    };
+    const dbCreateRun = (agent) => {
+        const id = generateId("run");
+        const now = new Date().toISOString();
+        const transcriptPath = logPath(id);
+        const discoveredStdoutPath = discoverRunLogPath(id, "stdout");
+        const discoveredStderrPath = discoverRunLogPath(id, "stderr");
+        db.prepare(`INSERT INTO runs (id, agent, started_at, status, metadata, transcript_path, stdout_path, stderr_path)
+         VALUES (?, ?, ?, 'running', '{}', ?, ?, ?)`).run(id, agent, now, transcriptPath, discoveredStdoutPath, discoveredStderrPath);
+        dbUpdateRunMetadata(id, {
+            logCapture: buildLogCaptureMetadata({
+                transcript_path: transcriptPath,
+                stdout_path: discoveredStdoutPath,
+                stderr_path: discoveredStderrPath,
+                metadata: "{}",
+            }, null),
+        });
+        return id;
+    };
+    const dbUpdateRun = (runId, updates) => {
+        const sets = [];
+        const params = [];
+        if (updates.status) {
+            sets.push("status = ?");
+            params.push(updates.status);
+            if (updates.status === "completed" || updates.status === "failed") {
+                sets.push("ended_at = datetime('now')");
+            }
+        }
+        if (updates.summary) {
+            sets.push("summary = ?");
+            params.push(updates.summary);
+        }
+        if (updates.errorMessage) {
+            sets.push("error_message = ?");
+            params.push(updates.errorMessage);
+        }
+        if (sets.length > 0) {
+            params.push(runId);
+            db.prepare(`UPDATE runs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+        }
+    };
+    const dbFinalizeRun = (runId, updates, failureReason = null) => {
+        dbUpdateRun(runId, updates);
+        const row = dbSyncRunLogPaths(runId);
+        if (!row)
+            return;
+        dbUpdateRunMetadata(runId, {
+            logCapture: buildLogCaptureMetadata(row, failureReason),
+        });
+    };
+    const dbCreateTask = (data) => {
+        const id = generateId("tx");
+        const now = new Date().toISOString();
+        db.prepare(`INSERT INTO tasks (id, title, description, status, parent_id, score, created_at, updated_at, completed_at, metadata)
+         VALUES (?, ?, ?, 'backlog', NULL, ?, ?, ?, NULL, ?)`).run(id, data.title, data.description, data.score, now, now, JSON.stringify(data.metadata));
+        return id;
+    };
+    const emitMetric = (runId, metricName, metadata) => {
+        db.prepare(`INSERT INTO events (timestamp, event_type, run_id, content, metadata)
+         VALUES (datetime('now'), 'metric', ?, ?, ?)`).run(runId, metricName, JSON.stringify(metadata));
+    };
+    // Agent dispatch helpers
+    const runScanAgent = (task, scan, agentModel, agentRuntime, runId) => Effect.gen(function* () {
+        const prompt = composeScanPrompt(task, scan);
+        const config = {
+            prompt,
+            options: {
+                tools: ["Read", "Glob", "Grep"],
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+                model: agentModel,
+                runtime: agentRuntime,
+                maxTurns: 20,
+                persistSession: false,
+                outputFormat: { type: "json_schema", schema: FINDINGS_SCHEMA },
+            },
+        };
+        const result = yield* agentService
+            .run(config, (msg) => {
+            try {
+                const logPathHints = extractRunLogPathHints(msg);
+                if (logPathHints.stdoutPath || logPathHints.stderrPath) {
+                    dbRecordRunLogPathHints(runId, logPathHints);
+                }
+            }
+            catch {
+                // Never let path-hint parsing block cycle execution.
+            }
+            writeTranscriptLine(runId, { ...msg, timestamp: new Date().toISOString() });
+        })
+            .pipe(Effect.mapError((e) => new CycleScanError({
+            phase: "scan",
+            reason: extractErrorReason(e, "Scan agent failed"),
+            cause: e,
+        })));
+        // Try structured output first, then parse text
+        const output = result.structuredOutput;
+        if (output?.findings) {
+            return output.findings;
+        }
+        try {
+            const parsed = JSON.parse(result.text);
+            return parsed.findings ?? [];
+        }
+        catch {
+            return [];
+        }
+    });
+    const runDedupAgent = (findings, issuesMap, agentModel, agentRuntime, runId) => Effect.gen(function* () {
+        if (issuesMap.size === 0) {
+            return { newIssues: findings, duplicates: [] };
+        }
+        if (findings.length === 0) {
+            return { newIssues: [], duplicates: [] };
+        }
+        const existingIssues = Array.from(issuesMap.entries()).map(([id, issue]) => ({
+            id,
+            title: issue.title,
+            description: issue.description,
+            severity: issue.severity,
+            file: issue.file,
+            line: issue.line,
+        }));
+        const prompt = composeDedupPrompt(findings, existingIssues);
+        const config = {
+            prompt,
+            options: {
+                tools: [],
+                model: agentModel,
+                runtime: agentRuntime,
+                maxTurns: 1,
+                persistSession: false,
+                outputFormat: { type: "json_schema", schema: DEDUP_SCHEMA },
+            },
+        };
+        const result = yield* agentService
+            .run(config, (msg) => {
+            try {
+                const logPathHints = extractRunLogPathHints(msg);
+                if (logPathHints.stdoutPath || logPathHints.stderrPath) {
+                    dbRecordRunLogPathHints(runId, logPathHints);
+                }
+            }
+            catch {
+                // Never let path-hint parsing block cycle execution.
+            }
+            writeTranscriptLine(runId, { ...msg, timestamp: new Date().toISOString() });
+        })
+            .pipe(Effect.mapError((e) => new CycleScanError({
+            phase: "dedup",
+            reason: extractErrorReason(e, "Dedup agent failed"),
+            cause: e,
+        })));
+        const output = result.structuredOutput;
+        if (output?.newIssues) {
+            return output;
+        }
+        try {
+            return JSON.parse(result.text);
+        }
+        catch {
+            return { newIssues: findings, duplicates: [] };
+        }
+    });
+    const runFixAgent = (issues, agentModel, agentRuntime, runId) => Effect.gen(function* () {
+        const prompt = composeFixPrompt(issues);
+        const config = {
+            prompt,
+            options: {
+                tools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
+                permissionMode: "acceptEdits",
+                model: agentModel,
+                runtime: agentRuntime,
+                maxTurns: 50,
+                persistSession: false,
+            },
+        };
+        yield* agentService
+            .run(config, (msg) => {
+            try {
+                const logPathHints = extractRunLogPathHints(msg);
+                if (logPathHints.stdoutPath || logPathHints.stderrPath) {
+                    dbRecordRunLogPathHints(runId, logPathHints);
+                }
+            }
+            catch {
+                // Never let path-hint parsing block cycle execution.
+            }
+            writeTranscriptLine(runId, { ...msg, timestamp: new Date().toISOString() });
+        })
+            .pipe(Effect.mapError((e) => new CycleScanError({
+            phase: "fix",
+            reason: extractErrorReason(e, "Fix agent failed"),
+            cause: e,
+        })));
+    });
+    return {
+        computeLoss,
+        runCycles: (config, onProgress) => Effect.gen(function* () {
+            ensureLogsDir();
+            const taskPrompt = resolvePrompt(config.taskPrompt);
+            const scanPrompt = config.scanPrompt
+                ? resolvePrompt(config.scanPrompt)
+                : "Find bugs, anti-patterns, missing error handling, security vulnerabilities, and untested code paths.";
+            const cycleCount = config.cycles ?? 1;
+            const maxRounds = config.maxRounds ?? 10;
+            const agentCount = config.agents ?? 3;
+            const model = config.model ?? "claude-opus-4-6";
+            const runtime = config.runtime ?? "auto";
+            const scanOnly = config.scanOnly ?? false;
+            const dryRun = config.dryRun ?? false;
+            const doFix = (config.fix ?? false) && !scanOnly && !dryRun;
+            const effectiveMaxRounds = scanOnly || (!doFix && !dryRun) ? 1 : maxRounds;
+            const baseScore = config.score ?? 500;
+            const cycleName = config.name ?? taskPrompt.slice(0, 60).replace(/\n/g, " ");
+            const cycleDescription = config.description ?? scanPrompt.slice(0, 200).replace(/\n/g, " ");
+            const results = [];
+            // Query max existing cycle number for globally unique numbering
+            const maxCycleRow = db
+                .prepare(`SELECT MAX(CAST(json_extract(metadata, '$.cycle') AS INTEGER)) as maxCycle
+               FROM runs WHERE agent = 'cycle-scanner'`)
+                .get();
+            const cycleOffset = maxCycleRow?.maxCycle ?? 0;
+            for (let i = 1; i <= cycleCount; i++) {
+                const cycle = cycleOffset + i;
+                onProgress?.({ type: "cycle_start", cycle, totalCycles: cycleCount, name: cycleName });
+                // Create cycle group run
+                const cycleRunId = dbCreateRun("cycle-scanner");
+                dbUpdateRunMetadata(cycleRunId, { type: "cycle", cycle, name: cycleName, description: cycleDescription });
+                writeOrchestratorLog(cycleRunId, `Starting cycle ${cycle}/${cycleCount}: "${cycleName}" with ${agentCount} agents, model: ${model}, runtime: ${runtime}`);
+                // Load existing issues for this cycle
+                const issuesMap = new Map();
+                const existingRows = db
+                    .prepare(`SELECT id, title, description, metadata FROM tasks
+                 WHERE json_extract(metadata, '$.foundByScan') = 1
+                   AND json_extract(metadata, '$.cycleId') = ?`)
+                    .all(cycleRunId);
+                for (const row of existingRows) {
+                    const meta = JSON.parse(row.metadata || "{}");
+                    issuesMap.set(row.id, {
+                        id: row.id,
+                        title: row.title,
+                        description: row.description,
+                        severity: meta.severity ?? "low",
+                        file: meta.file ?? "",
+                        line: meta.line ?? 0,
+                    });
+                }
+                let totalNewIssues = 0;
+                let finalLoss = 0;
+                let converged = false;
+                let roundCount = 0;
+                for (let round = 1; round <= effectiveMaxRounds; round++) {
+                    roundCount = round;
+                    // SCAN PHASE — N agents in parallel
+                    writeOrchestratorLog(cycleRunId, `Round ${round}: Dispatching ${agentCount} scan agents...`);
+                    const scanStart = Date.now();
+                    const scanEffects = Array.from({ length: agentCount }, (_, i) => Effect.gen(function* () {
+                        const scanRunId = dbCreateRun(`scan-agent-${i + 1}`);
+                        dbUpdateRunMetadata(scanRunId, { type: "scan", cycle, round, cycleRunId });
+                        return yield* runScanAgent(taskPrompt, scanPrompt, model, runtime, scanRunId).pipe(Effect.map((findings) => ({
+                            findings,
+                            failed: false,
+                            errorReason: null,
+                        })), Effect.tap(() => Effect.sync(() => dbFinalizeRun(scanRunId, { status: "completed" }))), Effect.catchAll((error) => {
+                            const reason = extractErrorReason(error, "Scan agent failed");
+                            return Effect.sync(() => {
+                                dbFinalizeRun(scanRunId, { status: "failed", errorMessage: reason }, reason);
+                                return {
+                                    findings: [],
+                                    failed: true,
+                                    errorReason: reason,
+                                };
+                            });
+                        }));
+                    }));
+                    const scanResults = yield* Effect.all(scanEffects, { concurrency: agentCount });
+                    const failedScans = scanResults.filter((result) => result.failed);
+                    const allFindings = scanResults.flatMap((result) => result.findings);
+                    const scanDuration = Date.now() - scanStart;
+                    if (failedScans.length > 0) {
+                        const reasonList = Array.from(new Set(failedScans
+                            .map((result) => result.errorReason)
+                            .filter((reason) => typeof reason === "string" && reason.length > 0)));
+                        const reasonText = reasonList.length > 0 ? ` Reasons: ${reasonList.join(" | ")}` : "";
+                        writeOrchestratorLog(cycleRunId, `Round ${round}: ${failedScans.length}/${agentCount} scan agent(s) failed.${reasonText}`);
+                    }
+                    if (failedScans.length === agentCount) {
+                        const reasonList = Array.from(new Set(failedScans
+                            .map((result) => result.errorReason)
+                            .filter((reason) => typeof reason === "string" && reason.length > 0)));
+                        const reasonText = reasonList.length > 0 ? reasonList.join(" | ") : "No failure reason reported";
+                        const fatalReason = `All ${agentCount} scan agents failed in cycle ${cycle} round ${round}: ${reasonText}`;
+                        writeOrchestratorLog(cycleRunId, fatalReason);
+                        dbFinalizeRun(cycleRunId, {
+                            status: "failed",
+                            errorMessage: fatalReason,
+                        }, fatalReason);
+                        return yield* Effect.fail(new CycleScanError({ phase: "scan", reason: fatalReason }));
+                    }
+                    writeOrchestratorLog(cycleRunId, `Round ${round}: Scan complete — ${allFindings.length} findings in ${(scanDuration / 1000).toFixed(1)}s`);
+                    onProgress?.({ type: "scan_complete", cycle, round, findings: allFindings.length, durationMs: scanDuration });
+                    if (allFindings.length === 0) {
+                        writeOrchestratorLog(cycleRunId, `Round ${round}: No findings — converged!`);
+                        emitMetric(cycleRunId, "cycle.round.loss", {
+                            metric: "cycle.round.loss",
+                            cycleId: cycleRunId,
+                            cycle,
+                            round,
+                            loss: 0,
+                            newIssues: 0,
+                            existingIssues: issuesMap.size,
+                            duplicates: 0,
+                            high: 0,
+                            medium: 0,
+                            low: 0,
+                        });
+                        onProgress?.({ type: "converged", cycle, round });
+                        converged = true;
+                        break;
+                    }
+                    // DEDUP PHASE
+                    const dedupRunId = dbCreateRun("dedup-agent");
+                    dbUpdateRunMetadata(dedupRunId, { type: "dedup", cycle, round, cycleRunId });
+                    const dedupResult = yield* runDedupAgent(allFindings, issuesMap, model, runtime, dedupRunId).pipe(Effect.tap(() => Effect.sync(() => dbFinalizeRun(dedupRunId, { status: "completed" }))), Effect.tapError((error) => Effect.sync(() => {
+                        const reason = extractErrorReason(error, "Dedup agent failed");
+                        dbFinalizeRun(dedupRunId, { status: "failed", errorMessage: reason }, reason);
+                    })), Effect.catchAll(() => Effect.succeed({ newIssues: allFindings, duplicates: [] })));
+                    writeOrchestratorLog(cycleRunId, `Round ${round}: Dedup complete — ${dedupResult.newIssues.length} new, ${dedupResult.duplicates.length} duplicates`);
+                    onProgress?.({
+                        type: "dedup_complete",
+                        cycle,
+                        round,
+                        newIssues: dedupResult.newIssues.length,
+                        duplicates: dedupResult.duplicates.length,
+                    });
+                    // CREATE TASKS for new issues
+                    if (!dryRun && dedupResult.newIssues.length > 0) {
+                        for (const issue of dedupResult.newIssues) {
+                            const taskId = dbCreateTask({
+                                title: `${issue.severity.toUpperCase()}: ${issue.title}`,
+                                description: issue.description,
+                                score: baseScore,
+                                metadata: {
+                                    foundByScan: true,
+                                    cycleId: cycleRunId,
+                                    cycle,
+                                    round,
+                                    severity: issue.severity,
+                                    issueType: issue.issueType,
+                                    file: issue.file,
+                                    line: issue.line,
+                                },
+                            });
+                            issuesMap.set(taskId, {
+                                id: taskId,
+                                title: issue.title,
+                                description: issue.description,
+                                severity: issue.severity,
+                                file: issue.file,
+                                line: issue.line,
+                            });
+                        }
+                    }
+                    else if (dryRun && dedupResult.newIssues.length > 0) {
+                        // Still add to in-memory map for dedup in subsequent rounds
+                        for (const issue of dedupResult.newIssues) {
+                            const fakeId = `dry-${cycle}-${round}-${issuesMap.size}`;
+                            issuesMap.set(fakeId, {
+                                id: fakeId,
+                                title: issue.title,
+                                description: issue.description,
+                                severity: issue.severity,
+                                file: issue.file,
+                                line: issue.line,
+                            });
+                        }
+                    }
+                    totalNewIssues += dedupResult.newIssues.length;
+                    // COMPUTE ROUND LOSS
+                    const { high, medium, low } = countBySeverity(dedupResult.newIssues);
+                    const loss = computeLoss(dedupResult.newIssues);
+                    finalLoss = loss;
+                    writeOrchestratorLog(cycleRunId, `Round ${round}: Loss = ${loss} (${high}H x3 + ${medium}M x2 + ${low}L x1)`);
+                    onProgress?.({ type: "round_loss", cycle, round, loss, high, medium, low });
+                    // FIX PHASE
+                    if (doFix && dedupResult.newIssues.length > 0) {
+                        const fixRunId = dbCreateRun("fix-agent");
+                        dbUpdateRunMetadata(fixRunId, { type: "fix", cycle, round, cycleRunId });
+                        yield* runFixAgent(dedupResult.newIssues, model, runtime, fixRunId).pipe(Effect.tap(() => Effect.sync(() => dbFinalizeRun(fixRunId, { status: "completed" }))), Effect.tapError((error) => Effect.sync(() => {
+                            const reason = extractErrorReason(error, "Fix agent failed");
+                            dbFinalizeRun(fixRunId, { status: "failed", errorMessage: reason }, reason);
+                        })), Effect.catchAll(() => Effect.void));
+                    }
+                    // EMIT ROUND METRICS
+                    emitMetric(cycleRunId, "cycle.round.loss", {
+                        metric: "cycle.round.loss",
+                        cycleId: cycleRunId,
+                        cycle,
+                        round,
+                        loss,
+                        newIssues: dedupResult.newIssues.length,
+                        existingIssues: issuesMap.size,
+                        duplicates: dedupResult.duplicates.length,
+                        high,
+                        medium,
+                        low,
+                    });
+                    // CHECK CONVERGENCE
+                    if (dedupResult.newIssues.length === 0) {
+                        converged = true;
+                        break;
+                    }
+                }
+                // EMIT CYCLE-LEVEL METRIC
+                emitMetric(cycleRunId, "cycle.complete", {
+                    metric: "cycle.complete",
+                    cycleId: cycleRunId,
+                    cycle,
+                    name: cycleName,
+                    description: cycleDescription,
+                    rounds: roundCount,
+                    totalNewIssues,
+                    existingIssues: issuesMap.size,
+                    finalLoss,
+                    converged,
+                });
+                // UPDATE CYCLE RUN
+                dbFinalizeRun(cycleRunId, {
+                    status: "completed",
+                    summary: `Cycle ${cycle}: ${roundCount} rounds, ${totalNewIssues} new issues, loss ${finalLoss}${converged ? " (converged)" : ""}`,
+                });
+                dbUpdateRunMetadata(cycleRunId, {
+                    type: "cycle",
+                    cycle,
+                    name: cycleName,
+                    description: cycleDescription,
+                    rounds: roundCount,
+                    totalNewIssues,
+                    existingIssues: issuesMap.size,
+                    finalLoss,
+                    converged,
+                });
+                writeOrchestratorLog(cycleRunId, `Cycle ${cycle} complete: ${roundCount} rounds, ${totalNewIssues} new issues, final loss ${finalLoss}${converged ? " — CONVERGED" : ""}`);
+                const cycleResult = {
+                    cycleRunId,
+                    cycle,
+                    name: cycleName,
+                    description: cycleDescription,
+                    rounds: roundCount,
+                    totalNewIssues,
+                    existingIssues: issuesMap.size,
+                    finalLoss,
+                    converged,
+                };
+                onProgress?.({ type: "cycle_complete", result: cycleResult });
+                results.push(cycleResult);
+            }
+            return results;
+        }).pipe(Effect.catchAllDefect((defect) => Effect.fail(new CycleScanError({
+            phase: "unknown",
+            reason: `Unexpected defect: ${defect instanceof Error ? defect.message : String(defect)}`,
+            cause: defect,
+        })))),
+    };
+}));
+//# sourceMappingURL=cycle-scan-service-impl.js.map