@lsctech/polaris 0.5.6 → 0.5.8

package/dist/loop/worker-packet.js

@@ -11,7 +11,7 @@
  * accept BootstrapPacket transparently accept WorkerPacket.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
+exports.REPAIR_RETURN_CONTRACT = exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
 exports.roleContextForWorkerRole = roleContextForWorkerRole;
 exports.isWorkerPacket = isWorkerPacket;
 exports.getWorkerCommitPolicy = getWorkerCommitPolicy;
@@ -19,6 +19,7 @@ exports.compileStartupPacket = compileStartupPacket;
 exports.compileImplPacket = compileImplPacket;
 exports.compileFinalizePacket = compileFinalizePacket;
 exports.compilePreflightPacket = compilePreflightPacket;
+exports.compileRepairWorkerPacket = compileRepairWorkerPacket;
 const worker_prompt_js_1 = require("./worker-prompt.js");
 const body_parser_js_1 = require("./body-parser.js");
 const WORKER_ROLE_CONTEXT = {
@@ -421,3 +422,76 @@ function compilePreflightPacket(input) {
         },
     };
 }
+/** Return contract for repair workers (same shape as impl). */
+exports.REPAIR_RETURN_CONTRACT = [
+    'child_id',
+    'status',
+    'commit',
+    'validation',
+    'next_recommended_action',
+];
+/**
+ * Build a compiled repair worker packet.
+ *
+ * Repair workers use `worker_role: "repair"` and the same sealed packet/result
+ * contracts as impl workers, but with tightly scoped allowed/prohibited paths
+ * derived from the compiled repair packet manifest.
+ *
+ * The parent/orchestrator MUST use this function and MUST NOT implement
+ * repair work inline.
+ */
+function compileRepairWorkerPacket(input) {
+    const steps = [
+        `Confirm QC repair scope: allowed=${JSON.stringify(input.allowedScope)}, prohibited=${JSON.stringify(input.prohibitedScope)}.`,
+        `Review root-cause hint: ${input.rootCauseHint}`,
+        `Apply minimal repair to files within allowed scope only. Do NOT touch prohibited paths.`,
+        `Run validation commands and confirm all pass.`,
+        `Create exactly ONE git commit: [REPAIR] ${input.clusterId} round-${input.round} packet-${input.packetId}.`,
+        `Write compact return JSON to stdout (fields: ${exports.REPAIR_RETURN_CONTRACT.join(', ')}). next_recommended_action MUST be "continue" on success, "stop" on unresolvable blocker.`,
+        `TERMINATE SESSION IMMEDIATELY.`,
+    ];
+    return {
+        schema_version: '2.1',
+        worker_role: 'repair',
+        run_id: input.runId,
+        cluster_id: input.clusterId,
+        active_child: input.packetId,
+        state_file: input.stateFile,
+        telemetry_file: input.telemetryFile,
+        instructions: {
+            primary_goal: `QC repair worker for cluster ${input.clusterId}, round ${input.round}, packet ${input.packetId}. ` +
+                `Apply minimal targeted repairs to findings within the allowed scope. Root cause: ${input.rootCauseHint}`,
+            steps,
+            allowed_scope: input.allowedScope,
+            validation_commands: input.validationCommands,
+        },
+        lifecycle: defaultLifecycle(input.maxConcurrentWorkers ?? 1, 'commit-and-exit'),
+        return_contract: exports.REPAIR_RETURN_CONTRACT,
+        prompt_mode: 'full',
+        prompt_metrics: { mode: 'full', char_count: 0, estimated_tokens: 0 },
+        role_context: roleContextForWorkerRole('repair'),
+        routing_context: {
+            task_type: "repair",
+            required_capabilities: ["repair"],
+        },
+        prohibited_write_paths: [
+            ...exports.WORKER_PROHIBITED_WRITE_PATHS,
+            ...input.prohibitedScope,
+        ],
+        result_file_contract: {
+            result_file: input.resultFile,
+            result_required_fields: Object.fromEntries([
+                ['run_id', input.runId],
+                ['cluster_id', input.clusterId],
+                ['child_id', input.packetId],
+                ...exports.REPAIR_RETURN_CONTRACT.filter((key) => key !== 'child_id').map((key) => [key, `<${key}>`]),
+            ]),
+        },
+        context: {
+            branch: input.branch,
+            worker_role: 'repair',
+            repair_round: input.round,
+            repair_packet_id: input.packetId,
+        },
+    };
+}

