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

package/src/internal/factory.ts

@@ -10,6 +10,7 @@ import {
 } from "effect-agent";
 import { Toolkit, type LanguageModel, type Model, type Tool } from "effect/unstable/ai";
 
+import type { ChangedFile } from "./diff.ts";
 import {
   fanOutHandlersLayerFor,
   FanOutCoordinatorToolkitLayer,
@@ -256,7 +257,7 @@ const make = <
     fingerprint: makeFingerprint(signature, options.ignore),
     profileFingerprint: makeProfileFingerprint(profileSignature, options.ignore),
     snapshot: makeReviewSnapshot(options.ignore),
-    filterFiles: (files: ReadonlyArray<import("./diff.ts").ChangedFile>) => {
+    filterFiles: (files: ReadonlyArray<ChangedFile>) => {
       const ignored = compileIgnoreGlobs(options.ignore ?? []);
       return files.filter((file) => !ignored(file.path));
     },
@@ -280,12 +281,12 @@ export interface PrReviewFanOutOptions<
 }
 
 /**
- * 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.
+ * 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.
  */
 const makeFanOut = <Provider, ModelProvides, ModelRequires>(
   options: PrReviewFanOutOptions<Provider, ModelProvides, ModelRequires>,
@@ -316,7 +317,9 @@ const makeFanOut = <Provider, ModelProvides, ModelRequires>(
     ].join(" ");
   const profileSignature = (_mission: ReviewMission): string =>
     [
-      "pr-review-profile-v1-fan-out",
+      // v3 invalidates continuity produced before complete evidence sharding,
+      // universal specialist scrutiny, and request-bound result projection.
+      "pr-review-profile-v3-sharded-request-bound-assurance",
       JSON.stringify(guidanceLines),
       JSON.stringify(options.ignore ?? []),
       `maxFindings=${clampMaxFindings(options.maxFindings)}`,
@@ -358,7 +361,7 @@ const makeFanOut = <Provider, ModelProvides, ModelRequires>(
     fingerprint: makeFingerprint(signature, options.ignore),
     profileFingerprint: makeProfileFingerprint(profileSignature, options.ignore),
     snapshot: makeReviewSnapshot(options.ignore),
-    filterFiles: (files: ReadonlyArray<import("./diff.ts").ChangedFile>) => {
+    filterFiles: (files: ReadonlyArray<ChangedFile>) => {
       const ignored = compileIgnoreGlobs(options.ignore ?? []);
       return files.filter((file) => !ignored(file.path));
     },

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

@@ -1,55 +1,69 @@
 import { Effect, Layer, Ref, Schema, Stream } from "effect";
 import { LanguageModel, Model, type Response } from "effect/unstable/ai";
 
-import { FileReviewReport } from "./fan-out.ts";
+import { FileReviewReport, FileReviewRequest } 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.
-// ---------------------------------------------------------------------------
+// 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";
 
-/** The delegation Tool Call id the scripted coordinator uses for one unit. */
-export const offlineUnitCallId = (unitId: string): string => `delegate-${unitId}`;
+export const offlineUnitCallId = (workId: string): string => `delegate-${workId}`;
 
-/** The diff Tool Call id the scripted child uses for one unit. */
-export const offlineChildDiffCallId = (unitId: string): string => `fanout-diff-${unitId}`;
+export type OfflineUnitCall = FileReviewRequest;
 
-/** One scripted delegation the offline coordinator declares. */
-export interface OfflineUnitCall {
-  readonly unitId: string;
-  readonly paths: ReadonlyArray<string>;
-}
+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}`;
+};
 
-/**
- * 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 discoveryCalls: ReadonlyArray<OfflineUnitCall>;
+  readonly verificationCalls: ReadonlyArray<OfflineUnitCall>;
   readonly review: CodeReview;
 }) => {
-  const firstUnitCallId = offlineUnitCallId(script.unitCalls[0]?.unitId ?? "unit-none");
+  const firstDiscovery = scriptedUnitCallId(script.discoveryCalls, 0);
+  const firstVerification = scriptedUnitCallId(script.verificationCalls, 0);
   return makePromptKeyedModel("pr-fanout-coordinator-offline", (promptJson) => {
-    if (promptJson.includes(firstUnitCallId)) {
+    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.unitCalls.map(
-          (unit): Response.StreamPartEncoded => ({
+        ...script.discoveryCalls.map(
+          (call, index): Response.StreamPartEncoded => ({
             type: "tool-call",
-            id: offlineUnitCallId(unit.unitId),
+            id: scriptedUnitCallId(script.discoveryCalls, index),
             name: "delegate_file_review",
-            params: { unitId: unit.unitId, paths: unit.paths },
+            params: Schema.encodeSync(FileReviewRequest)(call),
             providerExecuted: false,
           }),
         ),
@@ -65,76 +79,19 @@ export const makeOfflineFanOutCoordinatorModel = (script: {
   });
 };
 
-/** 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 };
+  | { readonly _tag: "report"; readonly report: FileReviewReport }
+  | { readonly _tag: "malformed-output" };
 
 export interface OfflineUnitScript {
-  readonly unitId: string;
-  /** The one file the scripted child reads the diff of. */
-  readonly diffPath: string;
+  readonly workId: 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",
@@ -148,13 +105,23 @@ export const makeOfflineFileReviewerModel = (scripts: ReadonlyArray<OfflineUnitS
                 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) {
+                const script = scripts.filter((candidate) =>
+                  promptJson.includes(`for ${candidate.workId} in host-planned unit`),
+                );
+                if (script.length !== 1) {
                   return yield* Effect.die(
-                    new Error("The child prompt names no scripted review unit"),
+                    new Error("The child prompt must name exactly one scripted work ID"),
                   );
                 }
-                return Stream.fromIterable(parts);
+                const [selected] = script;
+                if (selected === undefined) return yield* Effect.die("unreachable scripted match");
+                return Stream.fromIterable(
+                  scriptedFinalParts(
+                    selected.outcome._tag === "report"
+                      ? JSON.stringify(Schema.encodeSync(FileReviewReport)(selected.outcome.report))
+                      : "this is not valid review JSON",
+                  ),
+                );
               }),
             ),
         }),