@effect-agent/pr-review 0.1.0-beta.48 → 0.1.0-beta.50

package/README.md

@@ -1,112 +1,175 @@
 # @effect-agent/pr-review
 
-A small, provider-neutral review agent. Bounded model runs receive admitted patches as
-literal unified diffs, read immutable base or head source when needed, record established
-findings with `record_finding`, and return findings through a required native completion Tool.
-There is no voting, candidate cache, private hypothesis
-handoff, or repository code execution.
-
-The native Agent `inputPrompt` projects each complete patch once, with literal newlines. It keeps
-file headers, hunk ranges, additions, deletions, context, and mode or rename metadata. It does not
-duplicate context into separate old/new views or JSON-escape the source for the model. The canonical
-`ReviewRequest` and finding validation retain the original patches. This reduces repeated input
-overhead without excluding changes; it does not guarantee a complete review within a spending cap.
-
-The reviewer assesses every supplied patch first. Source reads resolve concrete questions about
-plausible defects, such as a missing caller, guard, contract, or limit. It reuses supplied evidence
-and finishes when those questions are resolved; straightforward changes can finish without source
-tools. Reads prioritize implementation and owned boundary schemas over test examples, including
-the definitions needed to resolve the question rather than only a nearby call site.
-Findings explain a supported trigger, concrete impact, and needed correction. Changes that
-expose an unchanged downstream failure remain eligible. Incremental findings must arise from the
-exact delta; unrelated old bugs and target-only changes stay out of scope, while explicit reverts
-remain reviewable.
-Changes to collection membership, cardinality, or representation warrant checking affected
-consumer limits with a supported boundary input, including transformations and aggregation.
-New or moved resource acquisition warrants checking an early-failure sequence and its cleanup.
-Owned untrusted-input and model-output Schema boundaries must safely handle every admitted value,
-including adversarial values at the field and collection bounds.
-Novelty compares base and head with the same supported operation input, including when a
-previously failing helper becomes newly reachable.
-
-The result contains model findings with host-validated paths and line anchors, exact duplicate
-removal, aggregate usage, and optional host-priced cost. Unknown changed paths fail closed and
-invalid inline anchors become top-level findings. Model output, usage, context, and retained response
-bytes remain bounded. Public finding paths, titles, and bodies retain their 512, 200, and
-2,000-character limits.
-
-Hosts may supply up to eight `ReviewFollowUp` values containing complete prior feedback, each
-bounded to 32,000 characters. The reviewer separately checks those blockers against current source
-and may return `ReviewOutcome.resolutions` with their exact IDs and fixing evidence. Omitted or
-uncertain resolutions leave prior feedback open. Unknown or duplicate resolution IDs fail
-verification. Incomplete, exhausted, pending-path, or excluded-path results return no resolutions.
-Follow-ups appear only in the final patch batch, sharing the existing execution and spending limits.
-They do not expand new-finding scope or declare a partial review safe to merge.
-GitHub history, credentials, selection, dismissal authorization, and publication belong to the host.
-
-Without host spending admission, the engine owns a cumulative 416,000-token stop policy and
-reserves 160,000 tokens for a final context and completion response. The model sees its current
-turn, tool, and token usage. Token, turn, or tool exhaustion permits one constrained completion
-through `submit_review`; it returns validated findings and accounted usage with
-`ReviewOutcome.exhausted` naming the limit. Hosts must
-treat that outcome as incomplete, even when it contains no findings. Measured usage can exceed a
-policy threshold before the engine observes it; this is not a provider-side spending cap.
-The usage ledger records research, compaction, and finalization without a second token limit that
-could abort delivery.
-
-An optional `costControl` reports the host's pre-request spending admission and provider usage.
-Supplying it replaces the cumulative token quota and completion reserve with that admission.
-Cached reads still contribute to usage diagnostics, but cannot force early token finalization.
-Cost-admitted runs allow up to 64 turns, matching the 64-tool-call allowance, while retaining
-the shared 5-minute and 128,000-token context bounds. Uncapped runs retain eight turns. A cost
-estimator alone does not disable the token quota. Capped hosts own model-visible spending feedback
-at their provider boundary; the generic turn/tool status is disabled for these runs. The Action
-counts its outgoing spending status before admission and keeps it outside the reusable cache prefix.
-With `costControl`, large requests run in sequential batches of at most 256,000 patch characters,
-preserving the host's file order and keeping each patch complete. One patch may use the full
-256,000-character batch capacity. Each batch has a fresh context
-and the same source service. All batches share the host ledger, turn and tool allowances, deadline,
-and 24-finding capacity. They stop on an incomplete result or exhaustion. `pendingPaths` identifies
-admitted patches never sent to a model, including a batch refused before paid inference. Hosts
-must disclose those paths as unreviewed. Without `costControl`, the reviewer retains one run and its
-cumulative token policy.
-When the host stops research for cost, the reviewer returns `exhausted: "cost"` and delivers
-recorded findings without requiring another paid call. Hosts must reserve the full possible charge
-before sending each request; the port itself does not enforce a cap. The
-[GitHub Action](../../action/README.md) supplies that implementation for its supported OpenAI models.
-`reservedCostMicrousd` reports the maximum additional charge for requests whose usage is still
-unknown, separately from the observed usage estimate.
-
-Recorded findings also survive a later expected execution or verification failure. Such a result
-has `incomplete: true`; hosts must not treat an empty or partial result as clearing the change.
-The model can also set `incomplete: true` in `submit_review` when it cannot finish assessing the
-supplied patches. That declaration preserves findings and becomes `ReviewOutcome.incomplete`
-even when no engine limit or provider failure occurred. Host-tracked `unreviewedPaths` remain
-disclosed separately and do not by themselves mark the admitted patches unfinished. An empty
-complete result is not proof that the repository is defect-free.
-With `costControl`, an accounted provider attempt also returns an incomplete outcome after an
-expected failure, even without findings, so hosts can publish its usage and outstanding charges.
-An engine context-limit failure or the host's
-`costControl.snapshot.inputLimitExceeded` returns an incomplete `exhausted: "tokens"` outcome,
-even before any paid attempt. Batches that never started remain in `pendingPaths`.
-Otherwise failures without recorded findings remain typed. Defects and interruption still
-propagate, and these records belong to the current run's Scope, not persistent storage.
-The report retains recorded findings before adding newly submitted findings, removes exact
-duplicates, and marks coverage incomplete if the combined report exceeds 24 findings.
+A provider-neutral agent that reviews an exact base-to-head change using a complete change
+index, paged diffs, and immutable source tools. One conversation follows related behavior across
+files. There are no separate patch batches, candidate pipeline, voting, or repository execution.
+
+## Evidence and findings
+
+The initial prompt includes every admitted path and its character range in one literal diff
+artifact. Changes up to 32,000 characters are included directly. Larger changes use `read_diff`:
+start at offset zero and follow `nextOffset`, or select a file's start offset from the index.
+Pages contain at most 32,000 UTF-16 characters and can cross file boundaries or split lines.
+Original unified patches, hunk coordinates, deletions, renames, and mode metadata remain intact.
+
+`read_file` reads up to 200 lines and 20,000 characters at the exact base or head.
+`find_files` searches filenames. `search_code` searches literal, case-sensitive source text to
+find definitions, callers, consumers, and tests, including unchanged code. Its path filter is a
+filename substring; cursor zero starts the search. Each page scans twenty authorized files,
+returns up to five matching lines per file, and provides `nextCursor` for more files.
+`truncated` identifies omitted matching lines and `unreadablePaths` identifies failed reads.
+A partial or failed search cannot establish that a caller is absent.
+
+The reviewer turns changed contracts into material, falsifiable questions and traces evidence
+for and against them across callers and consumers. Before recording a defect, it checks the
+strongest relevant guard, documented exception, or alternative interpretation and establishes
+why the supported trigger still causes concrete impact. It checks base/head causation, boundary
+values, cleanup, concurrency, and whether changed tests would detect the claimed failure.
+New features must satisfy their stated contracts, including validation, limits, isolation,
+and aggregation; a bypass can be a defect even when the old code also accepted that input.
+Unrelated old bugs, speculation, style, compiler diagnostics, and generic test requests are
+excluded. Incremental reviews limit new findings to their exact delta.
+
+The shared finding rubric, parent review procedure, and host-supplied repository policy are
+separate instructions. Policy findings identify the specific rule and applicable exceptions,
+citing instruction paths and lines when available. An explicitly reviewable architecture
+contract can warrant a finding without a runtime failure; its supplied severity takes precedence.
+
+`record_finding` is the only way to add findings to the report. The model is instructed to record
+each distinct root cause once and recover the saved ledger with `review_status` after `new_context`,
+without re-recording an issue with revised wording or severity. Counterevidence must be checked
+before recording because the ledger has no retraction or revision operation. `submit_review` is the
+required native completion tool and accepts only `blockedOn` and `resolutions` metadata.
+The host builds the final report directly from the ledger, so completion never rewrites or merges
+findings. Extra completion fields fail validation.
+
+The host validates changed paths and RIGHT-side line anchors, demotes invalid anchors to
+top-level findings, and removes only exact repeated records. Distinct defects at the same path
+and line remain separate. Up to 24 findings are retained, prioritizing blocking over important
+over minor findings. Overflow always marks the result incomplete, regardless of later completion.
+Finding paths, titles, and bodies retain their 512, 200, and 2,000-character bounds.
+
+## Coverage and limits
+
+Requests admit up to 1,000 distinct changed paths, 2,000,000 characters per patch, and 8,000,000
+patch characters overall. These are host input limits, separate from the model's working context.
+Source hosts can apply additional authorization and admission bounds.
+
+The host tracks diff ranges available to completed model requests. Merely issuing a read, repeating
+a page, skipping ahead, or failing a tool does not establish complete coverage. `pendingPaths`
+includes partially read files. `review_status` recovers saved findings and outstanding ranges;
+its optional cursor pages through the current pending list. While a range remains unread,
+`submit_review` returns a recoverable error with the next unread offset. The same run continues
+under its original budgets. A native budget stop preserves the pending paths and findings as
+incomplete; repeated completion refusals cannot restart the run or reset its allowance.
+Reading all ranges is necessary, but it does not prove that the model assessed every behavior.
+
+`review_status` also keeps a bounded investigation notebook for the lifetime of the review.
+Replace it with `notes: { text, expectedRevision }`; text is limited to 4,000 characters and
+stale revisions fail without overwriting newer notes. The response supplies the current text and
+revision. Notes preserve unresolved questions, exact evidence references, and next checks across
+rollover. They are model-authored context, never proof of coverage or a source of findings.
+Only the accepted-update count (`notesUpdates`) leaves the review; note text is not persisted in
+the outcome. Children cannot update the parent's notebook.
+
+Completion means a source-based assessment of the admitted changes and material supported
+hypotheses, not proof of correctness or an exhaustive audit of every dependency. The model can
+report `blockedOn` only for specific unavailable evidence, naming the affected behavior and its
+attempts to retrieve that evidence. It must still review the remaining patches. The bounded
+reason is retained in the outcome and summary, forces incompleteness, and prevents resolutions.
+Excluded artifacts, lack of live execution, and hypothetical uncertainty do not themselves
+block assessment of the admitted change.
+
+Every parent conversation has 128 model turns, 512 tool calls, four concurrent tools, and a five-minute deadline.
+The default `compaction: "rollover"` strategy uses a 48,000-token working context to bound
+context growth during large reviews. Hosts can select `compaction: "prune"`
+and an integer `contextTokenLimit` from 16,000 to 128,000. These settings do not widen host input
+admission or create new spending, turn, or tool allowances. Invalid options fail before model work.
+
+Native rollover starts a fresh window without a summarizer call. Its bounded recovery excerpt
+may omit unseen tool results, so undelivered diff pages remain unread and must be fetched again.
+Already delivered ranges and saved findings survive. Both strategies support calling `new_context`
+alone with a handoff; original instructions and the complete change index remain available.
+
+Every measured outcome includes `compactions`, an array of emitted native `CompactionPerformed`
+events containing only `kind`, `turn`, `tokensBeforeEstimate`, and `tokensAfterEstimate`.
+An empty array means no event was emitted; absence means the outcome supplied no measurement.
+The array is bounded to 512 entries and includes events retained before a typed failure. It does
+not expose source or handoff text, and events alone do not distinguish automatic from requested
+rollovers. Boundaries that fail before event emission are not counted.
+
+Without `costControl`, the engine applies a cumulative 416,000-token policy with a 160,000-token
+completion reserve. A host cost estimator alone does not disable it. With `costControl`, the
+host reserves the full possible charge before each provider call, replacing that token quota.
+The [GitHub Action](../../action/README.md) supplies spending admission for supported OpenAI models.
+Recorded findings survive a cost stop without requiring another paid call. `reservedCostMicrousd`
+reports maximum additional charges for sent requests whose usage remains unknown.
+
+Token, turn, tool, or cost exhaustion is incomplete. Expected failures preserve recorded findings
+and completed model attempts, including their accounting when no finding was recorded. Context/input-token
+refusals return an incomplete token-exhausted outcome before paid inference when possible.
+Failures before any model attempt, finding, or budget refusal remain typed. Defects and interruption propagate, and every
+resource belongs to the review's Scope. Excluded host `unreviewedPaths` remain separately disclosed.
+An empty result never proves that the repository is defect-free.
+
+## Optional research children
+
+The default reviewer runs alone. Experiments can provide `research: { model, concurrency: 2 }`
+to expose native `delegate_research`. Concurrency is either one or two (default two), with at
+most two children established per review. Each child has six ordinary model turns, twelve tool
+calls, a 60-second deadline, and a 32,000-token context using native pruning. The runtime can
+reserve a final completion response after structural exhaustion. The host configures the child
+model's output limit; the eval uses 4,000 tokens.
+
+A delegation supplies one unresolved, falsifiable question whose answer could change a finding,
+and one to three distinct admitted changed paths. Instructions ask neutrally for supporting or
+refuting evidence and discourage generic second reviews; children use the same finding rubric.
+The host selects their exact patches, rejecting more than 32,000 total patch characters.
+Children receive the immutable revisions and current saved findings, and can use only the
+three repository read tools, `record_finding`, and `finish_research`. The completion contains
+an evidence summary and incomplete flag; findings go directly to the same canonical ledger.
+Children cannot delegate further, establish parent diff coverage, or resolve prior reviews.
+
+Native reservations and child fibers belong to the review's Scope. Child compaction cannot
+change the parent's unread ranges. Child model requirements remain visible in the review's
+Effect requirements, and usage contributes to the existing accounting. A host supplying
+`costControl` must use the same admission service for both model layers, so all requests draw
+from one spending cap. Without host admission, the parent and child native token policies are
+separate; the parent token quota is not a combined spending cap.
+
+Research-enabled runs break equal-severity finding ties by their complete serialized values
+before retaining 24, so child completion order cannot select the survivors. Exact duplicates
+are still the only records removed. A rejected delegation, failed or interrupted child,
+unfinished join, child-reported incomplete result, or child budget exhaustion makes the parent
+incomplete and suppresses resolutions. Defects and external interruption still propagate.
+
+Measured outcomes include `research` counters: `delegations` counts declared delegation calls;
+`started`, `completed`, `failed`, and `interrupted` count emitted native child events; `incomplete`
+counts completed child results that report incomplete or exhausted work. Zero counts are measured
+zero, while an absent field means no measurement was supplied. Counts contain no child source,
+summary, or transcript; prestart refusals have a declaration but no child event.
+
+## Follow-ups and hosting
+
+Hosts can supply up to eight prior `ReviewFollowUp` values, each up to 32,000 characters. The
+reviewer verifies every blocker in a follow-up against current source before returning its exact
+ID and fixing evidence. Unknown or duplicate resolution IDs fail verification. Incomplete,
+exhausted, pending-path, or excluded-path results return no resolutions. History selection,
+credentials, dismissal authorization, and publication belong to the host.
 
 ```ts
-const reviewer = makeReviewer({ model, guidance, estimateCostMicrousd, costControl });
+const reviewer = makeReviewer({ model, guidance, costControl });
 const program = reviewer.review(request).pipe(Effect.provideService(ReviewRepository, repository));
 ```
 
