@effect-agent/pr-review 0.1.0-beta.27 → 0.1.0-beta.29

package/src/internal/anchors.ts

@@ -1,20 +0,0 @@
-import { commentableLines } from "./diff.ts";
-import type { ChangedFile } from "./diff.ts";
-import type { ReviewFinding } from "./review-agent.ts";
-
-/** Why a finding cannot anchor to the current new-version diff, if any. */
-export const anchorViolation = (
-  finding: ReviewFinding,
-  files: ReadonlyArray<ChangedFile>,
-): string | undefined => {
-  const file = files.find((candidate) => candidate.path === finding.path);
-  if (file === undefined) return "path is not part of the changeset";
-  if (file.patch === undefined) return "file has no anchorable textual diff";
-  if (finding.endLine < finding.startLine) return "endLine precedes startLine";
-  if (finding.endLine - finding.startLine + 1 > 100) return "range is implausibly large";
-  const anchors = commentableLines(file.patch);
-  for (let line = finding.startLine; line <= finding.endLine; line += 1) {
-    if (!anchors.has(line)) return `line ${line} is not part of the diff`;
-  }
-  return undefined;
-};

package/src/internal/coverage.ts

@@ -1,357 +0,0 @@
-import { Option, Schema } from "effect";
-import type { RunEvent } from "effect-agent";
-
-import type { ChangedFile } from "./diff.ts";
-import { isReviewableFile } from "./diff.ts";
-import { FileDiffView, FileDiffQuery } from "./review-agent.ts";
-import type { ReviewUnitPlan } from "./review-units.ts";
-
-// ---------------------------------------------------------------------------
-// Two different claims are deliberately modeled:
-//
-// - input coverage: every required path was assigned bounded evidence or was
-//   explicitly reported outside the pipeline's capacity;
-// - review assurance: every scheduled discovery/specialist pass and every
-//   candidate-verification pass settled.
-//
-// Neither claims that the model found every defect. The fan-out pipeline is
-// host-scheduled (fan-out.ts), so its assurance is computed from direct pass
-// results; only the flat reviewer is assessed from its Run event trace here.
-// ---------------------------------------------------------------------------
-
-export class ReviewInputCoverage extends Schema.Class<ReviewInputCoverage>(
-  "@effect-agent/pr-review/ReviewInputCoverage",
-)({
-  status: Schema.Literals(["complete", "incomplete"]),
-  requiredPaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  assignedPaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  /** Assigned paths whose model-visible diff was truncated by the evidence bound. */
-  partialPaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  unassignedPaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  /**
-   * Paths with neither a textual diff nor bounded base/head text (binaries,
-   * oversized files). Fail-closed: they keep the status incomplete for as
-   * long as they are part of the pull request — an unreviewable change must
-   * never authorize a green check. Exclude them deliberately with ignore
-   * globs when that is intended.
-   */
-  undiffablePaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  reasons: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(1_000))).check(
-    Schema.isMaxLength(20),
-  ),
-}) {}
-
-export class FailedReviewPass extends Schema.Class<FailedReviewPass>(
-  "@effect-agent/pr-review/FailedReviewPass",
-)({
-  workId: Schema.NonEmptyString.check(Schema.isMaxLength(96)),
-  stage: Schema.Literals(["discovery", "specialist", "verification"]),
-  errorTag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
-}) {}
-
-/**
- * Settlement of scheduled review work. `incomplete` means reviewer-side work
- * failed after its bounded retry — a machinery gap that is carried forward and
- * retried on the next run, never a statement about the code under review.
- * `unverified` is the flat reviewer's honest constant: one pass with no
- * independent verifier is neither settled assurance nor a failure.
- */
-export class ReviewAssurance extends Schema.Class<ReviewAssurance>(
-  "@effect-agent/pr-review/ReviewAssurance",
-)({
-  status: Schema.Literals(["settled", "incomplete", "unverified"]),
-  requiredGeneralDiscoveryPasses: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  completedGeneralDiscoveryPasses: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  requiredSpecialistPasses: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  completedSpecialistPasses: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  requiredVerificationPasses: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  completedVerificationPasses: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  discoveredCandidates: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  confirmedCandidates: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  rejectedCandidates: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  unsettledCandidates: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  /** Discovery claims discarded for anchors/paths outside their assigned evidence. */
-  discardedInvalidFindings: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  failedPasses: Schema.Array(FailedReviewPass).check(Schema.isMaxLength(64)),
-  reasons: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(1_000))).check(
-    Schema.isMaxLength(32),
-  ),
-}) {}
-
-interface ToolTrace {
-  readonly declared: Map<string, Extract<RunEvent, { readonly _tag: "ToolCallDeclared" }>>;
-  readonly succeeded: Map<string, Extract<RunEvent, { readonly _tag: "ToolCallSucceeded" }>>;
-  readonly failed: Map<string, Extract<RunEvent, { readonly _tag: "ToolCallFailed" }>>;
-}
-
-const toolTrace = (events: ReadonlyArray<RunEvent>): ToolTrace => {
-  const declared = new Map<string, Extract<RunEvent, { readonly _tag: "ToolCallDeclared" }>>();
-  const succeeded = new Map<string, Extract<RunEvent, { readonly _tag: "ToolCallSucceeded" }>>();
-  const failed = new Map<string, Extract<RunEvent, { readonly _tag: "ToolCallFailed" }>>();
-  for (const event of events) {
-    if (event._tag === "ToolCallDeclared") declared.set(event.toolCallId, event);
-    if (event._tag === "ToolCallSucceeded") succeeded.set(event.toolCallId, event);
-    if (event._tag === "ToolCallFailed") failed.set(event.toolCallId, event);
-  }
-  return { declared, succeeded, failed };
-};
-
-const sortedUnique = (values: Iterable<string>): ReadonlyArray<string> =>
-  [...new Set(values)].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
-
-/** Render a bounded, deterministic "label (n): a, b, … (+k more)" reason line. */
-export const boundedListReason = (label: string, values: Iterable<string>): string => {
-  const items = sortedUnique(values);
-  const prefix = `${label} (${items.length}): `;
-  let rendered = prefix;
-  for (let index = 0; index < items.length; index += 1) {
-    const item = items[index] ?? "";
-    const separator = index === 0 ? "" : ", ";
-    const omitted = items.length - index - 1;
-    const suffix = omitted === 0 ? "" : ` … (+${omitted} more)`;
-    if (`${rendered}${separator}${item}${suffix}`.length > 1_000) {
-      const omission = `… (+${items.length - index} more)`;
-      return `${rendered.slice(0, 1_000 - omission.length)}${omission}`;
-    }
-    rendered = `${rendered}${separator}${item}`;
-  }
-  return rendered;
-};
-
-export interface CarriedScope {
-  /** Carried paths a retry can actually settle (failed passes, overflow). */
-  readonly retryablePaths: ReadonlyArray<string>;
-  /** Carried paths no retry can settle (binaries, oversized files). */
-  readonly undiffablePaths: ReadonlyArray<string>;
-  /** Whether any incompleteness beyond the undiffable files exists. */
-  readonly retryableGap: boolean;
-}
-
-/**
- * Split carried scope into paths a retry can settle and paths it never can.
- * Undiffable files are a property of the pull request, not a transient
- * reviewer-side failure: gate reasons and rendered callouts must never promise
- * they are "retried automatically" — the honest instruction is to remove them
- * from the pull request or exclude them with ignore globs.
- */
-export const splitCarriedScope = (input: {
-  readonly inputCoverage?: ReviewInputCoverage | undefined;
-  readonly assurance?: ReviewAssurance | undefined;
-  readonly unreviewedPaths?: ReadonlyArray<string> | undefined;
-}): CarriedScope => {
-  const undiffable = new Set(input.inputCoverage?.undiffablePaths ?? []);
-  const retryablePaths = (input.unreviewedPaths ?? []).filter((path) => !undiffable.has(path));
-  const undiffablePaths = sortedUnique(undiffable);
-  // Every non-undiffable coverage gap (range truncation, capacity overflow,
-  // truncated or missing evidence, anchor surface) contributes its own reason
-  // line, so a lone reason alongside undiffable paths means the undiffable
-  // files are the entire gap.
-  const coverageGapBeyondUndiffable =
-    input.inputCoverage?.status === "incomplete" &&
-    input.inputCoverage.reasons.length > (undiffablePaths.length > 0 ? 1 : 0);
-  return {
-    retryablePaths,
-    undiffablePaths,
-    retryableGap:
-      input.assurance?.status === "incomplete" ||
-      retryablePaths.length > 0 ||
-      coverageGapBeyondUndiffable,
-  };
-};
-
-const anchorSurfaceAdjusted = (
-  inputCoverage: ReviewInputCoverage,
-  anchorFiles: ReadonlyArray<ChangedFile>,
-  totalAnchorFiles: number,
-): ReviewInputCoverage =>
-  anchorFiles.length >= totalAnchorFiles
-    ? inputCoverage
-    : ReviewInputCoverage.make({
-        ...inputCoverage,
-        status: "incomplete",
-        reasons: [
-          ...inputCoverage.reasons,
-          `full pull-request anchor surface exposed ${anchorFiles.length} of ${totalAnchorFiles} required files`,
-        ],
-      });
-
-/** The flat reviewer's honest constant assurance: one pass, no verifier. */
-export const flatAssurance = (): ReviewAssurance =>
-  ReviewAssurance.make({
-    status: "unverified",
-    requiredGeneralDiscoveryPasses: 1,
-    completedGeneralDiscoveryPasses: 1,
-    requiredSpecialistPasses: 0,
-    completedSpecialistPasses: 0,
-    requiredVerificationPasses: 0,
-    completedVerificationPasses: 0,
-    discoveredCandidates: 0,
-    confirmedCandidates: 0,
-    rejectedCandidates: 0,
-    unsettledCandidates: 0,
-    discardedInvalidFindings: 0,
-    failedPasses: [],
-    reasons: [
-      "flat review has no independent candidate-verification pass; use the fan-out pipeline for a settled assurance result",
-    ],
-  });
-
-export interface FlatReviewAssessment {
-  readonly inputCoverage: ReviewInputCoverage;
-  readonly assurance: ReviewAssurance;
-  /** Retryable evidence gaps (failed or missing diff reads), never undiffable paths. */
-  readonly unreviewedPaths: ReadonlyArray<string>;
-}
-
-/**
- * Assess one settled flat run from its Run event trace: which required paths
- * received successful bounded diff evidence. This observes tool INPUT
- * assignment only — the host cannot know which evidence the model weighed.
- */
-export const assessFlatReview = (input: {
-  readonly files: ReadonlyArray<ChangedFile>;
-  readonly totalFiles: number;
-  readonly anchorFiles: ReadonlyArray<ChangedFile>;
-  readonly totalAnchorFiles: number;
-  readonly events: ReadonlyArray<RunEvent>;
-}): FlatReviewAssessment => {
-  const trace = toolTrace(input.events);
-  const requiredPaths = sortedUnique(input.files.map((file) => file.path));
-  const assigned = new Set<string>();
-  const partial = new Set<string>();
-  const failedPaths = new Set<string>();
-  for (const [toolCallId, declaration] of trace.declared) {
-    if (declaration.toolName !== "read_file_diff") continue;
-    const query = Schema.decodeUnknownOption(FileDiffQuery)(declaration.parameters);
-    if (Option.isNone(query)) continue;
-    const success = trace.succeeded.get(toolCallId);
-    if (success !== undefined) {
-      assigned.add(query.value.path);
-      const view = Schema.decodeUnknownOption(FileDiffView)(success.result);
-      if (Option.isSome(view) && view.value.truncated) partial.add(query.value.path);
-    }
-    if (trace.failed.has(toolCallId)) failedPaths.add(query.value.path);
-  }
-  const undiffable = new Set(
-    input.files.filter((file) => !isReviewableFile(file)).map((file) => file.path),
-  );
-  const unassigned = requiredPaths.filter(
-    (path) => !undiffable.has(path) && (!assigned.has(path) || failedPaths.has(path)),
-  );
-  const reasons: Array<string> = [];
-  if (input.files.length < input.totalFiles) {
-    reasons.push(
-      `review range exposed ${input.files.length} of ${input.totalFiles} required files`,
-    );
-  }
-  if (undiffable.size > 0) {
-    reasons.push(
-      boundedListReason("required paths have no reviewable diff or bounded text", undiffable),
-    );
-  }
-  if (failedPaths.size > 0) reasons.push(boundedListReason("diff reads failed", failedPaths));
-  if (partial.size > 0) {
-    reasons.push(boundedListReason("model-visible diff evidence was truncated", partial));
-  }
-  if (unassigned.length > 0) {
-    reasons.push(boundedListReason("required paths received no successful diff input", unassigned));
-  }
-  const inputCoverage = anchorSurfaceAdjusted(
-    ReviewInputCoverage.make({
-      status: reasons.length === 0 ? "complete" : "incomplete",
-      requiredPaths,
-      assignedPaths: sortedUnique(assigned),
-      partialPaths: sortedUnique(partial),
-      unassignedPaths: sortedUnique(unassigned),
-      undiffablePaths: sortedUnique(undiffable),
-      reasons,
-    }),
-    input.anchorFiles,
-    input.totalAnchorFiles,
-  );
-  return {
-    inputCoverage,
-    assurance: flatAssurance(),
-    // Everything still unreviewed and still part of the pull request carries
-    // forward — undiffable paths included, so the check stays fail-closed
-    // even after they leave the incremental delta.
-    unreviewedPaths: sortedUnique([...unassigned, ...undiffable]),
-  };
-};
-
-/**
- * Input coverage of one host-scheduled fan-out plan: which required paths the
- * bounded plan actually assigned complete evidence for. Capacity overflow and
- * undiffable paths are both real gaps; the pipeline carries them so the check
- * stays fail-closed until they are reviewed, removed, or explicitly ignored.
- */
-export const fanOutInputCoverage = (input: {
-  readonly plan: ReviewUnitPlan;
-  readonly files: ReadonlyArray<ChangedFile>;
-  readonly totalFiles: number;
-  readonly anchorFiles: ReadonlyArray<ChangedFile>;
-  readonly totalAnchorFiles: number;
-}): ReviewInputCoverage => {
-  const plan = input.plan;
-  const assignedPaths = sortedUnique(plan.units.flatMap((unit) => unit.paths));
-  const unassignedPaths = sortedUnique(plan.unassignedPaths);
-  const reasons: Array<string> = [];
-  if (plan.truncated) {
-    reasons.push(
-      `review range exposed ${input.files.length} of ${input.totalFiles} required files`,
-    );
-  }
-  if (plan.undiffablePaths.length > 0) {
-    reasons.push(
-      boundedListReason(
-        "required paths have no reviewable diff or bounded text",
-        plan.undiffablePaths,
-      ),
-    );
-  }
-  if (plan.partialEvidencePaths.length > 0) {
-    reasons.push(
-      boundedListReason(
-        "fan-out capacity left some deterministic evidence shards unassigned",
-        plan.partialEvidencePaths,
-      ),
-    );
-  }
-  if (plan.unassignedEvidenceShardCount > 0) {
-    reasons.push(
-      `${plan.unassignedEvidenceShardCount} deterministic evidence shard(s) exceeded fan-out capacity`,
-    );
-    reasons.push(
-      boundedListReason(
-        `unassigned evidence shard identifier sample (${plan.unassignedEvidenceShardIds.length} of ${plan.unassignedEvidenceShardCount})`,
-        plan.unassignedEvidenceShardIds,
-      ),
-    );
-  }
-  if (plan.unassignedPaths.length > 0) {
-    reasons.push(boundedListReason("fan-out capacity left paths unassigned", plan.unassignedPaths));
-  }
-  return anchorSurfaceAdjusted(
-    ReviewInputCoverage.make({
-      status: reasons.length === 0 ? "complete" : "incomplete",
-      requiredPaths: sortedUnique(input.files.map((file) => file.path)),
-      assignedPaths,
-      partialPaths: plan.partialEvidencePaths,
-      unassignedPaths,
-      undiffablePaths: sortedUnique(plan.undiffablePaths),
-      reasons,
-    }),
-    input.anchorFiles,
-    input.totalAnchorFiles,
-  );
-};