package/dist/qc/artifacts.js

@@ -37,6 +37,7 @@ exports.getQcArtifactDir = getQcArtifactDir;
 exports.writeQcArtifact = writeQcArtifact;
 exports.readQcArtifact = readQcArtifact;
 exports.listQcArtifactIds = listQcArtifactIds;
+exports.validateQcArtifactPointers = validateQcArtifactPointers;
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
 const schemas_js_1 = require("./schemas.js");
@@ -115,3 +116,29 @@ function listQcArtifactIds(clusterId, repoRoot) {
         throw error;
     }
 }
+/**
+ * Validate that the artifacts referenced by QC run pointers still exist.
+ * Returns a list of missing primary artifacts and unavailable raw audit
+ * artifacts so callers can warn, prune, or mark pointers consistently.
+ */
+function validateQcArtifactPointers(qcRuns) {
+    const missing = [];
+    const unavailable = [];
+    if (!qcRuns) {
+        return { ok: true, missing, unavailable };
+    }
+    for (const pointer of Object.values(qcRuns)) {
+        if (!(0, node_fs_1.existsSync)(pointer.artifact_path)) {
+            missing.push(pointer.artifact_path);
+        }
+        for (const rawPath of pointer.raw_artifact_paths ?? []) {
+            if (!(0, node_fs_1.existsSync)(rawPath)) {
+                unavailable.push(rawPath);
+            }
+        }
+        if (pointer.provider_attempt_artifact_path && !(0, node_fs_1.existsSync)(pointer.provider_attempt_artifact_path)) {
+            unavailable.push(pointer.provider_attempt_artifact_path);
+        }
+    }
+    return { ok: missing.length === 0 && unavailable.length === 0, missing, unavailable };
+}

