@effect-agent/pr-review 0.1.0-beta.8 → 0.1.0-beta.80

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;
-};

package/src/internal/factory.ts

@@ -1,374 +0,0 @@
-import { Effect, Layer } from "effect";
-import {
-  Agent,
-  AgentPolicy,
-  getToolExecutionClass,
-  IdGenerator,
-  SubagentReservationsMemoryLive,
-  type AgentPolicyInput,
-  type UsageBudgetLimits,
-} from "effect-agent";
-import { Toolkit, type LanguageModel, type Model, type Tool } from "effect/unstable/ai";
-
-import {
-  fanOutHandlersLayerFor,
-  FanOutCoordinatorToolkitLayer,
-  FileReviewToolkitLayer,
-  makeFanOutReviewSuite,
-} from "./fan-out.ts";
-import { computeChangesetFingerprint } from "./fingerprint.ts";
-import { compileIgnoreGlobs, ignoringPullRequestSourceLayer } from "./ignore.ts";
-import {
-  clampMaxFindings,
-  CodeReview,
-  defaultReviewPolicy,
-  ListChangedFiles,
-  makeReviewInstructions,
-  ReadFile,
-  ReadFileDiff,
-  ReviewMission,
-  ReviewToolkitLayer,
-  resolveGuidance as resolveReviewGuidance,
-  type ReviewGuidance,
-} from "./review-agent.ts";
-import { buildProfileMission, computeProfileFingerprint } from "./review-state.ts";
-import {
-  buildReviewMission,
-  executeReview,
-  fanOutReviewBudgetLimits,
-  reviewBudgetLimits,
-} from "./run.ts";
-import { PullRequestSource } from "./source.ts";
-
-// ---------------------------------------------------------------------------
-// The configuration factory: one call turns a Model and optional adaptation
-// knobs into a bound, runnable reviewer. Every knob widens what goes INTO the
-// review — guidance, extra read-only tools, execution bounds, ignore globs —
-// and none weakens what leaves it: anchor validation, the findings bound, and
-// publication-after-settlement are applied by the run path unconditionally.
-// ---------------------------------------------------------------------------
-
-/** Options shared by both reviewer shapes. */
-export interface PrReviewSharedOptions {
-  /**
-   * Host-side and instruction-level findings bound, clamped to the CodeReview
-   * schema cap of 20.
-   */
-  readonly maxFindings?: number | undefined;
-  /**
-   * Glob patterns (`**` crosses directories, `*`/`?` stay in one segment)
-   * removed from the reviewer's observation surface entirely.
-   */
-  readonly ignore?: ReadonlyArray<string> | undefined;
-  /** Map the model's verdict onto APPROVE/REQUEST_CHANGES instead of COMMENT. */
-  readonly applyVerdict?: boolean | undefined;
-  /** Run-level usage bounds; defaults to the shape's packaged limits. */
-  readonly budget?: UsageBudgetLimits | undefined;
-  /**
-   * Human-readable descriptor of the bound model (provider, model id, effort)
-   * rendered into the review footer and included in the fingerprint
-   * signature, so changing the binding re-reviews instead of skipping.
-   */
-  readonly modelLabel?: string | undefined;
-}
-
-/** Options accepted by `PrReview.make` (the flat reviewer). */
-export interface PrReviewOptions<
-  Provider,
-  ModelProvides,
-  ModelRequires,
-  Extra extends ReadonlyArray<Tool.Any>,
-> extends PrReviewSharedOptions {
-  /** The Effect AI Model to bind; its Layer requirements stay visible in `R`. */
-  readonly model: Model.Model<Provider, LanguageModel.LanguageModel | ModelProvides, ModelRequires>;
-  /** Domain guidance injected between the mission framing and the procedure. */
-  readonly guidance?: ReviewGuidance | undefined;
-  /** Full override of the flat reviewer's execution bounds. */
-  readonly policy?: AgentPolicyInput | undefined;
-  /**
-   * Additional tools merged into the reviewer's toolkit. Every extra tool
-   * must be annotated `ToolExecutionClass: "readonly"` — construction fails
-   * otherwise — and its handler Layer is the caller's to provide, so the new
-   * dependency stays visible in the run's `R`.
-   */
-  readonly extraTools?: Extra | undefined;
-}
-
-/** How one run should publish. */
-export interface RunReviewOptions {
-  /** Post the review to GitHub; `false` (default) stops after planning. */
-  readonly post?: boolean | undefined;
-  /** Workflow-run URL rendered into the review footer. */
-  readonly runUrl?: string | undefined;
-}
-
-const EMPTY_TOOLS: ReadonlyArray<Tool.Any> = [];
-
-const requireReadonly = (tools: ReadonlyArray<Tool.Any>): void => {
-  for (const tool of tools) {
-    const executionClass = getToolExecutionClass(tool);
-    if (executionClass !== "readonly") {
-      throw new Error(
-        `PrReview.make: extra tool '${tool.name}' declares execution class '${executionClass}'. ` +
-          `The packaged reviewer's tool surface is read-only; annotate the tool with ` +
-          `ToolExecutionClass "readonly" or run it outside the reviewer.`,
-      );
-    }
-  }
-};
-
-const provideIgnore = <A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-  ignore: ReadonlyArray<string> | undefined,
-) =>
-  ignore !== undefined && ignore.length > 0
-    ? effect.pipe(Effect.provide(ignoringPullRequestSourceLayer(ignore)))
-    : effect;
-
-/**
- * The changeset fingerprint of what this reviewer WOULD review right now:
- * the ignore-filtered changeset hashed with the prompt signature. Identical
- * fingerprints mean an identical review input surface — the basis for
- * skipping re-reviews after content-free head changes (base auto-merges,
- * equivalent rebases).
- */
-const makeFingerprint = (
-  signature: (mission: ReturnType<typeof buildReviewMission>) => string,
-  ignore: ReadonlyArray<string> | undefined,
-) =>
-  provideIgnore(
-    Effect.gen(function* () {
-      const source = yield* PullRequestSource;
-      const metadata = yield* source.metadata;
-      const files = yield* source.changedFiles;
-      return yield* computeChangesetFingerprint(
-        files,
-        signature(buildReviewMission(metadata, files)),
-      );
-    }),
-    ignore,
-  );
-
-const makeProfileFingerprint = (
-  signature: (mission: ReviewMission) => string,
-  ignore: ReadonlyArray<string> | undefined,
-) =>
-  provideIgnore(
-    Effect.gen(function* () {
-      const source = yield* PullRequestSource;
-      const metadata = yield* source.metadata;
-      const files = yield* source.anchorFiles;
-      return yield* computeProfileFingerprint(signature(buildProfileMission(metadata, files)));
-    }),
-    ignore,
-  );
-
-const makeReviewSnapshot = (ignore: ReadonlyArray<string> | undefined) =>
-  provideIgnore(
-    Effect.gen(function* () {
-      const source = yield* PullRequestSource;
-      return {
-        metadata: yield* source.metadata,
-        files: yield* source.anchorFiles,
-      };
-    }),
-    ignore,
-  );
-
-/**
- * Build the flat reviewer: one bounded read-only agent over the whole
- * changeset. Returns the model-agnostic definition, the explicit binding, and
- * a `run` whose error and requirement channels stay fully inferred — the
- * pull-request source, the publisher, extra tool handlers, and the Model
- * Layer's requirements all remain visible to the caller.
- */
-const make = <
-  Provider,
-  ModelProvides,
-  ModelRequires,
-  const Extra extends ReadonlyArray<Tool.Any> = readonly [],
->(
-  options: PrReviewOptions<Provider, ModelProvides, ModelRequires, Extra>,
-) => {
-  // Safe when `extraTools` is omitted: the generic default fixes Extra to the
-  // empty tuple, which is exactly what the fallback value is.
-  const extraTools = options.extraTools ?? (EMPTY_TOOLS as Extra);
-  requireReadonly(extraTools);
-
-  const definition = Agent.define("pr-reviewer", {
-    input: ReviewMission,
-    output: CodeReview,
-    instructions: makeReviewInstructions({
-      guidance: options.guidance,
-      maxFindings: options.maxFindings,
-    }),
-    toolkit: Toolkit.make(ListChangedFiles, ReadFileDiff, ReadFile, ...extraTools),
-    policy: options.policy === undefined ? defaultReviewPolicy : AgentPolicy.make(options.policy),
-    description:
-      "Review one pull request read-only: list the changeset, read annotated diffs and head-file context, and return a structured, line-anchored code review.",
-    metadata: { deploymentClass: "E", surface: "read-only" },
-  });
-  // `Agent.withModel` types the model through a conditional that stays
-  // deferred inside this generic body, so the binding is built structurally —
-  // the identical frozen `{ definition, model }` pair the runtime accepts.
-  const binding = Object.freeze({ definition, model: options.model });
-
-  // Everything that shapes this reviewer's output: the rendered instructions
-  // (mission, guidance, findings bound, contract) plus the verdict mapping.
-  const signature = (mission: ReviewMission): string =>
-    [
-      definition.instructions(mission),
-      `applyVerdict=${String(options.applyVerdict ?? false)}`,
-      ...(options.modelLabel === undefined ? [] : [`model=${options.modelLabel}`]),
-    ].join("\u0000");
-  const profileSignature = (mission: ReviewMission): string =>
-    [
-      "pr-review-profile-v1-flat",
-      JSON.stringify(resolveReviewGuidance(options.guidance, mission)),
-      JSON.stringify(options.policy ?? {}),
-      JSON.stringify(extraTools.map((tool) => tool.name)),
-      JSON.stringify(options.ignore ?? []),
-      `maxFindings=${clampMaxFindings(options.maxFindings)}`,
-      `applyVerdict=${String(options.applyVerdict ?? false)}`,
-      ...(options.modelLabel === undefined ? [] : [`model=${options.modelLabel}`]),
-    ].join("\u0000");
-
-  const run = (runOptions: RunReviewOptions = {}) =>
-    provideIgnore(
-      executeReview(binding, {
-        post: runOptions.post ?? false,
-        applyVerdict: options.applyVerdict ?? false,
-        limits: options.budget ?? reviewBudgetLimits,
-        maxFindings: clampMaxFindings(options.maxFindings),
-        signature,
-        modelLabel: options.modelLabel,
-        runUrl: runOptions.runUrl,
-        usageScope: "run",
-        reviewShape: "flat",
-      }).pipe(Effect.provide(Layer.mergeAll(ReviewToolkitLayer, IdGenerator.layer)), Effect.scoped),
-      options.ignore,
-    );
-
-  return {
-    definition,
-    binding,
-    run,
-    fingerprint: makeFingerprint(signature, options.ignore),
-    profileFingerprint: makeProfileFingerprint(profileSignature, options.ignore),
-    snapshot: makeReviewSnapshot(options.ignore),
-    filterFiles: (files: ReadonlyArray<import("./diff.ts").ChangedFile>) => {
-      const ignored = compileIgnoreGlobs(options.ignore ?? []);
-      return files.filter((file) => !ignored(file.path));
-    },
-  } as const;
-};
-
-/** Options accepted by `PrReview.makeFanOut` (the delegating reviewer). */
-export interface PrReviewFanOutOptions<
-  Provider,
-  ModelProvides,
-  ModelRequires,
-> extends PrReviewSharedOptions {
-  /** The Effect AI Model bound to both the coordinator and its children. */
-  readonly model: Model.Model<Provider, LanguageModel.LanguageModel | ModelProvides, ModelRequires>;
-  /**
-   * Static guidance injected into every child reviewer's instructions. The
-   * coordinator's mission never crosses the delegation boundary, so
-   * mission-dependent guidance cannot exist for children.
-   */
-  readonly guidance?: string | ReadonlyArray<string> | undefined;
-}
-
-/**
- * Build the fan-out reviewer: a coordinator that delegates bounded per-unit
- * file reviews to attached ephemeral children and merges their findings under
- * the same output contract and the same fail-closed publication path as the
- * flat reviewer. Child and coordinator execution bounds are packaged and not
- * configurable here — the delegation reservation mirrors the child policy,
- * and letting the two drift apart is a published-API hazard.
- */
-const makeFanOut = <Provider, ModelProvides, ModelRequires>(
-  options: PrReviewFanOutOptions<Provider, ModelProvides, ModelRequires>,
-) => {
-  const suite = makeFanOutReviewSuite({
-    guidance: options.guidance,
-    maxFindings: options.maxFindings,
-  });
-  // Structural bindings for the same reason as in `make` above.
-  const binding = Object.freeze({ definition: suite.parent, model: options.model });
-  const childBinding = Object.freeze({ definition: suite.child, model: options.model });
-
-  // The coordinator's rendered instructions (mission, guidance, findings
-  // bound, contract) plus the review-shaping options they do not carry: the
-  // child guidance, the host knobs, and the model binding descriptor.
-  const guidanceLines =
-    options.guidance === undefined
-      ? []
-      : typeof options.guidance === "string"
-        ? [options.guidance]
-        : options.guidance;
-  const signature = (mission: ReviewMission): string =>
-    [
-      suite.parent.instructions(mission),
-      `childGuidance=${JSON.stringify(guidanceLines)}`,
-      `applyVerdict=${String(options.applyVerdict ?? false)}`,
-      ...(options.modelLabel === undefined ? [] : [`model=${options.modelLabel}`]),
-    ].join(" ");
-  const profileSignature = (_mission: ReviewMission): string =>
-    [
-      "pr-review-profile-v1-fan-out",
-      JSON.stringify(guidanceLines),
-      JSON.stringify(options.ignore ?? []),
-      `maxFindings=${clampMaxFindings(options.maxFindings)}`,
-      `applyVerdict=${String(options.applyVerdict ?? false)}`,
-      ...(options.modelLabel === undefined ? [] : [`model=${options.modelLabel}`]),
-    ].join("\u0000");
-  const delegationLayer = fanOutHandlersLayerFor(suite.delegation)(childBinding).pipe(
-    Layer.provide(
-      Layer.mergeAll(FileReviewToolkitLayer, SubagentReservationsMemoryLive, IdGenerator.layer),
-    ),
-  );
-
-  const run = (runOptions: RunReviewOptions = {}) =>
-    provideIgnore(
-      executeReview(binding, {
-        post: runOptions.post ?? false,
-        applyVerdict: options.applyVerdict ?? false,
-        limits: options.budget ?? fanOutReviewBudgetLimits,
-        maxFindings: clampMaxFindings(options.maxFindings),
-        signature,
-        modelLabel: options.modelLabel,
-        runUrl: runOptions.runUrl,
-        usageScope: "coordinator",
-        reviewShape: "fan-out",
-      }).pipe(
-        Effect.provide(
-          Layer.mergeAll(FanOutCoordinatorToolkitLayer, delegationLayer, IdGenerator.layer),
-        ),
-        Effect.scoped,
-      ),
-      options.ignore,
-    );
-
-  return {
-    definition: suite.parent,
-    binding,
-    childBinding,
-    run,
-    fingerprint: makeFingerprint(signature, options.ignore),
-    profileFingerprint: makeProfileFingerprint(profileSignature, options.ignore),
-    snapshot: makeReviewSnapshot(options.ignore),
-    filterFiles: (files: ReadonlyArray<import("./diff.ts").ChangedFile>) => {
-      const ignored = compileIgnoreGlobs(options.ignore ?? []);
-      return files.filter((file) => !ignored(file.path));
-    },
-  } as const;
-};
-
-/**
- * The packaged pull-request reviewer factory.
- *
- * - `make` — one flat reviewer over the whole changeset.
- * - `makeFanOut` — a coordinator delegating bounded per-unit child reviews.
- */
-export const PrReview = { make, makeFanOut } as const;

