@open-cr-agent/core 0.1.0

package/dist/pipeline/report.d.ts

@@ -0,0 +1,118 @@
+import type { Usage } from "../contracts.js";
+import type { AnchorMethod, ChangeRequest, Finding, PriorFinding, RiskTier, Verdict } from "../domain.js";
+import type { JudgeDecisions } from "../judge/judge.js";
+import type { MemoryEntry } from "../memory/memory.js";
+import type { ExclusionReason } from "../select/select.js";
+import type { RefutedFinding } from "../verify/verify.js";
+import type { SkippedCell } from "./matrix.js";
+export type CoverageEntry = {
+    path: string;
+    status: "reviewed" | "failed" | "unreviewed" | "unchanged";
+} | {
+    path: string;
+    status: "excluded";
+    reason: ExclusionReason;
+};
+export declare function coverageGaps(coverage: readonly CoverageEntry[]): {
+    notReviewed: number;
+    nothingReviewed: boolean;
+};
+export type TaskStatus = "completed" | "failed" | "timed_out" | "cancelled";
+export interface TaskOutcome {
+    taskId: string;
+    reviewer: string;
+    bundle: string;
+    files: string[];
+    status: TaskStatus;
+    error?: string;
+    findings: number;
+    durationMs: number;
+}
+export interface ReviewReport {
+    changeRequest: ChangeRequest;
+    tier: RiskTier;
+    verdict: Verdict;
+    summary: string;
+    coverage: CoverageEntry[];
+    bundles: {
+        label: string;
+        files: string[];
+    }[];
+    tasks: TaskOutcome[];
+    skipped: SkippedCell[];
+    findings: Finding[];
+    unverifiedCriticals: number;
+    refuted: RefutedFinding[];
+    remembered: MemoryEntry[];
+    judgement?: JudgeDecisions;
+    scope?: {
+        mode: "incremental";
+        since: string;
+    } | {
+        mode: "full";
+        reason: string;
+    };
+    rereview?: {
+        fixed: PriorFinding[];
+        notReproduced: PriorFinding[];
+        notRechecked: PriorFinding[];
+        unchanged: PriorFinding[];
+        dismissed: PriorFinding[];
+    };
+    anchoring?: AnchoringSummary;
+    usage: Usage;
+    warnings: string[];
+}
+export type ReviewEvent = {
+    type: "run_started";
+    changeRequest: ChangeRequest;
+} | {
+    type: "files_selected";
+    selected: number;
+    excluded: number;
+    tier: RiskTier;
+} | {
+    type: "files_bundled";
+    strategy: string;
+    bundles: number;
+    warnings: string[];
+} | {
+    type: "matrix_planned";
+    tasks: number;
+    skipped: SkippedCell[];
+} | {
+    type: "task_started";
+    taskId: string;
+    reviewer: string;
+    bundle: string;
+    files: string[];
+} | {
+    type: "task_progress";
+    taskId: string;
+    message: string;
+} | {
+    type: "finding";
+    taskId: string;
+    finding: Finding;
+} | {
+    type: "task_finished";
+    outcome: TaskOutcome;
+} | {
+    type: "verification_finished";
+    checked: number;
+    refuted: RefutedFinding[];
+} | {
+    type: "judge_finished";
+    verdict: Verdict;
+    judgement?: JudgeDecisions;
+} | {
+    type: "run_finished";
+    report: ReviewReport;
+};
+export interface AnchoringSummary {
+    byMethod: Record<AnchorMethod, number>;
+    ambiguous: number;
+    relocationCalls: number;
+}
+export declare function summarizeAnchoring(findings: readonly Finding[], relocationCalls: number): AnchoringSummary;
+//# sourceMappingURL=report.d.ts.map

package/dist/pipeline/report.js

@@ -0,0 +1,27 @@
+// How much of the selection this run actually reviewed. Every surface (exit
+// code, terminal, pull request summary) reads it from here, so none of them
+// can call a run that reviewed nothing "approved".
+export function coverageGaps(coverage) {
+    const notReviewed = coverage.filter((c) => c.status === "failed" || c.status === "unreviewed").length;
+    // Unchanged files were reviewed by an earlier run, and their findings and
+    // verdict carry over: a re-review whose new files all failed still has them.
+    const reviewed = coverage.some((c) => c.status === "reviewed" || c.status === "unchanged");
+    return { notReviewed, nothingReviewed: notReviewed > 0 && !reviewed };
+}
+export function summarizeAnchoring(findings, relocationCalls) {
+    const byMethod = {
+        hunk: 0,
+        file: 0,
+        cross_file: 0,
+        relocated: 0,
+        file_level: 0,
+    };
+    for (const f of findings)
+        byMethod[f.anchor.method] += 1;
+    return {
+        byMethod,
+        ambiguous: findings.filter((f) => f.anchor.ambiguous).length,
+        relocationCalls,
+    };
+}
+//# sourceMappingURL=report.js.map

