@jamesaphoenix/tx-core 0.8.1 → 0.9.0

package/dist/services/cycle-scan-service.js

@@ -1,877 +1,2 @@
-/**
- * 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 "./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,
-        })))),
-    };
-}));
+export { CycleScanService, CycleScanServiceLive, } from "../internal/cycle-scan-service-impl.js";
 //# sourceMappingURL=cycle-scan-service.js.map