package/src/internal/fan-out-scripted.ts

@@ -1,164 +0,0 @@
-import { Effect, Layer, Ref, Schema, Stream } from "effect";
-import { LanguageModel, Model, type Response } from "effect/unstable/ai";
-
-import { FileReviewReport } from "./fan-out.ts";
-import { CodeReview } from "./review-agent.ts";
-import { makePromptKeyedModel, scriptedFinalParts, scriptedToolTurn } from "./scripted.ts";
-
-// ---------------------------------------------------------------------------
-// Deterministic offline models for the fan-out reviewer: prompt-keyed
-// scripted models for BOTH the coordinator and the file-reviewer children.
-// Both key every decision on committed history in the prompt (tool-call ids
-// and briefed unit ids), never on call order, so concurrent children and
-// replays stay honest.
-// ---------------------------------------------------------------------------
-
-export const OFFLINE_UNITS_CALL_ID = "units-1";
-
-/** The delegation Tool Call id the scripted coordinator uses for one unit. */
-export const offlineUnitCallId = (unitId: string): string => `delegate-${unitId}`;
-
-/** The diff Tool Call id the scripted child uses for one unit. */
-export const offlineChildDiffCallId = (unitId: string): string => `fanout-diff-${unitId}`;
-
-/** One scripted delegation the offline coordinator declares. */
-export interface OfflineUnitCall {
-  readonly unitId: string;
-  readonly paths: ReadonlyArray<string>;
-}
-
-/**
- * Build the offline scripted coordinator model. Turn 1 lists the review
- * units, Turn 2 declares one delegation Tool Call per scripted unit in one
- * batch, Turn 3 returns the scripted merged review JSON. Decisions key on
- * tool-call ids already committed to the prompt.
- */
-export const makeOfflineFanOutCoordinatorModel = (script: {
-  readonly unitCalls: ReadonlyArray<OfflineUnitCall>;
-  readonly review: CodeReview;
-}) => {
-  const firstUnitCallId = offlineUnitCallId(script.unitCalls[0]?.unitId ?? "unit-none");
-  return makePromptKeyedModel("pr-fanout-coordinator-offline", (promptJson) => {
-    if (promptJson.includes(firstUnitCallId)) {
-      return scriptedFinalParts(JSON.stringify(Schema.encodeSync(CodeReview)(script.review)));
-    }
-    if (promptJson.includes(OFFLINE_UNITS_CALL_ID)) {
-      return scriptedToolTurn(
-        ...script.unitCalls.map(
-          (unit): Response.StreamPartEncoded => ({
-            type: "tool-call",
-            id: offlineUnitCallId(unit.unitId),
-            name: "delegate_file_review",
-            params: { unitId: unit.unitId, paths: unit.paths },
-            providerExecuted: false,
-          }),
-        ),
-      );
-    }
-    return scriptedToolTurn({
-      type: "tool-call",
-      id: OFFLINE_UNITS_CALL_ID,
-      name: "list_review_units",
-      params: { scope: "all" },
-      providerExecuted: false,
-    });
-  });
-};
-
-/** How one scripted child behaves for its briefed unit. */
-export type OfflineUnitOutcome =
-  /** Read one diff, then return the scripted report. */
-  | { readonly _tag: "findings"; readonly report: FileReviewReport }
-  /** Read one diff, then return non-JSON — the child fails typed (AgentOutputError). */
-  | { readonly _tag: "malformed-output" }
-  /**
-   * Declare more Tool Calls than the child's AgentPolicy allows in one turn —
-   * none executes and the child fails typed (AgentPolicyError "tool-calls",
-   * the reviewer's deliberate `onExhaustion: "fail"` pin).
-   */
-  | { readonly _tag: "budget-runaway"; readonly declaredCalls: number };
-
-export interface OfflineUnitScript {
-  readonly unitId: string;
-  /** The one file the scripted child reads the diff of. */
-  readonly diffPath: string;
-  readonly outcome: OfflineUnitOutcome;
-}
-
-/**
- * Build the offline scripted file-reviewer model shared by every delegated
- * child. Each child Run builds the Model Layer inside its own scope; the
- * script entry is selected by the briefed unitId present in the child's OWN
- * prompt, and the turn is selected by whether that unit's diff Tool Call id
- * is already committed there — content-keyed on both axes, so concurrent
- * children never interfere. First-turn child prompts are recorded for
- * context-isolation assertions.
- */
-export const makeOfflineFileReviewerModel = (scripts: ReadonlyArray<OfflineUnitScript>) =>
-  Effect.gen(function* () {
-    const calls = yield* Ref.make(0);
-    const prompts = yield* Ref.make<ReadonlyArray<string>>([]);
-    const decide = (promptJson: string): ReadonlyArray<Response.StreamPartEncoded> | undefined => {
-      const script = scripts.find((candidate) => promptJson.includes(candidate.unitId));
-      if (script === undefined) return undefined;
-      switch (script.outcome._tag) {
-        case "budget-runaway": {
-          return scriptedToolTurn(
-            ...Array.from(
-              { length: script.outcome.declaredCalls },
-              (_, index): Response.StreamPartEncoded => ({
-                type: "tool-call",
-                id: `runaway-${script.unitId}-${index + 1}`,
-                name: "read_file_diff",
-                params: { path: script.diffPath },
-                providerExecuted: false,
-              }),
-            ),
-          );
-        }
-        case "malformed-output":
-        case "findings": {
-          if (promptJson.includes(offlineChildDiffCallId(script.unitId))) {
-            return scriptedFinalParts(
-              script.outcome._tag === "findings"
-                ? JSON.stringify(Schema.encodeSync(FileReviewReport)(script.outcome.report))
-                : "this is not the JSON you are looking for",
-            );
-          }
-          return scriptedToolTurn({
-            type: "tool-call",
-            id: offlineChildDiffCallId(script.unitId),
-            name: "read_file_diff",
-            params: { path: script.diffPath },
-            providerExecuted: false,
-          });
-        }
-      }
-    };
-    const model = Model.make(
-      "scripted",
-      "pr-fanout-file-reviewer-offline",
-      Layer.effect(
-        LanguageModel.LanguageModel,
-        LanguageModel.make({
-          generateText: () => Effect.succeed([]),
-          streamText: (request) =>
-            Stream.unwrap(
-              Effect.gen(function* () {
-                yield* Ref.update(calls, (value) => value + 1);
-                const promptJson = JSON.stringify(request.prompt);
-                yield* Ref.update(prompts, (previous) => [...previous, promptJson]);
-                const parts = decide(promptJson);
-                if (parts === undefined) {
-                  return yield* Effect.die(
-                    new Error("The child prompt names no scripted review unit"),
-                  );
-                }
-                return Stream.fromIterable(parts);
-              }),
-            ),
-        }),
-      ),
-    );
-    return { model, calls: Ref.get(calls), prompts: Ref.get(prompts) };
-  });