package/dist/pipeline/run.d.ts

@@ -0,0 +1,36 @@
+import type { AnchorContext } from "../anchor/anchor.js";
+import type { BundlePolicy } from "../bundle/bundle.js";
+import type { FileGrouper } from "../bundle/grouping.js";
+import type { AgentRuntime, VcsAdapter } from "../contracts.js";
+import type { ReviewerDefinition } from "../review/reviewer.js";
+import type { RepoRule } from "../rules/repo-rules.js";
+import type { SelectionPolicy } from "../select/select.js";
+import { type ReviewerOverrides } from "./matrix.js";
+import { type ReviewEvent, type ReviewReport } from "./report.js";
+export { GUIDELINES_PATH } from "./plan.js";
+export interface ReviewOptions {
+    vcs: VcsAdapter;
+    runtime: AgentRuntime;
+    reviewers?: readonly ReviewerDefinition[];
+    reviewerOverrides?: ReviewerOverrides;
+    rules?: readonly RepoRule[];
+    readTrusted?: (path: string) => Promise<string | undefined>;
+    selection?: SelectionPolicy;
+    bundling?: BundlePolicy;
+    grouper?: FileGrouper;
+    relocate?: AnchorContext["relocate"] | false;
+    concurrency?: number;
+    taskTimeoutMs?: number;
+    runTimeoutMs?: number;
+    abortGraceMs?: number;
+    verify?: boolean;
+    judge?: boolean;
+    maxCostUsd?: number;
+    maxTasks?: number;
+    fullReview?: boolean;
+    ultra?: boolean;
+    signal?: AbortSignal;
+    onEvent?: (event: ReviewEvent) => void;
+}
+export declare function runReview(options: ReviewOptions): Promise<ReviewReport>;
+//# sourceMappingURL=run.d.ts.map

package/dist/pipeline/run.js

