@effect-agent/pr-review 0.1.0-beta.22 → 0.1.0-beta.24

package/src/internal/factory.ts

@@ -1,23 +1,17 @@
-import { Effect, Layer } from "effect";
+import { Effect, Layer, Schema } 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 type { ChangedFile } from "./diff.ts";
-import {
-  fanOutHandlersLayerFor,
-  FanOutCoordinatorToolkitLayer,
-  FileReviewToolkitLayer,
-  makeFanOutReviewSuite,
-} from "./fan-out.ts";
-import { computeChangesetFingerprint } from "./fingerprint.ts";
+import { makeFileReviewerDefinition } from "./fan-out.ts";
+import { computeChangesetFingerprint, computeProfileFingerprint } from "./fingerprint.ts";
 import { compileIgnoreGlobs, ignoringPullRequestSourceLayer } from "./ignore.ts";
 import {
   clampMaxFindings,
@@ -32,9 +26,10 @@ import {
   resolveGuidance as resolveReviewGuidance,
   type ReviewGuidance,
 } from "./review-agent.ts";
-import { buildProfileMission, computeProfileFingerprint } from "./review-state.ts";
+import { buildProfileMission } from "./review-state.ts";
 import {
   buildReviewMission,
+  executeFanOutReview,
   executeReview,
   fanOutReviewBudgetLimits,
   reviewBudgetLimits,
@@ -180,8 +175,8 @@ const makeReviewSnapshot = (ignore: ReadonlyArray<string> | undefined) =>
  * 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.
+ * pull-request source, the publisher, `Crypto.Crypto`, extra tool handlers,
+ * and the Model Layer's requirements all remain visible to the caller.
  */
 const make = <
   Provider,
@@ -244,8 +239,6 @@ const make = <
         signature,
         modelLabel: options.modelLabel,
         runUrl: runOptions.runUrl,
-        usageScope: "run",
-        reviewShape: "flat",
       }).pipe(Effect.provide(Layer.mergeAll(ReviewToolkitLayer, IdGenerator.layer)), Effect.scoped),
       options.ignore,
     );
@@ -264,44 +257,39 @@ const make = <
   } as const;
 };
 
-/** Options accepted by `PrReview.makeFanOut` (the delegating reviewer). */
+/** Options accepted by `PrReview.makeFanOut` (the host-scheduled pipeline). */
 export interface PrReviewFanOutOptions<
   Provider,
   ModelProvides,
   ModelRequires,
 > extends PrReviewSharedOptions {
-  /** The Effect AI Model bound to both the coordinator and its children. */
+  /** The Effect AI Model bound to every child review pass. */
   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
+   * pipeline schedules children from the deterministic plan, so
    * mission-dependent guidance cannot exist for children.
    */
   readonly guidance?: string | ReadonlyArray<string> | undefined;
 }
 
 /**
- * Build the fan-out reviewer: a coordinator schedules host-planned general
- * and specialist discovery plus independent candidate verification through
- * attached ephemeral children. Host code reconstructs publication only from
- * exactly confirmed candidates. 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.
+ * Build the fan-out reviewer: host code schedules host-planned general and
+ * specialist discovery plus independent candidate verification directly as
+ * bounded child runs — there is no coordinator model and no delegation tool,
+ * so review assurance cannot fail on scheduling compliance. Host code
+ * composes publication only from exactly confirmed candidates. Child
+ * execution bounds are packaged and not configurable here.
  */
 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 });