package/src/internal/diff.ts

@@ -1,193 +0,0 @@
-import { Schema } from "effect";
-
-// ---------------------------------------------------------------------------
-// Changed-file and unified-diff primitives shared by the tool surface, the
-// publication planner, and the GitHub adapter. The parser is deterministic
-// and bounded; it never throws on malformed hunks — unparseable patch text
-// simply yields no commentable lines, which fails findings closed.
-// ---------------------------------------------------------------------------
-
-/** A repository-relative file path as transported values carry it. */
-export const ChangedPath = Schema.NonEmptyString.check(Schema.isMaxLength(512));
-
-/** GitHub's changed-file status vocabulary, kept verbatim. */
-export const ChangedFileStatus = Schema.Literals([
-  "added",
-  "removed",
-  "modified",
-  "renamed",
-  "copied",
-  "changed",
-  "unchanged",
-]);
-
-/** One file changed by the pull request, with its optional textual patch. */
-export class ChangedFile extends Schema.Class<ChangedFile>("@effect-agent/pr-review/ChangedFile")({
-  path: ChangedPath,
-  status: ChangedFileStatus,
-  additions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  deletions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  /** Present for renames/copies: the path the file previously had. */
-  previousPath: Schema.optionalKey(ChangedPath),
-  /** Unified-diff hunks; absent for binary or oversized files. */
-  patch: Schema.optionalKey(Schema.String),
-  /**
-   * Bounded UTF-8 content used only when the provider omitted `patch`.
-   * Modified files require both sides; additions require head content and
-   * deletions require base content. These values are review evidence, never
-   * GitHub inline-comment anchors.
-   */
-  reviewBaseContent: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200_000))),
-  reviewHeadContent: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200_000))),
-}) {}
-
-/** Complete rendered fallback evidence must fit one ordinary model context. */
-export const MAX_REVIEW_CONTENT_CHARS = 220_000;
-
-/**
- * Render complete patchless evidence, or refuse it when a required side is
- * absent or B/H annotation would exceed the model-facing bound. Callers use
- * this same value for planning and tool output so truncated fallback evidence
- * can never count as complete coverage.
- */
-export const renderReviewContent = (file: ChangedFile): string | undefined => {
-  if (file.patch !== undefined) return undefined;
-  const includeBase = file.status !== "added";
-  const includeHead = file.status !== "removed";
-  const sections: Array<string> = [
-    "[GitHub omitted the unified diff. B/H lines below are bounded full-file review content, not valid inline-comment anchors. Report defects from this evidence as non-anchored concerns.]",
-  ];
-  let renderedLength = sections[0]?.length ?? 0;
-  const append = (part: string): boolean => {
-    const nextLength = renderedLength + 1 + part.length;
-    if (nextLength > MAX_REVIEW_CONTENT_CHARS) return false;
-    sections.push(part);
-    renderedLength = nextLength;
-    return true;
-  };
-  const appendSide = (side: "B" | "H", header: string, content: string): boolean => {
-    if (!append(header)) return false;
-    const lines = content.split("\n");
-    for (let index = 0; index < lines.length; index += 1) {
-      if (!append(`${side}${index + 1}   ${lines[index] ?? ""}`)) return false;
-    }
-    return true;
-  };
-  if (includeBase) {
-    if (file.reviewBaseContent === undefined) return undefined;
-    if (!appendSide("B", "[BASE VERSION]", file.reviewBaseContent)) return undefined;
-  }
-  if (includeHead) {
-    if (file.reviewHeadContent === undefined) return undefined;
-    if (!appendSide("H", "[HEAD VERSION]", file.reviewHeadContent)) return undefined;
-  }
-  return sections.join("\n");
-};
-
-/** Whether complete patchless evidence fits the model-facing review bound. */
-export const hasReviewableContent = (file: ChangedFile): boolean =>
-  renderReviewContent(file) !== undefined;
-
-/** Whether the reviewer has either a real patch or bounded textual fallback evidence. */
-export const isReviewableFile = (file: ChangedFile): boolean =>
-  file.patch !== undefined || hasReviewableContent(file);
-
-/** One parsed line of a unified diff, with both coordinate systems. */
-export interface PatchLine {
-  readonly kind: "context" | "add" | "del";
-  readonly oldLine: number | undefined;
-  readonly newLine: number | undefined;
-  readonly text: string;
-}
-
-const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
-
-/**
- * Parse unified-diff hunk text into coordinate-tagged lines. Lines outside a
- * recognized hunk header are ignored rather than guessed at.
- */
-export const parsePatch = (patch: string): ReadonlyArray<PatchLine> => {
-  const lines: Array<PatchLine> = [];
-  let oldLine = 0;
-  let newLine = 0;
-  let inHunk = false;
-  for (const raw of patch.split("\n")) {
-    const header = HUNK_HEADER.exec(raw);
-    if (header !== null) {
-      oldLine = Number(header[1]);
-      newLine = Number(header[2]);
-      inHunk = true;
-      continue;
-    }
-    if (!inHunk) continue;
-    if (raw.startsWith("+")) {
-      lines.push({ kind: "add", oldLine: undefined, newLine, text: raw.slice(1) });
-      newLine += 1;
-    } else if (raw.startsWith("-")) {
-      lines.push({ kind: "del", oldLine, newLine: undefined, text: raw.slice(1) });
-      oldLine += 1;
-    } else if (raw.startsWith(" ") || raw === "") {
-      lines.push({ kind: "context", oldLine, newLine, text: raw.slice(1) });
-      oldLine += 1;
-      newLine += 1;
-    } else if (raw.startsWith("\\")) {
-      // "" — metadata, not a diff line.
-    } else {
-      // Unrecognized content ends the current hunk conservatively.
-      inHunk = false;
-    }
-  }
-  return lines;
-};
-
-/**
- * The new-file line numbers a GitHub review comment may anchor to on the
- * RIGHT side: every added or context line that appears in the diff.
- */
-export const commentableLines = (patch: string): ReadonlySet<number> => {
-  const lines = new Set<number>();
-  for (const line of parsePatch(patch)) {
-    if (line.newLine !== undefined) lines.add(line.newLine);
-  }
-  return lines;
-};
-
-/**
- * Render a patch with explicit RIGHT-side line numbers so the model can
- * anchor findings without arithmetic. `R<n>` marks a line that exists in the
- * new version of the file (`+` added, blank context); deleted lines keep a
- * bare `-` marker and no number.
- */
-export const annotatePatch = (patch: string): string => {
-  const output: Array<string> = [];
-  let oldLine = 0;
-  let newLine = 0;
-  let inHunk = false;
-  for (const raw of patch.split("\n")) {
-    const header = HUNK_HEADER.exec(raw);
-    if (header !== null) {
-      oldLine = Number(header[1]);
-      newLine = Number(header[2]);
-      inHunk = true;
-      output.push(raw);
-      continue;
-    }
-    if (!inHunk) continue;
-    if (raw.startsWith("+")) {
-      output.push(`R${newLine} + ${raw.slice(1)}`);
-      newLine += 1;
-    } else if (raw.startsWith("-")) {
-      output.push(`      - ${raw.slice(1)}`);
-      oldLine += 1;
-    } else if (raw.startsWith(" ") || raw === "") {
-      output.push(`R${newLine}   ${raw.slice(1)}`);
-      oldLine += 1;
-      newLine += 1;
-    } else if (raw.startsWith("\\")) {
-      output.push(`        ${raw}`);
-    } else {
-      inHunk = false;
-    }
-  }
-  return output.join("\n");
-};