@@ -0,0 +1,301 @@
+import { runtimeRelocator } from "../anchor/relocate.js";
+import { errorMessage } from "../errors.js";
+import { judgeFindings } from "../judge/judge.js";
+import { applyMemory } from "../memory/memory.js";
+import { priorCodePresence } from "../rereview/presence.js";
+import { reconcile, stillOpen } from "../rereview/reconcile.js";
+import { correctnessReviewer } from "../review/reviewers/correctness.js";
+import { markUnchecked, verifyFindings } from "../verify/verify.js";
+import { spendTracker } from "./budget.js";
+import { runJob } from "./execute.js";
+import { dedupeFindings } from "./findings.js";
+import { DEFAULT_MAX_TASKS, planTasks } from "./matrix.js";
+import { planReview } from "./plan.js";
+import { mapWithConcurrency } from "./pool.js";
+import { coverageGaps, summarizeAnchoring, } from "./report.js";
+import { addUsage, emptyUsage } from "./usage.js";
+export { GUIDELINES_PATH } from "./plan.js";
+const DEFAULTS = { concurrency: 4, taskTimeoutMs: 10 * 60_000, runTimeoutMs: 25 * 60_000 };
+// Plan (deterministic stages) → execute (one agent task per cell) → report.
+export async function runReview(options) {
+    const emit = options.onEvent ?? (() => { });
+    const timeout = AbortSignal.timeout(options.runTimeoutMs ?? DEFAULTS.runTimeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+    const reviewers = options.reviewers ?? [correctnessReviewer];
+    if (reviewers.length === 0)
+        throw new Error("No reviewer is registered");
+    const prior = await loadPriorReview(options.vcs);
+    const scope = reviewScope(prior.review, options.fullReview === true);
+    const plan = await planReview(scope.only
+        ? {
+            ...options,
+            reviewOnly: scope.only,
+            ...(prior.review?.tier ? { priorTier: prior.review.tier } : {}),
+        }
+        : options, emit, signal);
+    const matrix = planTasks(plan.bundles, reviewers, plan.tier, options.reviewerOverrides, {
+        ultra: options.ultra === true,
+        ...(options.maxTasks !== undefined ? { maxTasks: options.maxTasks } : {}),
+        hasGuidelines: Boolean(plan.guidelines?.trim()),
+    });
+    const limited = matrix.skipped.filter((s) => s.reason === "task_limit").length;
+    if (limited > 0) {
+        plan.warnings.push(`task limit of ${options.maxTasks ?? DEFAULT_MAX_TASKS} reached: ${limited} review task(s) skipped; their files are reported as not reviewed`);
+    }
+    emit({ type: "matrix_planned", tasks: matrix.cells.length, skipped: matrix.skipped });
+    const relocationUsage = [];
+    const budget = spendTracker(options.maxCostUsd, plan.usage);
+    const relocator = options.relocate === false
+        ? undefined
+        : (options.relocate ??
+            runtimeRelocator(options.runtime, signal, (u) => {
+                relocationUsage.push(u);
+                budget.add(u);
+            }));
+    const execute = {
+        runtime: options.runtime,
+        taskTimeoutMs: options.taskTimeoutMs ?? DEFAULTS.taskTimeoutMs,
+        abortGraceMs: options.abortGraceMs,
+        // Past the spend limit a quote that does not match stays file-level.
+        relocate: relocator &&
+            (async (request) => (budget.exhausted() ? undefined : relocator(request))),
+        ultra: options.ultra === true,
+        plans: new Map(),
+        emit,
+        signal,
+    };
+    const results = await mapWithConcurrency(matrix.cells, options.concurrency ?? DEFAULTS.concurrency, async (cell) => {
+        // Once the run is cancelled or timed out, remaining cells are not started.
+        if (signal.aborted)
+            return skipCell(cell, "run cancelled before this task started", emit);
+        if (budget.reviewExhausted()) {
+            return skipCell(cell, `spend limit of $${options.maxCostUsd} reached`, emit);
+        }
+        const result = await runJob(cell, plan, execute);
+        budget.add(result.usage);
+        return result;
+    });
+    // Memory and the previous review filter first, so Verify and Judge are not
+    // paid for findings that will not be reported, and a person's dismissal
+    // keeps a finding out of the verdict whatever the models say.
+    const concurrency = options.concurrency ?? DEFAULTS.concurrency;
+    const found = dedupeFindings(results.flatMap((r) => r.findings));
+    const fileCoverage = coverage(plan.decisions, results, plan.unchanged, matrix.limited ?? []);
+    const remembered = applyMemory(found, plan.memory);
+    const reported = new Set(found.map((f) => f.fingerprint));
+    const priorReview = withoutRemembered(prior.review, plan.memory);
+    const reconciled = reconcile({
+        findings: remembered.kept,
+        reported,
+        prior: priorReview,
+        coverage: fileCoverage,
+        stillPresent: await priorCodePresence(priorReview, reported, plan.context.readFile),
+    });
+    const verification = options.verify === false
+        ? {
+            checked: 0,
+            kept: markUnchecked(reconciled.findings),
+            refuted: [],
+            missed: [],
+            usage: [],
+            warnings: [],
+        }
+        : await verifyFindings(reconciled.findings, {
+            runtime: options.runtime,
+            diffs: plan.selected,
+            context: plan.context,
+            signal,
+            concurrency,
+            budget,
+        });
+    if (verification.checked > 0) {
+        emit({
+            type: "verification_finished",
+            checked: verification.checked,
+            refuted: verification.refuted,
+        });
+    }
+    const judgeWanted = options.judge !== false && verification.kept.length > 0;
+    const judgeAffordable = !budget.exhausted();
+    const judged = await judgeFindings(verification.kept, {
+        runtime: options.runtime,
+        changeRequest: plan.changeRequest,
+        tier: plan.tier,
+        signal,
+        enabled: judgeWanted && judgeAffordable,
+        keepDropped: options.ultra === true,
+        carried: stillOpen(reconciled),
+    });
+    if (judgeWanted && !judgeAffordable) {
+        judged.warnings.push(`spend limit of $${options.maxCostUsd} reached: findings were not judged`);
+    }
+    const { nothingReviewed } = coverageGaps(fileCoverage);
+    if (!nothingReviewed) {
+        emit(judged.decisions
+            ? { type: "judge_finished", verdict: judged.verdict, judgement: judged.decisions }
+            : { type: "judge_finished", verdict: judged.verdict });
+    }
+    const report = {
+        changeRequest: plan.changeRequest,
+        tier: plan.tier,
+        verdict: judged.verdict,
+        summary: nothingReviewed
+            ? "Nothing was reviewed: no reviewer covered or finished any selected file."
+            : judged.summary,
+        coverage: fileCoverage,
+        bundles: plan.bundles.map((b) => ({ label: b.label, files: b.files.map((f) => f.newPath) })),
+        tasks: results.map((r) => r.outcome),
+        skipped: matrix.skipped,
+        findings: sortFindings(judged.findings),
+        // Counted before the judge: dropping or downgrading a critical nobody
+        // could check must not turn an incomplete run into a clean one.
+        unverifiedCriticals: countMissedCriticals(verification.kept, verification.missed),
+        refuted: verification.refuted,
+        remembered: remembered.remembered,
+        usage: sumUsage([
+            ...plan.usage,
+            ...results.map((r) => r.usage),
+            ...relocationUsage,
+            ...verification.usage,
+            ...judged.usage,
+        ]),
+        warnings: [
+            ...plan.warnings,
+            ...results.flatMap((r) => r.warnings),
+            ...verification.warnings,
+            ...judged.warnings,
+        ],
+    };
+    if (judged.decisions)
+        report.judgement = judged.decisions;
+    report.anchoring = summarizeAnchoring(report.findings, relocationUsage.length);
+    if (prior.review) {
+        report.rereview = {
+            fixed: reconciled.fixed,
+            notReproduced: reconciled.notReproduced,
+            notRechecked: reconciled.notRechecked,
+            unchanged: reconciled.unchanged,
+            dismissed: reconciled.dismissed,
+        };
+    }
+    if (plan.widened) {
+        report.scope = {
+            mode: "full",
+            reason: `the risk tier rose from ${plan.widened.from} to ${plan.widened.to}, which adds reviewers`,
+        };
+    }
+    else if (scope.note)
+        report.scope = scope.note;
+    if (prior.warning)
+        report.warnings.push(prior.warning);
+    emit({ type: "run_finished", report });
+    return report;
+}
+function skipCell(cell, reason, emit) {
+    const outcome = {
+        taskId: cell.taskId,
+        reviewer: cell.reviewer.id,
+        bundle: cell.bundle.label,
+        files: cell.bundle.files.map((f) => f.newPath),
+        status: "cancelled",
+        error: reason,
+        findings: 0,
+        durationMs: 0,
+    };
+    emit({ type: "task_finished", outcome });
+    return { outcome, findings: [], usage: emptyUsage(), warnings: [] };
+}
+// An earlier finding the team has since accepted is no longer open.
+function withoutRemembered(review, memory) {
+    if (!review)
+        return undefined;
+    const accepted = new Set(memory.map((e) => e.fingerprint));
+    // Everything else the earlier review carries (replies, tier, head) stays.
+    return { ...review, findings: review.findings.filter((f) => !accepted.has(f.fingerprint)) };
+}
+// Review only what changed since the earlier review when the platform can
+// tell; otherwise everything, with the reason in the report.
+function reviewScope(review, full) {
+    if (!review)
+        return {};
+    if (full)
+        return { note: { mode: "full", reason: "a full review was requested" } };
+    if (review.changedSince) {
+        return {
+            only: new Set(review.changedSince.files),
+            note: { mode: "incremental", since: review.changedSince.head },
+        };
+    }
+    const reason = review.fullReviewReason ?? "the platform cannot tell what changed since";
+    return { note: { mode: "full", reason } };
+}
+// A missing earlier review only costs the comparison, never the review.
+async function loadPriorReview(vcs) {
+    try {
+        const review = await vcs.getPriorReview();
+        return review ? { review } : {};
+    }
+    catch (error) {
+        return { warning: `could not load the previous review: ${errorMessage(error)}` };
+    }
+}
+function coverage(decisions, results, unchanged, limited) {
+    // A file is reviewed when every reviewer assigned to it finished at least
+    // one of its tasks: under --ultra one completed sample is enough. A
+    // reviewer whose task failed makes the file "failed"; one the task limit
+    // never started makes it "unreviewed".
+    const done = new Map();
+    const ran = new Set();
+    const key = (reviewer, file) => `${reviewer}\0${file}`;
+    for (const { outcome } of results) {
+        for (const file of outcome.files) {
+            const k = key(outcome.reviewer, file);
+            ran.add(k);
+            done.set(k, done.get(k) === true || outcome.status === "completed");
+        }
+    }
+    for (const cell of limited) {
+        for (const f of cell.bundle.files) {
+            const k = key(cell.reviewer.id, f.newPath);
+            if (!done.has(k))
+                done.set(k, false);
+        }
+    }
+    const status = new Map();
+    for (const [k, completed] of done) {
+        const file = k.split("\0")[1];
+        const now = completed ? "reviewed" : ran.has(k) ? "failed" : "unreviewed";
+        const before = status.get(file);
+        // failed outranks unreviewed, which outranks reviewed.
+        if (!before || now === "failed" || (now === "unreviewed" && before === "reviewed")) {
+            status.set(file, now);
+        }
+    }
+    return decisions.map((d) => {
+        const path = d.diff.newPath;
+        if (!d.selected)
+            return { path, status: "excluded", reason: d.reason };
+        if (unchanged.has(path))
+            return { path, status: "unchanged" };
+        return { path, status: status.get(path) ?? "unreviewed" };
+    });
+}
+const SEVERITY_ORDER = { critical: 0, warning: 1, suggestion: 2 };
+function sortFindings(findings) {
+    return findings.sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] ||
+        a.file.localeCompare(b.file) ||
+        (a.lineRange?.start ?? 0) - (b.lineRange?.start ?? 0));
+}
+function sumUsage(usages) {
+    return usages.reduce(addUsage, emptyUsage());
+}
+// Low-confidence findings do not count toward the verdict, so their missed
+// verification does not make the run incomplete either.
+function countMissedCriticals(findings, missed) {
+    const set = new Set(missed);
+    return findings.filter((f) => f.severity === "critical" &&
+        !f.lowConfidence &&
+        f.verification === "unchecked" &&
+        set.has(f.fingerprint)).length;
+}
+//# sourceMappingURL=run.js.map