-`repository.readFile` and `repository.findFiles` return typed Effects. Hosts must
-authorize the source sent to their model, enforce immutable revisions and read
-bounds, and treat source content as untrusted data. The reviewer exposes this
-dependency in its Effect requirements; it has no ambient filesystem or network
-access and does not cache review answers.
-
-`ReviewSource.fromText(request, text)` applies the shared line and character
-bounds after the host authorizes and reads a file.
+`ReviewRepository` implementations provide typed Effect operations for `readFile`, `findFiles`,
+and `searchCode`. Hosts authorize source sent to models, pin immutable revisions, enforce read
+bounds, and treat all source and model output as untrusted. The reviewer has no ambient filesystem
+or network access. `ReviewSource.fromText` applies the shared source-range bounds.
 
-Portions of the review instructions are adapted from
-[PR-Agent](https://github.com/The-PR-Agent/pr-agent). See `NOTICE` for its MIT license attribution.
+The navigable diff approach is informed by [Pullfrog's review workflow](https://github.com/pullfrog/pullfrog/blob/0212dedb0f92b8ba4020c17dc30d3eced32415d7/modes.ts)
+and [Codex's review task](https://github.com/openai/codex/blob/588b781ab4924ce7352488394028e63d74cf807f/codex-rs/core/src/tasks/review.rs).
+These designs do not establish accuracy. The [eval bench](../../examples/pr-review-eval/README.md)
+measures first-trial detection, false positives, and incomplete runs against adjudicated cases.
+Portions of the original review instructions were adapted from
+[PR-Agent](https://github.com/The-PR-Agent/pr-agent); see `NOTICE` for its MIT attribution.

package/dist/Review.d.mts

@@ -1,16 +1,42 @@
-import { a as ReviewSource, i as ReviewRepository, n as ReviewContextError, r as ReviewFileList } from "./ReviewRepository-Bx4ikyhF.mjs";
-import { Effect, Schema } from "effect";
+import { i as ReviewRepository, n as ReviewContextError, o as ReviewSearchResult, r as ReviewFileList, s as ReviewSource } from "./ReviewRepository-Wd_4qCaO.mjs";
+import { Effect, Layer, Schema } from "effect";
 import * as Agent from "effect-agent/Agent";
 import * as AgentRuntime from "effect-agent/AgentRuntime";
+import { ContextCompactor } from "effect-agent/ContextCompactor";
 import { IdGenerator } from "effect-agent/IdGenerator";
 import { RunCostEstimator } from "effect-agent/RunOptions";
 import { ThreadHistory } from "effect-agent/ThreadHistory";
 import { LanguageModel, Model, Tool } from "effect/unstable/ai";
 declare namespace Review_d_exports {
-  export { MAX_REVIEW_PATCH_CHARS, ReviewCategory, ReviewChange, ReviewCostControl, ReviewCostSnapshot, ReviewFinding, ReviewFollowUp, ReviewOutcome, ReviewReport, ReviewRequest, ReviewResolution, ReviewSeverity, ReviewUsage, ReviewVerificationError, ReviewerOptions, isCommentableLine, makeReviewer };
+  export { MAX_REVIEW_FILES, MAX_REVIEW_PATCH_CHARS, MAX_REVIEW_TOTAL_PATCH_CHARS, ReviewCategory, ReviewChange, ReviewCompaction, ReviewCompactionEvent, ReviewContextTokenLimit, ReviewCostControl, ReviewCostSnapshot, ReviewFinding, ReviewFollowUp, ReviewOutcome, ReviewReport, ReviewRequest, ReviewResearchConcurrency, ReviewResearchStats, ReviewResolution, ReviewSeverity, ReviewUsage, ReviewVerificationError, ReviewerOptions, isCommentableLine, makeReviewer };
 }
-/** Maximum patch text per batch; one complete file may occupy the entire batch. */
-declare const MAX_REVIEW_PATCH_CHARS = 256000;
+/** Host admission bounds, independent of the model's working context. */
+declare const MAX_REVIEW_FILES = 1000;
+declare const MAX_REVIEW_PATCH_CHARS = 2000000;
+declare const MAX_REVIEW_TOTAL_PATCH_CHARS = 8000000;
+/** Native strategies share the same review ledger and execution budgets. */
+declare const ReviewCompaction: Schema.Literals<readonly ["prune", "rollover"]>;
+type ReviewCompaction = typeof ReviewCompaction.Type;
+/** Working-context bound for pressure experiments; it never widens host input admission. */
+declare const ReviewContextTokenLimit: Schema.Int;
+/** Emitted native compaction evidence, without source, summaries, or handoff text. */
+declare const ReviewCompactionEvent: Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["clear-tool-results", "summarize", "rollover"]>;
+  readonly turn: Schema.Int;
+  readonly tokensBeforeEstimate: Schema.Natural;
+  readonly tokensAfterEstimate: Schema.Natural;
+}>;
+type ReviewCompactionEvent = typeof ReviewCompactionEvent.Type;
+declare const ReviewResearchConcurrency: Schema.Literals<readonly [1, 2]>;
+/** Measured native delegation events and incomplete child results; contains no child prose. */
+declare const ReviewResearchStats: Schema.Struct<{
+  readonly delegations: Schema.Natural;
+  readonly started: Schema.Natural;
+  readonly completed: Schema.Natural;
+  readonly failed: Schema.Natural;
+  readonly interrupted: Schema.Natural;
+  readonly incomplete: Schema.Natural;
+}>;
 declare const ReviewChange_base: Schema.Class<ReviewChange, Schema.Struct<{
   readonly path: Schema.NonEmptyString;
   readonly patch: Schema.NonEmptyString;
@@ -103,14 +129,33 @@ declare const ReviewOutcome_base: Schema.Class<ReviewOutcome, Schema.Struct<{
   readonly report: typeof ReviewReport;
   readonly turns: Schema.Natural;
   readonly usage: typeof ReviewUsage;
-  /** Admitted patches in batches that never started. These are not reviewed files. */
+  /** Admitted paths with diff ranges never supplied to the model, including partially read files. */
   readonly pendingPaths: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
   /** A constrained final answer preserves findings but cannot establish complete coverage. */
   readonly exhausted: Schema.optionalKey<Schema.Literals<readonly ["tokens", "tool-calls", "turns", "cost"]>>;
   /** Unfinished coverage, reported by the model or caused by failure or the report capacity bound. */
   readonly incomplete: Schema.optionalKey<Schema.Literal<true>>;
+  /** Specific missing evidence reported after all admitted diff ranges were delivered. */
+  readonly blockedOn: Schema.optionalKey<Schema.NonEmptyString>;
   /** Only returned after complete coverage, with identifiers drawn from the supplied follow-ups. */
   readonly resolutions: Schema.optionalKey<Schema.$Array<typeof ReviewResolution>>;
+  /** Present for measured runs, including an empty array when no native event was emitted. */
+  readonly compactions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["clear-tool-results", "summarize", "rollover"]>;
+    readonly turn: Schema.Int;
+    readonly tokensBeforeEstimate: Schema.Natural;
+    readonly tokensAfterEstimate: Schema.Natural;
+  }>>>;
+  readonly research: Schema.optionalKey<Schema.Struct<{
+    readonly delegations: Schema.Natural;
+    readonly started: Schema.Natural;
+    readonly completed: Schema.Natural;
+    readonly failed: Schema.Natural;
+    readonly interrupted: Schema.Natural;
+    readonly incomplete: Schema.Natural;
+  }>>;
+  /** Accepted working-note replacements; the note text stays inside the review's Scope. */
+  readonly notesUpdates: Schema.optionalKey<Schema.Natural>;
 }>, {}>;
 declare class ReviewOutcome extends ReviewOutcome_base {}
 declare const ReviewVerificationError_base: Schema.Class<ReviewVerificationError, Schema.TaggedStruct<"ReviewVerificationError", {
@@ -123,10 +168,16 @@ interface ReviewerOptions<Provider, ModelProvides, ModelRequires> {
   readonly guidance?: string | undefined;
   readonly estimateCostMicrousd?: RunCostEstimator | undefined;
   readonly costControl?: ReviewCostControl | undefined;
+  readonly compaction?: ReviewCompaction | undefined;
+  readonly contextTokenLimit?: number | undefined;
+  readonly research?: {
+    readonly model: Model.Model<Provider, LanguageModel.LanguageModel | ModelProvides, ModelRequires>;
+    readonly concurrency?: typeof ReviewResearchConcurrency.Type | undefined;
+  } | undefined;
 }
-/** A bounded review, with sequential patch batches when a shared spending ledger is supplied. */
+/** One navigable review with a complete change index and bounded evidence tools. */
 declare const makeReviewer: <Provider, ModelProvides, ModelRequires>(options: ReviewerOptions<Provider, ModelProvides, ModelRequires>) => {
-  readonly review: (request: ReviewRequest) => Effect.Effect<ReviewOutcome, import("@effect-agent/core/AgentError").AgentApprovalDenied | import("@effect-agent/core/AgentError").AgentApprovalPending | AgentRuntime.AgentChildPending | import("@effect-agent/core/AgentError").AgentInputError | import("@effect-agent/core/AgentError").AgentOutputError | import("@effect-agent/core/AgentError").AgentPolicyError | import("@effect-agent/core/AgentError").AgentToolAuthorizationDenied | import("effect/unstable/ai/AiError").AiError | import("effect-agent/RunHooks").BudgetAdapterError | import("effect-agent/Budget").BudgetExceeded | import("@effect-agent/engine/ContextCompactor").CompactionError | import("@effect-agent/core/AgentError").ContextBudgetError | import("@effect-agent/core/AgentError").ContextOverflowError | import("@effect-agent/core/MemoryReference").MemoryRecallError | import("@effect-agent/core/AgentError").ModelProtocolError | ReviewVerificationError | import("effect-agent/ThreadHistory").ThreadHistoryError, ReviewRepository | Exclude<Exclude<Exclude<Exclude<(Agent.ModelServices extends ModelProvides | LanguageModel.LanguageModel | Model.ModelName | Model.ProviderName ? Model.Model<Provider, ModelProvides | LanguageModel.LanguageModel, ModelRequires> : never) extends (infer T) ? T extends (Agent.ModelServices extends ModelProvides | LanguageModel.LanguageModel | Model.ModelName | Model.ProviderName ? Model.Model<Provider, ModelProvides | LanguageModel.LanguageModel, ModelRequires> : never) ? T extends import("effect/Layer").Layer<infer _Provides, infer _Error, infer Services> ? Services : never : never : never, AgentRuntime.EngineProvidedToolServices>, Tool.Handler<"record_finding">>, Tool.Handler<"submit_review"> | IdGenerator | import("effect-agent/RunOptions").RunContextPreparation | ThreadHistory | Tool.HandlersFor<{
+  readonly review: (request: ReviewRequest) => Effect.Effect<ReviewOutcome, import("@effect-agent/core/AgentError").AgentApprovalDenied | import("@effect-agent/core/AgentError").AgentApprovalPending | AgentRuntime.AgentChildPending | import("@effect-agent/core/AgentError").AgentInputError | import("@effect-agent/core/AgentError").AgentOutputError | import("@effect-agent/core/AgentError").AgentPolicyError | import("@effect-agent/core/AgentError").AgentToolAuthorizationDenied | import("effect/unstable/ai/AiError").AiError | import("effect-agent/RunHooks").BudgetAdapterError | import("effect-agent/Budget").BudgetExceeded | import("effect-agent/ContextCompactor").CompactionError | import("@effect-agent/core/AgentError").ContextBudgetError | import("@effect-agent/core/AgentError").ContextOverflowError | import("@effect-agent/core/MemoryReference").MemoryRecallError | import("@effect-agent/core/AgentError").ModelProtocolError | ReviewVerificationError | AgentRuntime.SubagentDurabilityError | import("effect-agent/ThreadHistory").ThreadHistoryError | AgentRuntime.ToolCallWaiting, ReviewRepository | Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<ModelRequires, AgentRuntime.EngineProvidedToolServices>, import("effect-agent/RunOptions").RunContextPreparation | ThreadHistory>, ContextCompactor | Tool.Handler<"finish_research"> | Tool.Handler<"record_finding"> | import("effect-agent/SubagentReservations").SubagentReservations>, ContextCompactor>, ContextCompactor | IdGenerator | import("effect-agent/RunOptions").RunContextPreparation | ThreadHistory | Tool.HandlersFor<{
     readonly find_files: Tool.Tool<"find_files", {
       readonly parameters: Schema.Struct<{
         readonly query: Schema.String;
@@ -147,8 +198,98 @@ declare const makeReviewer: <Provider, ModelProvides, ModelRequires>(options: Re
       readonly failure: typeof ReviewContextError;
       readonly failureMode: "return";
     }, never>;
+    readonly search_code: Tool.Tool<"search_code", {
+      readonly parameters: Schema.Struct<{
+        readonly query: Schema.NonEmptyString;
+        readonly path: Schema.String;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+        readonly cursor: Schema.Natural;
+      }>;
+      readonly success: typeof ReviewSearchResult;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+  }>>, import("effect/Scope").Scope> | Exclude<Exclude<Exclude<Exclude<Exclude<(Agent.ModelServices extends ModelProvides | LanguageModel.LanguageModel | Model.ModelName | Model.ProviderName ? Model.Model<Provider, ModelProvides | LanguageModel.LanguageModel, ModelRequires> : never) extends (infer T_1) ? T_1 extends (Agent.ModelServices extends ModelProvides | LanguageModel.LanguageModel | Model.ModelName | Model.ProviderName ? Model.Model<Provider, ModelProvides | LanguageModel.LanguageModel, ModelRequires> : never) ? T_1 extends Layer.Layer<infer _Provides, infer _Error, infer Services> ? Services : never : never : never, AgentRuntime.EngineProvidedToolServices>, Tool.Handler<"delegate_research"> | Tool.Handler<"record_finding"> | Tool.Handler<"submit_review"> | Tool.HandlersFor<{
+    readonly new_context: Tool.Tool<"new_context", {
+      readonly parameters: Schema.Struct<{
+        readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+      }>;
+      readonly failure: Schema.Never;
+      readonly failureMode: "error";
+    }, never>;
+    readonly read_diff: Tool.Tool<"read_diff", {
+      readonly parameters: Schema.Struct<{
+        readonly offset: Schema.Natural;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly offset: Schema.Natural;
+        readonly content: Schema.String;
+        readonly nextOffset: Schema.NullOr<Schema.Natural>;
+        readonly totalChars: Schema.Natural;
+      }>;
+      readonly failure: typeof ReviewVerificationError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly review_status: Tool.Tool<"review_status", {
+      readonly parameters: Schema.Struct<{
+        readonly cursor: Schema.optionalKey<Schema.Natural>;
+        readonly notes: Schema.optionalKey<Schema.Struct<{
+          readonly text: Schema.String;
+          readonly expectedRevision: Schema.Natural;
+        }>>;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly pending: Schema.$Array<Schema.Struct<{
+          readonly path: Schema.NonEmptyString;
+          readonly offset: Schema.Natural;
+        }>>;
+        readonly pendingCount: Schema.Natural;
+        readonly findings: Schema.$Array<typeof ReviewFinding>;
+        readonly notes: Schema.Struct<{
+          readonly text: Schema.String;
+          readonly revision: Schema.Natural;
+        }>;
+      }>;
+      readonly failure: typeof ReviewVerificationError;
+      readonly failureMode: "return";
+    }, never>;
+  }>>, ContextCompactor>, ContextCompactor | IdGenerator | import("effect-agent/RunOptions").RunContextPreparation | ThreadHistory | Tool.HandlersFor<{
+    readonly find_files: Tool.Tool<"find_files", {
+      readonly parameters: Schema.Struct<{
+        readonly query: Schema.String;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+      }>;
+      readonly success: typeof ReviewFileList;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly read_file: Tool.Tool<"read_file", {
+      readonly parameters: Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+        readonly startLine: Schema.Int;
+        readonly lineCount: Schema.Int;
+      }>;
+      readonly success: typeof ReviewSource;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
+    readonly search_code: Tool.Tool<"search_code", {
+      readonly parameters: Schema.Struct<{
+        readonly query: Schema.NonEmptyString;
+        readonly path: Schema.String;
+        readonly revision: Schema.Literals<readonly ["base", "head"]>;
+        readonly cursor: Schema.Natural;
+      }>;
+      readonly success: typeof ReviewSearchResult;
+      readonly failure: typeof ReviewContextError;
+      readonly failureMode: "return";
+    }, never>;
   }>>, import("effect/Scope").Scope>>;
 };
 //#endregion
-export { MAX_REVIEW_PATCH_CHARS, ReviewCategory, ReviewChange, ReviewCostControl, ReviewCostSnapshot, ReviewFinding, ReviewFollowUp, ReviewOutcome, ReviewReport, ReviewRequest, ReviewResolution, ReviewSeverity, ReviewUsage, ReviewVerificationError, ReviewerOptions, isCommentableLine, makeReviewer, Review_d_exports as t };
+export { MAX_REVIEW_FILES, MAX_REVIEW_PATCH_CHARS, MAX_REVIEW_TOTAL_PATCH_CHARS, ReviewCategory, ReviewChange, ReviewCompaction, ReviewCompactionEvent, ReviewContextTokenLimit, ReviewCostControl, ReviewCostSnapshot, ReviewFinding, ReviewFollowUp, ReviewOutcome, ReviewReport, ReviewRequest, ReviewResearchConcurrency, ReviewResearchStats, ReviewResolution, ReviewSeverity, ReviewUsage, ReviewVerificationError, ReviewerOptions, isCommentableLine, makeReviewer, Review_d_exports as t };
 //# sourceMappingURL=Review.d.mts.map