package/dist/qc/fixtures/repair-packets.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TEST_CONFIG = void 0;
+exports.makeFinding = makeFinding;
+exports.makeResult = makeResult;
+exports.makeSameFileFindings = makeSameFileFindings;
+exports.makeCrossFileSubsystemFindings = makeCrossFileSubsystemFindings;
+exports.makeOverlappingScopeFindings = makeOverlappingScopeFindings;
+exports.makeHighRiskFindings = makeHighRiskFindings;
+exports.makeLowConfidenceBroadFindings = makeLowConfidenceBroadFindings;
+exports.DEFAULT_TEST_CONFIG = {
+    enabled: true,
+    severityThresholds: { block: "high", repair: "medium", followUp: "low" },
+};
+function makeFinding(overrides = {}) {
+    return {
+        findingId: `f-${Math.random().toString(36).slice(2, 8)}`,
+        severity: "medium",
+        category: "style",
+        title: "Test finding",
+        fixAvailable: true,
+        autofixEligible: false,
+        attribution: { confidence: "high", reason: "changed-file-owner", childId: "POL-472" },
+        status: "open",
+        ...overrides,
+    };
+}
+function makeResult(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: "1.0",
+        qcRunId: `qc-run-${Math.random().toString(36).slice(2, 8)}`,
+        runId: "run-1",
+        clusterId: "POL-TEST",
+        trigger: "completed-cluster",
+        provider: "coderabbit",
+        providerMode: "local",
+        startedAt: now,
+        completedAt: now,
+        status: "findings",
+        findings: [],
+        rawArtifactPaths: [],
+        parserVersion: "coderabbit-1.0",
+        policyDecision: {
+            blocksDelivery: false,
+            requiresOperatorReview: false,
+            routedToRepair: false,
+            summary: "ok",
+        },
+        ...overrides,
+    };
+}
+function makeSameFileFindings() {
+    return [
+        makeFinding({
+            findingId: "f-same-1",
+            filePath: "src/auth/login.ts",
+            category: "style",
+            severity: "medium",
+            range: { startLine: 10, endLine: 15 },
+        }),
+        makeFinding({
+            findingId: "f-same-2",
+            filePath: "src/auth/login.ts",
+            category: "type-safety",
+            severity: "medium",
+            range: { startLine: 30, endLine: 35 },
+        }),
+        makeFinding({
+            findingId: "f-same-3",
+            filePath: "src/auth/login.ts",
+            category: "style",
+            severity: "medium",
+            range: { startLine: 12, endLine: 16 },
+        }),
+    ];
+}
+function makeCrossFileSubsystemFindings() {
+    return [
+        makeFinding({
+            findingId: "f-sub-a",
+            filePath: "src/qc/compiler.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 5, endLine: 8 },
+        }),
+        makeFinding({
+            findingId: "f-sub-b",
+            filePath: "src/qc/runner.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 20, endLine: 24 },
+        }),
+        makeFinding({
+            findingId: "f-sub-c",
+            filePath: "src/loop/worker.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 7, endLine: 11 },
+        }),
+    ];
+}
+function makeOverlappingScopeFindings() {
+    return [
+        makeFinding({
+            findingId: "f-overlap-1",
+            filePath: "src/core/state.ts",
+            category: "race-condition",
+            severity: "high",
+            range: { startLine: 40, endLine: 45 },
+        }),
+        makeFinding({
+            findingId: "f-overlap-2",
+            filePath: "src/core/state.ts",
+            category: "race-condition",
+            severity: "high",
+            range: { startLine: 42, endLine: 48 },
+        }),
+    ];
+}
+function makeHighRiskFindings() {
+    return [
+        makeFinding({
+            findingId: "f-security-1",
+            filePath: "src/auth/token.ts",
+            category: "security",
+            severity: "high",
+            range: { startLine: 1, endLine: 5 },
+        }),
+        makeFinding({
+            findingId: "f-security-2",
+            filePath: "src/auth/token.ts",
+            category: "auth",
+            severity: "medium",
+            range: { startLine: 10, endLine: 14 },
+        }),
+        makeFinding({
+            findingId: "f-migration-1",
+            filePath: "src/db/migrate.ts",
+            category: "migration",
+            severity: "medium",
+            range: { startLine: 3, endLine: 7 },
+        }),
+    ];
+}
+function makeLowConfidenceBroadFindings() {
+    return [
+        makeFinding({
+            findingId: "f-broad-1",
+            filePath: undefined,
+            category: "architecture",
+            severity: "medium",
+            attribution: { confidence: "low", reason: "provider-uncertain" },
+        }),
+        makeFinding({
+            findingId: "f-broad-2",
+            filePath: undefined,
+            category: "architecture",
+            severity: "low",
+            attribution: { confidence: "unattributed", reason: "unattributed" },
+        }),
+        makeFinding({
+            findingId: "f-preexisting-1",
+            filePath: "src/legacy/old.ts",
+            category: "tech-debt",
+            severity: "low",
+            attribution: { confidence: "medium", reason: "pre-existing" },
+        }),
+    ];
+}

package/dist/qc/index.js

@@ -28,3 +28,5 @@ __exportStar(require("./registry.js"), exports);
 __exportStar(require("./attribution.js"), exports);
 __exportStar(require("./autofix.js"), exports);
 __exportStar(require("./routing.js"), exports);
+__exportStar(require("./repair-packets.js"), exports);
+__exportStar(require("./repair-loop.js"), exports);

package/dist/qc/orchestration.js