+  const child = makeFileReviewerDefinition({ guidance: options.guidance });
+  // Structural binding for the same reason as in `make` above.
+  const childBinding = Object.freeze({ definition: 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.
+  // Everything that shapes this pipeline's output: the child instructions
+  // (guidance included) plus the host knobs the children do not carry.
   const guidanceLines =
     options.guidance === undefined
       ? []
@@ -310,31 +298,30 @@ const makeFanOut = <Provider, ModelProvides, ModelRequires>(
         : options.guidance;
   const signature = (mission: ReviewMission): string =>
     [
-      suite.parent.instructions(mission),
+      "pr-review-fan-out-host-scheduled-v1",
+      // Children never see the mission, but the documented skip-unchanged
+      // contract includes pull-request framing, so the fingerprint keeps it.
+      JSON.stringify(Schema.encodeSync(ReviewMission)(mission)),
       `childGuidance=${JSON.stringify(guidanceLines)}`,
+      `maxFindings=${clampMaxFindings(options.maxFindings)}`,
       `applyVerdict=${String(options.applyVerdict ?? false)}`,
       ...(options.modelLabel === undefined ? [] : [`model=${options.modelLabel}`]),
     ].join(" ");
   const profileSignature = (_mission: ReviewMission): string =>
     [
-      // v3 invalidates continuity produced before complete evidence sharding,
-      // universal specialist scrutiny, and request-bound result projection.
-      "pr-review-profile-v3-sharded-request-bound-assurance",
+      // v4 invalidates continuity produced by the coordinator-scheduled
+      // pipeline; the host now schedules every pass and retries failures.
+      "pr-review-profile-v4-host-scheduled",
       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),
-    ),
-  );
+    ].join(" ");
 
   const run = (runOptions: RunReviewOptions = {}) =>
     provideIgnore(
-      executeReview(binding, {
+      executeFanOutReview(childBinding, {
         post: runOptions.post ?? false,
         applyVerdict: options.applyVerdict ?? false,
         limits: options.budget ?? fanOutReviewBudgetLimits,
@@ -342,20 +329,12 @@ const makeFanOut = <Provider, ModelProvides, ModelRequires>(
         signature,
         modelLabel: options.modelLabel,
         runUrl: runOptions.runUrl,
-        usageScope: "coordinator",
-        reviewShape: "fan-out",
-      }).pipe(
-        Effect.provide(
-          Layer.mergeAll(FanOutCoordinatorToolkitLayer, delegationLayer, IdGenerator.layer),
-        ),
-        Effect.scoped,
-      ),
+      }).pipe(Effect.provide(IdGenerator.layer), Effect.scoped),
       options.ignore,
     );
 
   return {
-    definition: suite.parent,
-    binding,
+    definition: child,
     childBinding,
     run,
     fingerprint: makeFingerprint(signature, options.ignore),

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

@@ -1,83 +1,14 @@
 import { Effect, Layer, Ref, Schema, Stream } from "effect";
-import { LanguageModel, Model, type Response } from "effect/unstable/ai";
+import { LanguageModel, Model } from "effect/unstable/ai";
 
-import { FileReviewReport, FileReviewRequest } from "./fan-out.ts";
-import { CodeReview } from "./review-agent.ts";
-import { makePromptKeyedModel, scriptedFinalParts, scriptedToolTurn } from "./scripted.ts";
+import { FileReviewReport } from "./fan-out.ts";
+import { scriptedFinalParts } from "./scripted.ts";
 
-// Deterministic offline models for the complete fan-out protocol. Decisions
-// key on committed Tool Call IDs or work IDs in each prompt, never call order,
-// so bounded child concurrency cannot make the fixtures flaky.
-
-export const OFFLINE_UNITS_CALL_ID = "units-1";
-
-export const offlineUnitCallId = (workId: string): string => `delegate-${workId}`;
-
-export type OfflineUnitCall = FileReviewRequest;
-
-const scriptedUnitCallId = (calls: ReadonlyArray<OfflineUnitCall>, index: number): string => {
-  const call = calls[index];
-  if (call === undefined) return "delegate-none";
-  const occurrence = calls
-    .slice(0, index + 1)
-    .filter((candidate) => candidate.workId === call.workId).length;
-  const base = offlineUnitCallId(call.workId);
-  return occurrence === 1 ? base : `${base}-${occurrence}`;
-};
-
-export const makeOfflineFanOutCoordinatorModel = (script: {
-  readonly discoveryCalls: ReadonlyArray<OfflineUnitCall>;
-  readonly verificationCalls: ReadonlyArray<OfflineUnitCall>;
-  readonly review: CodeReview;
-}) => {
-  const firstDiscovery = scriptedUnitCallId(script.discoveryCalls, 0);
-  const firstVerification = scriptedUnitCallId(script.verificationCalls, 0);
-  return makePromptKeyedModel("pr-fanout-coordinator-offline", (promptJson) => {
-    if (script.discoveryCalls.length === 0 && promptJson.includes(OFFLINE_UNITS_CALL_ID)) {
-      return scriptedFinalParts(JSON.stringify(Schema.encodeSync(CodeReview)(script.review)));
-    }
-    if (
-      script.verificationCalls.length === 0
-        ? promptJson.includes(firstDiscovery)
-        : promptJson.includes(firstVerification)
-    ) {
-      return scriptedFinalParts(JSON.stringify(Schema.encodeSync(CodeReview)(script.review)));
-    }
-    if (promptJson.includes(firstDiscovery)) {
-      return scriptedToolTurn(
-        ...script.verificationCalls.map(
-          (call, index): Response.StreamPartEncoded => ({
-            type: "tool-call",
-            id: scriptedUnitCallId(script.verificationCalls, index),
-            name: "delegate_file_review",
-            params: Schema.encodeSync(FileReviewRequest)(call),
-            providerExecuted: false,
-          }),
-        ),
-      );
-    }
-    if (promptJson.includes(OFFLINE_UNITS_CALL_ID)) {
-      return scriptedToolTurn(
-        ...script.discoveryCalls.map(
-          (call, index): Response.StreamPartEncoded => ({
-            type: "tool-call",
-            id: scriptedUnitCallId(script.discoveryCalls, index),
-            name: "delegate_file_review",
-            params: Schema.encodeSync(FileReviewRequest)(call),
-            providerExecuted: false,
-          }),
-        ),
-      );
-    }
-    return scriptedToolTurn({
-      type: "tool-call",
-      id: OFFLINE_UNITS_CALL_ID,
-      name: "list_review_units",
-      params: { scope: "all" },
-      providerExecuted: false,
-    });
-  });
-};
+// Deterministic offline child models for the host-scheduled fan-out pipeline.
+// Decisions key on the work ID committed into each child's instructions,
+// never call order, so bounded pass concurrency cannot make fixtures flaky.
+// Each work ID carries a SEQUENCE of outcomes consumed per call, so tests can
+// script "fail once, then settle" and pin the pipeline's bounded retry.
 
 export type OfflineUnitOutcome =
   | { readonly _tag: "report"; readonly report: FileReviewReport }
@@ -85,13 +16,15 @@ export type OfflineUnitOutcome =
 
 export interface OfflineUnitScript {
   readonly workId: string;
-  readonly outcome: OfflineUnitOutcome;
+  /** Consumed one per child call for this work ID; the last outcome repeats. */
+  readonly outcomes: ReadonlyArray<OfflineUnitOutcome>;
 }
 
 export const makeOfflineFileReviewerModel = (scripts: ReadonlyArray<OfflineUnitScript>) =>
   Effect.gen(function* () {
     const calls = yield* Ref.make(0);
     const prompts = yield* Ref.make<ReadonlyArray<string>>([]);
+    const callsByWorkId = yield* Ref.make<ReadonlyMap<string, number>>(new Map());
     const model = Model.make(
       "scripted",
       "pr-fanout-file-reviewer-offline",
@@ -115,10 +48,23 @@ export const makeOfflineFileReviewerModel = (scripts: ReadonlyArray<OfflineUnitS
                 }
                 const [selected] = script;
                 if (selected === undefined) return yield* Effect.die("unreachable scripted match");
+                const occurrence = yield* Ref.modify(callsByWorkId, (byWorkId) => {
+                  const count = byWorkId.get(selected.workId) ?? 0;
+                  const next = new Map(byWorkId);
+                  next.set(selected.workId, count + 1);
+                  return [count, next] as const;
+                });
+                const outcome =
+                  selected.outcomes[Math.min(occurrence, selected.outcomes.length - 1)];
+                if (outcome === undefined) {
+                  return yield* Effect.die(
+                    new Error(`Work ID ${selected.workId} scripts no outcomes`),
+                  );
+                }
                 return Stream.fromIterable(
                   scriptedFinalParts(
-                    selected.outcome._tag === "report"
-                      ? JSON.stringify(Schema.encodeSync(FileReviewReport)(selected.outcome.report))
+                    outcome._tag === "report"
+                      ? JSON.stringify(Schema.encodeSync(FileReviewReport)(outcome.report))
                       : "this is not valid review JSON",
                   ),
                 );