package/src/internal/effort.ts

@@ -1,86 +0,0 @@
-import { Schema } from "effect";
-
-// ---------------------------------------------------------------------------
-// Reasoning effort, stored as a POSITION on [0, 1] rather than a rung name.
-// A rung name is only meaningful inside the provider that published it: the
-// same word can be one provider's floor and another's midpoint, and a stored
-// name silently changes meaning when the model under the setting changes. A
-// position has no such problem: 0 is whatever the provider calls its cheapest
-// offered rung and 1 its most expensive, and resolution is a lookup into that
-// provider's own ladder — the result is always a rung the provider offers.
-// ---------------------------------------------------------------------------
-
-/** A point on the effort axis: 0 = cheapest offered rung, 1 = most expensive. */
-export type EffortPosition = number;
-
-/**
- * Names accepted on user-facing surfaces (the action input, the CLI flag),
- * mapped to fixed points on the axis. These same names anchor every offered
- * rung during resolution, so a named input always lands on its same-named
- * rung when the provider offers it — `high` never resolves to `medium` just
- * because a ladder is short.
- */
-export const EFFORT_ALIASES = {
-  low: 0,
-  medium: 0.25,
-  high: 0.5,
-  xhigh: 0.75,
-  max: 1,
-} as const satisfies Readonly<Record<string, EffortPosition>>;
-
-/** A rung name every provider ladder must draw from. */
-export type EffortAliasName = keyof typeof EFFORT_ALIASES;
-
-const aliasPosition: Readonly<Record<string, EffortPosition | undefined>> = EFFORT_ALIASES;
-
-/** An effort input that is neither a known name nor a number on [0, 1]. */
-export class InvalidEffortInput extends Schema.TaggedError<InvalidEffortInput>()(
-  "InvalidEffortInput",
-  {
-    input: Schema.String,
-  },
-) {
-  override get message() {
-    return (
-      `Invalid effort '${this.input}': expected one of ` +
-      `${Object.keys(EFFORT_ALIASES).join(", ")} or a number between 0 and 1.`
-    );
-  }
-}
-
-export const isEffortPosition = (value: number): boolean =>
-  Number.isFinite(value) && value >= 0 && value <= 1;
-
-/**
- * Parse a user-supplied effort into a position: a name (`high`) or a bare
- * number (`0.75`). Returns undefined for anything else so the caller can fail
- * typed — a typo must stay visible, never silently become a level.
- */
-export const parseEffortPosition = (raw: string): EffortPosition | undefined => {
-  const normalized = raw.trim().toLowerCase();
-  const named = aliasPosition[normalized];
-  if (named !== undefined) return named;
-  if (normalized === "") return undefined;
-  const numeric = Number(normalized);
-  return isEffortPosition(numeric) ? numeric : undefined;
-};
-
-/**
- * Land a position on one provider's offered ladder: the highest offered rung
- * whose canonical alias position is at or below the requested position.
- * Anchoring on the alias positions (instead of scaling by ladder index) keeps
- * two properties at once: a named input lands on its same-named rung whenever
- * the provider offers it, and anything between rungs rounds DOWN so
- * resolution never costs more than was asked for.
- */
-export const resolveEffortRung = <const Rung extends EffortAliasName>(
-  position: EffortPosition,
-  rungs: readonly [Rung, ...ReadonlyArray<Rung>],
-): Rung => {
-  const clamped = Math.min(1, Math.max(0, position));
-  let selected = rungs[0];
-  for (const rung of rungs) {
-    if (EFFORT_ALIASES[rung] <= clamped) selected = rung;
-  }
-  return selected;
-};