@@ -20,7 +20,7 @@ const attribution_js_1 = require("./attribution.js");
 const autofix_js_1 = require("./autofix.js");
 const routing_js_1 = require("./routing.js");
 function buildAttributionContext(options) {
-    const { repoRoot, clusterId, branch, state } = options;
+    const { repoRoot, clusterId, branch, baseRef, state } = options;
     const dispatchRecords = {};
     if (state?.open_children_meta) {
         for (const [childId, meta] of Object.entries(state.open_children_meta)) {
@@ -31,7 +31,7 @@ function buildAttributionContext(options) {
     }
     return {
         repoRoot,
-        baseBranch: branch ?? state?.branch ?? "main",
+        baseBranch: baseRef ?? branch ?? state?.branch ?? "main",
         completedResults: state?.completed_children_results,
         dispatchRecords,
         clusterState: repoRoot ? ((0, store_js_1.readClusterStateSync)(clusterId, repoRoot) ?? undefined) : undefined,
@@ -99,6 +99,7 @@ async function runQcAtTrigger(options) {
             clusterId,
             runId,
             ...(trigger === "pr" ? { prUrl } : { branch }),
+            ...(options.baseRef ? { baseRef: options.baseRef } : {}),
         };
         try {
             const rawResult = await (0, runner_js_1.executeQcProvider)(provider, scope, {
@@ -108,6 +109,8 @@ async function runQcAtTrigger(options) {
                 branch,
                 telemetryFile,
                 timeoutMs,
+                config,
+                registry,
             });
             const result = applyAttributionAndRouting(rawResult, config, attributionContext, ownership, routeName);
             try {

package/dist/qc/policy.js

@@ -9,6 +9,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decideQcAction = decideQcAction;
+exports.decideProviderFailureAction = decideProviderFailureAction;
 exports.computeQcPolicyDecision = computeQcPolicyDecision;
 const severity_js_1 = require("./severity.js");
 /**
@@ -16,6 +17,7 @@ const severity_js_1 = require("./severity.js");
  *
  * Rules:
  *   - passed / skipped  -> pass (no effect on delivery)
+ *   - allProvidersFailed -> block
  *   - repairRouting: "block"  -> block finalize/delivery
  *   - repairRouting: "log"    -> pass (passive report only)
  *   - repairRouting: "route" / "follow-up" -> create follow-up work, but high/critical
@@ -27,6 +29,9 @@ function decideQcAction(result, config) {
     if (result.status === "passed" || result.status === "skipped") {
         return "pass";
     }
+    if (result.allProvidersFailed) {
+        return "block";
+    }
     const routing = config.repairRouting ?? "route";
     if (routing === "block") {
         return "block";
@@ -41,19 +46,41 @@ function decideQcAction(result, config) {
     }
     return "follow-up";
 }
+/**
+ * Decide what the runtime should do with a classified provider failure.
+ *
+ * Maps a failure reason to the per-provider failure policy from configuration.
+ * Reasons without a dedicated policy key default to "fail" so behavior is
+ * deterministic even for newly-classified failures.
+ */
+function decideProviderFailureAction(reason, policy) {
+    switch (reason) {
+        case "timeout":
+            return policy?.timeout ?? "fail";
+        case "parse-failed":
+            return policy?.parseFailure ?? "fail";
+        default:
+            return "fail";
+    }
+}
 /**
  * Compute the detailed policy decision for a QC result after attribution and
  * repair routing have been applied.
  */
 function computeQcPolicyDecision(result, config) {
     const blockThreshold = config.severityThresholds?.block ?? "high";
-    const blocksDelivery = result.findings.some((f) => (0, severity_js_1.compareSeverity)(f.severity, blockThreshold) >= 0 &&
-        (f.routingDecision === "operator-review" || f.routingDecision === undefined));
-    const requiresOperatorReview = result.status === "failed" ||
+    const blocksDelivery = result.allProvidersFailed ||
+        result.findings.some((f) => (0, severity_js_1.compareSeverity)(f.severity, blockThreshold) >= 0 &&
+            (f.routingDecision === "operator-review" || f.routingDecision === undefined));
+    const requiresOperatorReview = result.allProvidersFailed ||
+        result.status === "failed" ||
         result.status === "blocked" ||
         result.findings.some((f) => f.routingDecision === "operator-review");
     const routedToRepair = result.findings.some((f) => f.routingDecision === "original-worker" || f.routingDecision === "repair-worker");
     const summaryParts = [];
+    if (result.allProvidersFailed) {
+        summaryParts.push("all providers failed");
+    }
     summaryParts.push(`${result.findings.length} findings`);
     if (requiresOperatorReview) {
         summaryParts.push("operator review required");

package/dist/qc/providers/coderabbit.js

@@ -16,6 +16,79 @@ function pickString(...candidates) {
     }
     return undefined;
 }
+const FINDING_LOCATION_KEYS = ["file", "filePath", "path"];
+const FINDING_REVIEW_KEYS = [
+    "severity",
+    "message",
+    "title",
+    "summary",
+    "description",
+    "body",
+    "rule",
+    "category",
+    "suggestion",
+    "suggestedAction",
+    "fix",
+    "providerFindingId",
+    "id",
+    "findingId",
+];
+const PROGRESS_SHAPE_KEYS = new Set(["event", "progress", "heartbeat", "complete", "review_context"]);
+const PROGRESS_TYPE_VALUES = new Set([
+    "progress",
+    "status",
+    "heartbeat",
+    "complete",
+    "review_context",
+    "reviewcontext",
+]);
+const PROGRESS_STATUS_VALUES = new Set([
+    "in_progress",
+    "running",
+    "pending",
+    "complete",
+    "completed",
+    "done",
+    "heartbeat",
+    "ok",
+    "success",
+]);
+function hasFindingLocation(record) {
+    return FINDING_LOCATION_KEYS.some((key) => record[key] !== undefined);
+}
+function hasFindingReviewContent(record) {
+    return FINDING_REVIEW_KEYS.some((key) => record[key] !== undefined);
+}
+function isProgressRecord(record) {
+    // Check progress/status indicators FIRST before the generic finding-content guard
+    const keys = Object.keys(record);
+    if (keys.length === 0)
+        return false;
+    if (keys.some((key) => PROGRESS_SHAPE_KEYS.has(key)))
+        return true;
+    if (typeof record.type === "string" && PROGRESS_TYPE_VALUES.has(record.type.toLowerCase()))
+        return true;
+    if (typeof record.status === "string" && PROGRESS_STATUS_VALUES.has(record.status.toLowerCase()))
+        return true;
+    // Status-only records with category="status" are progress records even if they have message/title fields
+    if (typeof record.category === "string" && record.category.toLowerCase() === "status")
+        return true;
+    // Only reject as progress if it has both location AND review content (true finding shape)
+    if (hasFindingLocation(record) && hasFindingReviewContent(record)) {
+        return false;
+    }
+    return false;
+}
+function isActionableFinding(record) {
+    if (isProgressRecord(record))
+        return false;
+    return hasFindingLocation(record) || hasFindingReviewContent(record);
+}
+function makeUnusableOutputError(message) {
+    const err = new Error(message);
+    err.qcFailureReason = "unusable-output";
+    return err;
+}
 function buildRange(raw) {
     const startLine = coerceNumber(raw.startLine ?? raw.line) ?? 1;
     const endLine = coerceNumber(raw.endLine);
@@ -37,23 +110,27 @@ function parseFindingsFromPayload(payload) {
     }
     const record = payload;
     if (Array.isArray(record.findings)) {
-        return record.findings;
+        return record.findings.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
     }
     if (Array.isArray(record.issues)) {
-        return record.issues;
+        return record.issues.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
     }
     if (Array.isArray(record.results)) {
-        return record.results;
+        return record.results.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
     }
     // Single finding wrapped in an object
-    if (record.severity !== undefined ||
-        record.message !== undefined ||
-        record.title !== undefined) {
+    if (isActionableFinding(record)) {
         return [record];
     }
     return [];
 }
-function parseReport(output) {
+function parseReport(output, format, parser) {
+    if (parser && parser !== "coderabbit") {
+        throw new Error(`Unsupported parser for CodeRabbit provider: ${parser}`);
+    }
+    if (format === "sarif") {
+        throw new Error("SARIF output format is not supported by the CodeRabbit provider");
+    }
     const text = "stdout" in output && typeof output.stdout === "string" ? output.stdout : "";
     const data = "data" in output ? output.data : undefined;
     if (data !== undefined && typeof data === "object" && data !== null) {
@@ -64,30 +141,61 @@ function parseReport(output) {
             ...(typeof record.prUrl === "string" ? { prUrl: record.prUrl } : {}),
         };
     }
-    if (text.trim().startsWith("{") || text.trim().startsWith("[")) {
+    if (text.trim().length === 0) {
+        return null;
+    }
+    if (format === "json" || text.trim().startsWith("{") || text.trim().startsWith("[")) {
         try {
             const parsed = JSON.parse(text);
             if (Array.isArray(parsed)) {
-                return { findings: parsed };
+                const findings = parsed.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
+                if (findings.length === 0 && parsed.length > 0) {
+                    const progressCount = parsed.filter((item) => typeof item === "object" && item !== null && isProgressRecord(item)).length;
+                    if (progressCount > 0) {
+                        throw makeUnusableOutputError(`CodeRabbit output contained only progress/status/heartbeat records (${progressCount} items)`);
+                    }
+                }
+                return { findings };
+            }
+            const findings = parseFindingsFromPayload(parsed);
+            if (findings.length === 0 && isProgressRecord(parsed)) {
+                throw makeUnusableOutputError("CodeRabbit output was a progress/status/heartbeat record");
             }
             return {
-                findings: parseFindingsFromPayload(parsed),
+                findings,
                 ...(typeof parsed?.prUrl === "string"
                     ? { prUrl: parsed.prUrl }
                     : {}),
             };
         }
-        catch {
-            // Fall through to line scanning.
+        catch (jsonError) {
+            // When the format is explicitly JSON, a parse error is a real failure.
+            // Otherwise, treat the text as JSONL and fall through to line scanning.
+            if (format === "json") {
+                throw jsonError;
+            }
         }
     }
-    // Try JSONL: one finding per line
+    // JSONL or generic line scanning: one finding per line
     const lines = text.split("\n").filter((line) => line.trim().length > 0);
     const lineFindings = [];
+    let progressLineCount = 0;
+    let parsedLineCount = 0;
     for (const line of lines) {
         try {
             const parsed = JSON.parse(line);
-            lineFindings.push(parsed);
+            parsedLineCount++;
+            if (!parsed || typeof parsed !== "object") {
+                continue;
+            }
+            const record = parsed;
+            if (isProgressRecord(record)) {
+                progressLineCount++;
+                continue;
+            }
+            if (isActionableFinding(record)) {
+                lineFindings.push(parsed);
+            }
         }
         catch {
             // Ignore unparseable lines.
@@ -96,7 +204,13 @@ function parseReport(output) {
     if (lineFindings.length > 0) {
         return { findings: lineFindings };
     }
-    return null;
+    if (progressLineCount > 0) {
+        throw makeUnusableOutputError(`CodeRabbit output contained only progress/status/heartbeat records (${progressLineCount} lines)`);
+    }
+    if (parsedLineCount > 0) {
+        throw new Error("CodeRabbit output contained no actionable findings");
+    }
+    throw new Error("CodeRabbit output could not be parsed as JSON, JSONL, or metrics payload");
 }
 function normalizeFinding(raw, index) {
     const severityLabel = pickString(raw.severity, raw.level) ?? "info";
@@ -179,6 +293,7 @@ function buildResultFromReport(report, output, mode, providerFailed = false) {
  * No external network calls are made here.
  */
 class CodeRabbitQcProvider {
+    config;
     name = "coderabbit";
     supportedModes = ["local", "pr", "metrics-import"];
     capabilities = [
@@ -188,22 +303,42 @@ class CodeRabbitQcProvider {
         "auto-fix",
         "metrics-import",
     ];
+    constructor(config) {
+        this.config = config;
+    }
     canReview(scope) {
         if (scope.prUrl)
             return true;
         return Boolean(scope.branch);
     }
     buildReviewCommand(scope) {
+        const execution = this.config?.execution;
+        if (execution) {
+            const args = execution.args ? [...execution.args] : [];
+            if (execution.configPath) {
+                args.push("--config", execution.configPath);
+            }
+            const baseRef = scope.baseRef ?? scope.branch ?? "main";
+            if (scope.prUrl) {
+                args.push("--pr-url", scope.prUrl);
+            }
+            else {
+                args.push("--base", baseRef);
+            }
+            return { command: execution.command, args };
+        }
         if (scope.prUrl) {
             return { command: "coderabbit", args: ["review", "--agent", "--pr-url", scope.prUrl] };
         }
+        const baseRef = scope.baseRef ?? scope.branch ?? "main";
         return {
             command: "coderabbit",
-            args: ["review", "--agent", "--branch", scope.branch ?? "HEAD"],
+            args: ["review", "--agent", "--base", baseRef],
         };
     }
     parse(output) {
-        const report = parseReport(output);
+        const outputConfig = this.config?.execution?.output;
+        const report = parseReport(output, outputConfig?.format, outputConfig?.parser);
         return buildResultFromReport(report, output, "local", output.exitCode !== 0);
     }
     importMetrics(payload) {