package/dist/pipeline/task.d.ts

@@ -0,0 +1,19 @@
+import type { AgentRuntime, AgentTaskSpec, Usage } from "../contracts.js";
+import { type ReportedFinding } from "../domain.js";
+import type { TaskStatus } from "./report.js";
+export interface TaskResult {
+    status: TaskStatus;
+    error?: string;
+    findings: ReportedFinding[];
+    usage: Usage;
+    warnings: string[];
+}
+export interface TaskCallbacks {
+    onProgress(message: string): void;
+    category: string;
+    abortGraceMs?: number | undefined;
+}
+export declare function executeTask(runtime: AgentRuntime, spec: AgentTaskSpec, runSignal: AbortSignal, callbacks: TaskCallbacks): Promise<TaskResult>;
+export declare const ABORT_GRACE_MS = 10000;
+export declare const MAX_FINDINGS_PER_TASK = 50;
+//# sourceMappingURL=task.d.ts.map

package/dist/pipeline/task.js

@@ -0,0 +1,143 @@
+import { reportedFindingSchema } from "../domain.js";
+import { errorMessage } from "../errors.js";
+import { addUsage, emptyUsage } from "./usage.js";
+export async function executeTask(runtime, spec, runSignal, callbacks) {
+    const timeout = AbortSignal.timeout(spec.timeoutMs);
+    const signal = AbortSignal.any([runSignal, timeout]);
+    const result = {
+        status: "completed",
+        findings: [],
+        usage: emptyUsage(),
+        warnings: [],
+    };
+    let iterator;
+    let pending;
+    try {
+        iterator = runtime.runTask(spec, signal)[Symbol.asyncIterator]();
+        for (;;) {
+            pending = iterator.next();
+            const next = await untilAborted(pending, signal);
+            pending = undefined;
+            if (next.done)
+                break;
+            if (handle(next.value, result, callbacks)) {
+                void iterator.return?.();
+                break;
+            }
+        }
+    }
+    catch (error) {
+        if (signal.aborted) {
+            const timedOut = timeout.aborted && !runSignal.aborted;
+            result.status = timedOut ? "timed_out" : "cancelled";
+            result.error = timedOut ? `timed out after ${spec.timeoutMs}ms` : "run cancelled";
+            if (iterator)
+                await collectAfterAbort(iterator, pending, result, callbacks);
+            void iterator?.return?.();
+        }
+        else {
+            result.status = "failed";
+            result.error = errorMessage(error);
+        }
+    }
+    return result;
+}
+// A task cut off by its timeout or by Ctrl-C has still spent tokens and may
+// have reported findings; a runtime that stops its session delivers them
+// shortly after. Waiting a bounded moment keeps them in the report and in
+// the spend limit, without letting a runtime that ignores the abort hang.
+export const ABORT_GRACE_MS = 10_000;
+async function collectAfterAbort(iterator, pending, result, callbacks) {
+    const grace = AbortSignal.timeout(callbacks.abortGraceMs ?? ABORT_GRACE_MS);
+    let next = pending ?? iterator.next();
+    try {
+        for (;;) {
+            const event = await untilAborted(next, grace);
+            if (event.done)
+                return;
+            const { value } = event;
+            if (value.type === "usage" || value.type === "finding")
+                handle(value, result, callbacks);
+            if (value.type === "done" || value.type === "error")
+                return;
+            next = iterator.next();
+        }
+    }
+    catch {
+        // The runtime did not finish within the grace period, or failed: keep
+        // what arrived.
+    }
+}
+function handle(event, result, callbacks) {
+    switch (event.type) {
+        case "progress":
+            callbacks.onProgress(event.message);
+            return false;
+        case "finding": {
+            const parsed = reportedFindingSchema.safeParse(withReviewerCategory(event.finding, callbacks.category));
+            if (!parsed.success) {
+                result.warnings.push("runtime reported a finding that failed validation");
+            }
+            else if (result.findings.length >= MAX_FINDINGS_PER_TASK) {
+                const warning = `more than ${MAX_FINDINGS_PER_TASK} findings in one task; the rest were dropped`;
+                if (!result.warnings.includes(warning))
+                    result.warnings.push(warning);
+            }
+            else {
+                result.findings.push(bounded(parsed.data));
+            }
+            return false;
+        }
+        case "usage":
+            result.usage = addUsage(result.usage, event);
+            return false;
+        case "done":
+            return true;
+        case "error":
+            result.status = "failed";
+            result.error = event.error;
+            return true;
+    }
+}
+// A reviewer steered by the change could flood the pull request with
+// comments or pad them without end; both are bounded.
+export const MAX_FINDINGS_PER_TASK = 50;
+const MAX_TITLE = 300;
+const MAX_TEXT = 4_000;
+const MAX_EVIDENCE = 10;
+function bounded(f) {
+    const cut = (text, max) => (text.length > max ? `${text.slice(0, max)}…` : text);
+    return {
+        ...f,
+        title: cut(f.title, MAX_TITLE),
+        body: cut(f.body, MAX_TEXT),
+        ...(f.suggestion !== undefined ? { suggestion: cut(f.suggestion, MAX_TEXT) } : {}),
+        evidence: f.evidence.slice(0, MAX_EVIDENCE).map((e) => cut(e, 500)),
+    };
+}
+// The category is part of the fingerprint, so it comes from the reviewer and
+// never from the model: a model choosing another word would make the same
+// issue look new, and its earlier report look fixed.
+function withReviewerCategory(finding, category) {
+    if (typeof finding !== "object" || finding === null)
+        return finding;
+    return { ...finding, category };
+}
+// Runtimes may ignore the abort signal, so waiting for their next event is
+// raced against it to keep the task and run timeouts authoritative.
+function untilAborted(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+//# sourceMappingURL=task.js.map

package/dist/pipeline/usage.d.ts

@@ -0,0 +1,4 @@
+import type { Usage } from "../contracts.js";
+export declare function emptyUsage(): Usage;
+export declare function addUsage(total: Usage, next: Usage): Usage;
+//# sourceMappingURL=usage.d.ts.map

package/dist/pipeline/usage.js

@@ -0,0 +1,13 @@
+export function emptyUsage() {
+    return { inputTokens: 0, outputTokens: 0, reasoningTokens: 0, cachedTokens: 0, costUsd: 0 };
+}
+export function addUsage(total, next) {
+    return {
+        inputTokens: total.inputTokens + next.inputTokens,
+        outputTokens: total.outputTokens + next.outputTokens,
+        reasoningTokens: total.reasoningTokens + next.reasoningTokens,
+        cachedTokens: total.cachedTokens + next.cachedTokens,
+        costUsd: total.costUsd + next.costUsd,
+    };
+}
+//# sourceMappingURL=usage.js.map

package/dist/plugin/builtin.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { OcraPlugin } from "./types.js";
+export declare const correctnessReviewerPlugin: OcraPlugin;
+export declare const securityReviewerPlugin: OcraPlugin;
+export declare const performanceReviewerPlugin: OcraPlugin;
+export declare const docsReviewerPlugin: OcraPlugin;
+export declare const agentsMdReviewerPlugin: OcraPlugin;
+declare const sessionSettings: z.ZodObject<{
+    dir: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>;
+export declare const sessionJsonlPlugin: OcraPlugin<z.infer<typeof sessionSettings>>;
+export {};
+//# sourceMappingURL=builtin.d.ts.map