@claudexor/review 3.1.2 → 3.2.0

package/dist/reviewEngine.js

@@ -1,13 +1,15 @@
-import { parseUnifiedDiff, runCapture } from "@claudexor/core";
 import { preflightEvidence, writeDiffEvidence } from "@claudexor/context";
 import { HarnessRunSpec, ReviewFinding as ReviewFindingSchema } from "@claudexor/schema";
-import { existsSync, lstatSync, readlinkSync, realpathSync, statSync } from "node:fs";
-import { cp, mkdir, readdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
-import { appendLine, containsSecretLikeToken, ensureDir, newId, nowIso, readTextSafe, redactSecrets, sensitiveResourcePolicy, sha256, writeJson, writeText, } from "@claudexor/util";
-import { dedupeFindings, extractJsonBlocks, parseFindingsDetailed, } from "./findings.js";
-import { buildReviewPrompt } from "./reviewPrompt.js";
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { appendLine, containsSecretLikeToken, engineBuildIdentity, ensureDir, newId, nowIso, readTextSafe, redactSecrets, sha256, writeJson, writeText, } from "@claudexor/util";
+import { dedupeFindings, extractJsonBlocks, parseFindingsDetailed, parseSealedReviewEnvelopeDetailed, sealedReviewTranscriptChunk, } from "./findings.js";
+import { buildReviewPrompt, SEALED_REVIEW_OUTPUT_SCHEMA } from "./reviewPrompt.js";
+import { sealedReviewTranscriptFromEvents } from "./sealedReviewEnvelope.js";
+import { buildReviewerCandidateInventory, cleanupTemporaryReviewerWorkspaceBaseDir, copyReviewEvidencePacket, extractDiffPostimagePaths, isSameOrInside, prepareReviewerWorkspace, selectReviewerWorkspaceBaseDir, } from "./reviewerWorkspace.js";
+export { extractDiffPostimagePaths as __testExtractDiffPostimagePaths } from "./reviewerWorkspace.js";
 import { buildRouteProof, classifyDiversity } from "./route.js";
 import { reviewerAuthMode, reviewerAuthSwitchFromEvent } from "./reviewRuntimeTypes.js";
 import { ReviewerCostKnowledge } from "./reviewerCostKnowledge.js";
@@ -18,8 +20,6 @@ const DEFAULT_REVIEWER_TRANSIENT_RETRY_POLICY = {
     initialDelayMs: 1_000,
     maxDelayMs: 10_000,
 };
-const BLOCKED_REVIEWER_RUNTIME_ROOTS = new Set("auth cache daemon home homes logs runs secrets state tmp workspaces".split(" "));
-const TEXT_EVIDENCE_SUFFIXES = [".md", ".txt", ".json", ".yaml", ".yml", ".patch"];
 const REVIEW_WAVE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function readExistingDiffEvidence(dir, diff) {
     const diffText = diff.endsWith("\n") ? diff : `${diff}\n`;
@@ -55,6 +55,26 @@ function reviewerInfo(reviewer, routeProofStatus, observedModel = null) {
     };
 }
 export async function reviewCandidate(input) {
+    const sourceRoot = resolve(input.cwd);
+    const sourceExists = existsSync(sourceRoot);
+    const canonicalSourceRoot = sourceExists ? realpathSync(sourceRoot) : sourceRoot;
+    const sourceEvidencePath = resolve(input.evidenceDir);
+    const sourceEvidenceRoot = existsSync(input.evidenceDir)
+        ? realpathSync(input.evidenceDir)
+        : sourceEvidencePath;
+    if (sourceExists && isSameOrInside(sourceEvidenceRoot, canonicalSourceRoot)) {
+        throw new Error("review evidence directory must not contain the candidate root");
+    }
+    const evidenceInsideLexicalSource = sourceExists && isSameOrInside(sourceRoot, sourceEvidencePath);
+    const evidenceInsideCanonicalSource = sourceExists && isSameOrInside(canonicalSourceRoot, sourceEvidenceRoot);
+    const evidencePathInSourceNamespace = evidenceInsideCanonicalSource
+        ? resolve(sourceRoot, relative(canonicalSourceRoot, sourceEvidenceRoot))
+        : null;
+    const candidateEvidenceExcludeRoots = evidenceInsideLexicalSource || evidenceInsideCanonicalSource
+        ? [
+            ...new Set([sourceEvidencePath, sourceEvidenceRoot, evidencePathInSourceNamespace].filter((path) => path !== null)),
+        ]
+        : [];
     const findingsByReviewer = input.reviewers.map(() => []);
     const reviewerFamilies = input.reviewers.map((reviewer) => reviewer.providerFamily);
     const routeProofs = input.reviewers.map((reviewer, index) => reviewerRouteProof(reviewer, null, "unavailable", reviewerFamilies.filter((_, otherIndex) => otherIndex !== index)));
@@ -72,12 +92,26 @@ export async function reviewCandidate(input) {
         throw new Error("sealed release review requires CLAUDEXOR_REVIEW_WAVE_ID UUID");
     }
     const frozenMetadata = input.frozenIdentity
-        ? {
-            candidate_sha: input.frozenIdentity.candidateSha,
-            candidate_tree: input.frozenIdentity.candidateTree,
-            packet_manifest_sha256: input.frozenIdentity.packetManifestSha256,
-            ...(reviewWaveId ? { review_wave_id: reviewWaveId } : {}),
-        }
+        ? (() => {
+            const runtime = engineBuildIdentity();
+            const runtimeEntry = realpathSync(runtime.entry);
+            const runtimeEntryStat = lstatSync(runtimeEntry);
+            if (!runtimeEntryStat.isFile() || runtimeEntryStat.isSymbolicLink()) {
+                throw new Error("sealed release review runtime entry is not a regular file");
+            }
+            return {
+                candidate_sha: input.frozenIdentity.candidateSha,
+                candidate_tree: input.frozenIdentity.candidateTree,
+                packet_manifest_sha256: input.frozenIdentity.packetManifestSha256,
+                review_runtime_version: runtime.version,
+                review_runtime_build_sha: runtime.sha,
+                review_runtime_entry: runtimeEntry,
+                review_runtime_entry_sha256: createHash("sha256")
+                    .update(readFileSync(runtimeEntry))
+                    .digest("hex"),
+                ...(reviewWaveId ? { review_wave_id: reviewWaveId } : {}),
+            };
+        })()
         : {};
     if (containsSecretLikeToken(input.diff || "(empty diff)\n")) {
         throw new Error("diff evidence contains a secret-like token; refusing to persist raw DIFF.patch");
@@ -100,7 +134,15 @@ export async function reviewCandidate(input) {
         ].filter(Boolean);
         throw new Error(`mandatory evidence preflight failed (${parts.join("; ")})`);
     }
+    const postimagePaths = extractDiffPostimagePaths(input.diff);
+    const candidateInventory = await buildReviewerCandidateInventory(input.cwd, postimagePaths, input.evidenceReadOnly === true);
     const artifactsBaseDir = input.artifactsDir ?? join(input.evidenceDir, "reviewer-artifacts");
+    if (input.evidenceReadOnly &&
+        input.frozenIdentity &&
+        existsSync(artifactsBaseDir) &&
+        readdirSync(artifactsBaseDir).length > 0) {
+        throw new Error("sealed release review requires a fresh empty artifacts directory");
+    }
     ensureDir(artifactsBaseDir);
     const persistentEvidenceDir = join(artifactsBaseDir, "evidence");
     await copyReviewEvidencePacket(input.evidenceDir, persistentEvidenceDir, input.evidenceReadOnly === true);
@@ -116,11 +158,11 @@ export async function reviewCandidate(input) {
         diff_path: persistentPatch.diffPath,
         summary_path: persistentPatch.summaryPath,
         diff_sha256: persistentPatch.diffSha256,
-        review_subject: input.reviewSubject ?? "code",
+        candidate_inventory_mode: candidateInventory.mode,
+        candidate_inventory_reason: candidateInventory.reason,
         ...frozenMetadata,
     });
     const artifacts = input.reviewers.map(() => undefined);
-    const preservePaths = extractDiffTouchedPaths(input.diff);
     const reviewerWorkspaceBaseDir = selectReviewerWorkspaceBaseDir(input.cwd, artifactsBaseDir, input.evidenceDir);
     const runReviewer = async (reviewer, index) => {
         if (input.signal?.aborted)
@@ -135,8 +177,9 @@ export async function reviewCandidate(input) {
                 sourceEvidenceDir: persistentEvidenceDir,
                 workspaceBaseDir: reviewerWorkspaceBaseDir,
                 reviewerDirName: `${String(index + 1).padStart(2, "0")}-${safeFilePart(reviewer.adapter.id)}`,
-                excludeRoots: [artifactsBaseDir],
-                preservePaths,
+                excludeRoots: [artifactsBaseDir, ...candidateEvidenceExcludeRoots],
+                postimagePaths,
+                candidateCopyPaths: candidateInventory.copyPaths,
                 preserveEvidenceBytes: input.evidenceReadOnly === true,
             });
             const reviewerPatch = input.evidenceReadOnly
@@ -152,34 +195,42 @@ export async function reviewCandidate(input) {
                 persistent_diff_path: persistentPatch.diffPath,
                 persistent_summary_path: persistentPatch.summaryPath,
                 diff_sha256: persistentPatch.diffSha256,
-                review_subject: input.reviewSubject ?? "code",
+                candidate_inventory_mode: candidateInventory.mode,
+                candidate_inventory_reason: candidateInventory.reason,
                 ...frozenMetadata,
             });
-            const runtimePrompt = buildReviewPrompt(input.candidateLabel, reviewerWorkspace.root, reviewerWorkspace.evidenceDir, reviewerPatch, input.evidenceReadOnly === true, input.reviewSubject ?? "code");
+            const runtimePrompt = buildReviewPrompt(input.candidateLabel, reviewerWorkspace.root, reviewerWorkspace.evidenceDir, reviewerPatch, {
+                sealed: input.evidenceReadOnly === true,
+                candidateInventoryMode: candidateInventory.mode,
+            });
             spec = HarnessRunSpec.parse({
                 session_id: newId("rev"),
                 intent: "review",
                 prompt: runtimePrompt,
                 cwd: reviewerWorkspace.root,
                 access: "readonly",
+                ...(input.evidenceReadOnly && input.frozenIdentity
+                    ? {
+                        external_context_policy: "live",
+                        tool_permission_policy: { web: "live", allow: [], deny: [] },
+                    }
+                    : {}),
                 model_hint: reviewer.requestedModel ?? null,
                 effort_hint: reviewer.requestedEffort ?? null,
                 auth_preference: reviewer.authPreference ?? "auto",
                 env_inheritance: input.envInheritance ?? "mirror_native",
+                ...(input.evidenceReadOnly && input.frozenIdentity
+                    ? { output_schema: SEALED_REVIEW_OUTPUT_SCHEMA }
+                    : {}),
                 ...(input.env ? { env: input.env } : {}),
             });
-            writeText(artifact.promptPath, redactSecrets(`Persistent local replay evidence:
-- evidence_dir: ${persistentEvidenceDir}
-- candidate_root: ${reviewerWorkspace.root}
-- source_candidate_root: ${input.cwd}
-- source_candidate_evidence_dir: ${input.evidenceDir}
-- diff_path: ${persistentPatch.diffPath}
-- diff_sha256: ${persistentPatch.diffSha256}
-
-Runtime prompt used during review follows. Its candidate-tree paths may be transient after orchestrator cleanup; use the durable replay paths above for audit/replay.
-
-${runtimePrompt}
-`));
+            writeText(artifact.promptPath, spec.prompt);
+            updateReviewerMetadata(artifact, {
+                session_id: spec.session_id,
+                external_context_policy: spec.external_context_policy,
+                tool_web_policy: spec.tool_permission_policy.web,
+                submitted_prompt_sha256: createHash("sha256").update(spec.prompt).digest("hex"),
+            });
         }
         catch (err) {
             const failedAt = nowIso();
@@ -210,9 +261,13 @@ ${runtimePrompt}
         let routeModel;
         let routeSource = "unavailable";
         let reviewerError = null;
+        let sealedProjectionError = null;
         try {
-            const out = await collectReviewerOutput(reviewer, spec, reviewerTimeoutMs, input.transientRetryPolicy ?? DEFAULT_REVIEWER_TRANSIENT_RETRY_POLICY, artifact, input.onReviewerEvent, input.signal);
+            const out = await collectReviewerOutput(reviewer, spec, reviewerTimeoutMs, input.evidenceReadOnly && input.frozenIdentity
+                ? { maxRetries: 0, initialDelayMs: 0, maxDelayMs: 0 }
+                : (input.transientRetryPolicy ?? DEFAULT_REVIEWER_TRANSIENT_RETRY_POLICY), artifact, input.onReviewerEvent, input.signal, input.evidenceReadOnly === true);
             text = out.text;
+            sealedProjectionError = out.sealedProjectionError ?? null;
             streamObservedModel = out.observedModel;
             routeModel = out.observedModel;
             routeSource = out.observedSource;
@@ -228,6 +283,9 @@ ${runtimePrompt}
             if (typeof partial?.partialText === "string" && partial.partialText.trim() !== "") {
                 text = partial.partialText;
             }
+            if (typeof partial?.partialSealedProjectionError === "string") {
+                sealedProjectionError = partial.partialSealedProjectionError;
+            }
             reviewerSpend.recordPartial(index, partial);
             if (partial?.partialObservedModel) {
                 streamObservedModel = partial.partialObservedModel;
@@ -242,8 +300,24 @@ ${runtimePrompt}
         const proof = reviewerRouteProof(reviewer, routeModel ?? null, routeSource, reviewerFamilies.filter((_, i) => i !== index));
         routeProofs[index] = proof;
         const info = reviewerInfo(reviewer, proof.status, streamObservedModel ?? null);
-        const jsonBlocks = extractJsonBlocks(text);
+        const sealedParse = input.evidenceReadOnly
+            ? parseSealedReviewEnvelopeDetailed(text, info)
+            : null;
+        const jsonBlocks = sealedParse?.blocks ?? extractJsonBlocks(text);
         writeJson(artifact.parsedPath, redactValue(jsonBlocks));
+        if (sealedParse && (sealedProjectionError || sealedParse.error)) {
+            const detail = sealedProjectionError ?? sealedParse.error ?? "invalid sealed review output";
+            writeParseError(artifact, {
+                error: "invalid_sealed_review_envelope",
+                detail,
+                malformed: sealedParse.malformed,
+                text_sha256: sha256(text),
+                ...(reviewerError ? { reviewer_error: reviewerError } : {}),
+            });
+            findingsByReviewer[index]?.push(...sealedParse.findings);
+            findingsByReviewer[index]?.push(insufficientEvidenceFinding(info, `Invalid sealed review envelope: ${detail}.`));
+            return;
+        }
         if (reviewerError && (text.trim() === "" || jsonBlocks.length === 0)) {
             findingsByReviewer[index]?.push(insufficientEvidenceFinding(info, `Reviewer failed: ${reviewerError}`));
             return;
@@ -253,7 +327,7 @@ ${runtimePrompt}
             findingsByReviewer[index]?.push(insufficientEvidenceFinding(info, "Reviewer produced no parseable JSON findings."));
             return;
         }
-        const parsed = parseFindingsDetailed(text, info);
+        const parsed = sealedParse ?? parseFindingsDetailed(text, info);
         const parseError = {};
         let parsedFindingsRecorded = false;
         const recordParsedFindings = () => {
@@ -262,7 +336,7 @@ ${runtimePrompt}
             findingsByReviewer[index]?.push(...parsed.findings);
             parsedFindingsRecorded = true;
         };
-        if (parsed.malformed > 0) {
+        if (parsed.malformed > 0 && !sealedParse?.error) {
             Object.assign(parseError, {
                 error: "malformed_findings",
                 malformed: parsed.malformed,
@@ -342,7 +416,7 @@ ${runtimePrompt}
         await cleanupTemporaryReviewerWorkspaceBaseDir(reviewerWorkspaceBaseDir, artifactsBaseDir);
     }
 }
-async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPolicy, artifact, onReviewerEvent, signal) {
+async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPolicy, artifact, onReviewerEvent, signal, sealed = false) {
     const controller = new AbortController();
     spec.extra["abortSignal"] = controller.signal;
     const startMs = Date.now();
@@ -371,6 +445,8 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
     let observedSource = "unavailable";
     let observedAuthMode = null;
     let currentAuthMode = null;
+    const observedAuthModes = new Set();
+    const ignoredSettings = new Set();
     let costUsd = 0;
     let costEstimated = false;
     let cashUsd = 0;
@@ -390,9 +466,20 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
         let lastError = null;
         let attemptObservedModel;
         let attemptObservedSource = "unavailable";
+        const sealedMessageEvents = [];
         for await (const ev of iter) {
             const eventTime = nowIso();
-            appendLine(artifact.eventsPath, JSON.stringify(redactValue(ev)));
+            const persistedEvent = redactValue(ev);
+            appendLine(artifact.eventsPath, JSON.stringify(persistedEvent));
+            const ignored = ev.payload?.["ignored_settings"];
+            if (Array.isArray(ignored)) {
+                for (const item of ignored)
+                    if (typeof item === "string")
+                        ignoredSettings.add(item);
+                if (ignoredSettings.size > 0) {
+                    updateReviewerMetadata(artifact, { ignored_settings: [...ignoredSettings] });
+                }
+            }
             if (ev.transient)
                 sawTransient = true;
             if (ev.type === "error") {
@@ -413,8 +500,11 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
                 });
             }
             const disclosedAuthMode = reviewerAuthMode(ev.credential_route);
-            if (disclosedAuthMode)
+            if (disclosedAuthMode) {
                 currentAuthMode = disclosedAuthMode;
+                observedAuthModes.add(disclosedAuthMode);
+                updateReviewerMetadata(artifact, { auth_modes: [...observedAuthModes] });
+            }
             costKnowledge.observeEvent(currentAuthMode);
             if (!observedAuthMode) {
                 observedAuthMode = disclosedAuthMode;
@@ -454,11 +544,24 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
                     unknown_usd: unknownUsd,
                 });
             }
+            if (sealed && ev.type === "message" && ev.final === true) {
+                sealedMessageEvents.push(persistedEvent);
+            }
             if (ev.type === "message" && ev.text && ev.payload?.["auth_switched"] !== true) {
-                const safeText = redactSecrets(ev.text);
-                text += safeText + "\n";
-                partialText += safeText + "\n";
-                appendLine(artifact.transcriptPath, safeText);
+                const safeText = sealedReviewTranscriptChunk(persistedEvent);
+                if (safeText !== null) {
+                    if (sealed) {
+                        // Keep the long-running transcript visibly active for monitors. A
+                        // clean completion replaces these progress bytes with the exact
+                        // typed-final projection used by the sealed parser and sealer.
+                        appendLine(artifact.transcriptPath, safeText);
+                    }
+                    else {
+                        text += safeText;
+                        partialText += safeText;
+                        appendLine(artifact.transcriptPath, safeText);
+                    }
+                }
             }
             if (ev.observed_model) {
                 observedModel = ev.observed_model;
@@ -478,6 +581,17 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
         if (isCancelled()) {
             throw new Error("Reviewer cancelled");
         }
+        let sealedProjectionError;
+        if (sealed) {
+            try {
+                text = sealedReviewTranscriptFromEvents(sealedMessageEvents);
+                partialText = text;
+                writeText(artifact.transcriptPath, text);
+            }
+            catch (error) {
+                sealedProjectionError = error instanceof Error ? error.message : String(error);
+            }
+        }
         if (sawTransient &&
             text.trim() === "" &&
             nativeTry < transientRetryPolicy.maxRetries &&
@@ -511,7 +625,9 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
             return consumeOnce(nativeTry + 1);
         }
         if (sawError && !timedOut) {
-            throw new Error(`Reviewer emitted error event: ${lastError ?? "unknown error"}`);
+            throw Object.assign(new Error(`Reviewer emitted error event: ${lastError ?? "unknown error"}`), {
+                ...(sealedProjectionError ? { partialSealedProjectionError: sealedProjectionError } : {}),
+            });
         }
         if (!timedOut && !isCancelled()) {
             const completedTime = nowIso();
@@ -537,6 +653,7 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
         costKnowledge.finishAttempt();
         return {
             text,
+            ...(sealedProjectionError ? { sealedProjectionError } : {}),
             observedModel: attemptObservedModel,
             observedSource: attemptObservedSource,
             costUsd,
@@ -670,126 +787,6 @@ async function collectReviewerOutput(reviewer, spec, timeoutMs, transientRetryPo
         });
     }
 }
-function selectReviewerWorkspaceBaseDir(sourceRoot, artifactsBaseDir, sourceEvidenceDir) {
-    const durableBase = join(artifactsBaseDir, "workspaces");
-    if (!isSameOrInside(sourceRoot, durableBase) && !isSameOrInside(sourceEvidenceDir, durableBase)) {
-        return durableBase;
-    }
-    return join(tmpdir(), `claudexor-review-workspaces-${newId("ws")}`);
-}
-function isTemporaryReviewerWorkspaceBaseDir(baseDir) {
-    const resolved = resolve(baseDir);
-    const rel = relative(tmpdir(), resolved);
-    return (isSameOrInside(tmpdir(), resolved) &&
-        rel.split(/[\\/]+/)[0]?.startsWith("claudexor-review-workspaces-") === true);
-}
-async function prepareReviewerWorkspace(input) {
-    const sourceRoot = resolve(input.sourceRoot);
-    const workspaceBaseDir = resolve(input.workspaceBaseDir);
-    const root = join(workspaceBaseDir, input.reviewerDirName);
-    if (!existsSync(sourceRoot)) {
-        throw new Error(`candidate root does not exist: ${sourceRoot}`);
-    }
-    if (isSameOrInside(sourceRoot, root)) {
-        throw new Error(`reviewer workspace must be outside candidate root: ${root}`);
-    }
-    try {
-        await rm(root, { recursive: true, force: true });
-        await mkdir(root, { recursive: true, mode: 0o700 });
-        const excludeRoots = input.excludeRoots.map((p) => resolve(p));
-        const resolvedSourceRoot = realpathSync(sourceRoot);
-        await cp(sourceRoot, root, {
-            recursive: true,
-            dereference: false,
-            filter: (sourcePath) => shouldCopyReviewerPath(sourceRoot, resolvedSourceRoot, sourcePath, excludeRoots, input.preservePaths),
-        });
-        const sourceEvidenceDir = resolve(input.sourceEvidenceDir);
-        const evidenceDir = join(root, ".claudexor-review-evidence");
-        if (existsSync(sourceEvidenceDir)) {
-            const resolvedSourceEvidenceDir = realpathSync(sourceEvidenceDir);
-            const evidenceExcludeRoots = excludeRoots.filter((root) => !isSameOrInside(root, sourceEvidenceDir));
-            await rm(evidenceDir, { recursive: true, force: true });
-            await cp(sourceEvidenceDir, evidenceDir, input.preserveEvidenceBytes
-                ? { recursive: true, dereference: false }
-                : {
-                    recursive: true,
-                    dereference: false,
-                    filter: (sourcePath) => shouldCopyReviewerPath(sourceEvidenceDir, resolvedSourceEvidenceDir, sourcePath, evidenceExcludeRoots),
-                });
-        }
-        await mkdir(evidenceDir, { recursive: true, mode: 0o700 });
-        await initializeReviewerWorkspaceGit(root);
-        return { root, evidenceDir };
-    }
-    catch (err) {
-        await rm(root, { recursive: true, force: true });
-        throw err;
-    }
-}
-async function copyReviewEvidencePacket(sourceEvidenceDir, persistentEvidenceDir, preserveBytes = false) {
-    const source = resolve(sourceEvidenceDir);
-    const target = resolve(persistentEvidenceDir);
-    await rm(target, { recursive: true, force: true });
-    if (!existsSync(source)) {
-        await mkdir(target, { recursive: true, mode: 0o700 });
-        return;
-    }
-    if (preserveBytes) {
-        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-        await cp(source, target, { recursive: true, dereference: false });
-        return;
-    }
-    await mkdir(target, { recursive: true, mode: 0o700 });
-    const resolvedSource = realpathSync(source);
-    for (const entry of await readdir(source, { withFileTypes: true })) {
-        const sourcePath = join(source, entry.name);
-        if (!shouldCopyEvidencePacketPath(source, resolvedSource, sourcePath, target)) {
-            continue;
-        }
-        await copyReviewEvidenceEntry(source, resolvedSource, sourcePath, join(target, entry.name), target);
-    }
-}
-async function copyReviewEvidenceEntry(sourceEvidenceDir, resolvedSourceEvidenceDir, sourcePath, targetPath, targetEvidenceDir) {
-    const stat = lstatSync(sourcePath);
-    if (stat.isDirectory()) {
-        await mkdir(targetPath, { recursive: true, mode: 0o700 });
-        for (const entry of await readdir(sourcePath, { withFileTypes: true })) {
-            const childSource = join(sourcePath, entry.name);
-            if (!shouldCopyEvidencePacketPath(sourceEvidenceDir, resolvedSourceEvidenceDir, childSource, targetEvidenceDir)) {
-                continue;
-            }
-            await copyReviewEvidenceEntry(sourceEvidenceDir, resolvedSourceEvidenceDir, childSource, join(targetPath, entry.name), targetEvidenceDir);
-        }
-        return;
-    }
-    if (stat.isFile() && shouldTextSanitizeEvidenceFile(sourcePath)) {
-        const raw = readTextSafe(sourcePath);
-        if (raw === null)
-            throw new Error(`could not read review evidence file: ${sourcePath}`);
-        const text = shouldFailClosedEvidenceFile(sourcePath) ? raw : redactSecrets(raw);
-        if (containsSecretLikeToken(text)) {
-            throw new Error(`review evidence file contains a secret-like token: ${relative(sourceEvidenceDir, sourcePath)}`);
-        }
-        writeText(targetPath, text);
-        return;
-    }
-    await mkdir(dirname(targetPath), { recursive: true, mode: 0o700 });
-    await cp(sourcePath, targetPath, { recursive: false, dereference: false });
-}
-function shouldTextSanitizeEvidenceFile(path) {
-    return TEXT_EVIDENCE_SUFFIXES.some((extension) => path.toLowerCase().endsWith(extension));
-}
-function shouldFailClosedEvidenceFile(path) {
-    return path.toLowerCase().endsWith(".patch");
-}
-function shouldCopyEvidencePacketPath(sourceEvidenceDir, resolvedSourceEvidenceDir, sourcePath, targetEvidenceDir) {
-    const resolvedSourcePath = resolve(sourcePath);
-    if (isSameOrInside(resolvedSourcePath, targetEvidenceDir))
-        return false;
-    if (isSameOrInside(targetEvidenceDir, resolvedSourcePath))
-        return false;
-    return shouldCopyReviewerPath(sourceEvidenceDir, resolvedSourceEvidenceDir, resolvedSourcePath, [targetEvidenceDir], new Set(), false);
-}
 async function cleanupReviewerWorkspace(workspace, artifact) {
     try {
         await rm(workspace.root, { recursive: true, force: true });
@@ -802,188 +799,6 @@ async function cleanupReviewerWorkspace(workspace, artifact) {
         });
     }
 }
-async function cleanupTemporaryReviewerWorkspaceBaseDir(workspaceBaseDir, artifactsBaseDir) {
-    if (!isTemporaryReviewerWorkspaceBaseDir(workspaceBaseDir))
-        return;
-    try {
-        await rm(workspaceBaseDir, { recursive: true, force: true });
-    }
-    catch (err) {
-        try {
-            writeJson(join(artifactsBaseDir, "reviewer-workspace-base-cleanup-error.json"), {
-                reviewer_workspace_base_cleanup: "failed",
-                workspace_base_dir: workspaceBaseDir,
-                error: redactSecrets(err instanceof Error ? err.message : String(err)),
-            });
-        }
-        catch {
-            // Do not let cleanup telemetry hide the review result or the original error.
-        }
-    }
-}
-function shouldCopyReviewerPath(sourceRoot, resolvedSourceRoot, sourcePath, excludeRoots, preservePaths = new Set(), enforceContentPolicy = true) {
-    const resolvedSourcePath = resolve(sourcePath);
-    if (!isCopyableReviewerSymlink(sourceRoot, resolvedSourceRoot, resolvedSourcePath, excludeRoots)) {
-        return false;
-    }
-    if (excludeRoots.some((root) => isSameOrInside(root, resolvedSourcePath)))
-        return false;
-    const rel = relative(sourceRoot, resolvedSourcePath);
-    if (!rel)
-        return true;
-    const parts = rel.split(/[\\/]+/);
-    if (sensitiveResourcePolicy.classifyPath(rel).sensitive) {
-        return false;
-    }
-    if (parts[0] === ".claudexor") {
-        return (isCopyableReviewerClaudexorPath(rel, parts, preservePaths) &&
-            (!enforceContentPolicy || reviewerFileContentAllowed(resolvedSourcePath)));
-    }
-    if (parts.some((part) => [".git", ".adversarial-review", ".turbo", "node_modules"].includes(part))) {
-        return false;
-    }
-    if (parts.some((part) => [".next", ".cache", "coverage", "dist"].includes(part)) &&
-        !isPreservedReviewerPath(rel, preservePaths)) {
-        return false;
-    }
-    return (!rel.endsWith(".tsbuildinfo") &&
-        (!enforceContentPolicy || reviewerFileContentAllowed(resolvedSourcePath)));
-}
-function reviewerFileContentAllowed(path) {
-    let targetStat;
-    try {
-        targetStat = statSync(path);
-    }
-    catch {
-        return false;
-    }
-    if (!targetStat.isFile())
-        return true;
-    const content = readTextSafe(path);
-    return content !== null && !sensitiveResourcePolicy.containsSensitiveContent(content);
-}
-function isCopyableReviewerClaudexorPath(rel, parts, preservePaths) {
-    if (parts.length === 1) {
-        return true;
-    }
-    if (parts.length === 2 && parts[1] === "config.yaml") {
-        return true;
-    }
-    const runtimeRoot = parts[1]?.toLowerCase();
-    if (runtimeRoot && BLOCKED_REVIEWER_RUNTIME_ROOTS.has(runtimeRoot))
-        return false;
-    return isPreservedReviewerPath(rel, preservePaths);
-}
-function isPreservedReviewerPath(rel, preservePaths) {
-    const normalized = normalizeReviewerRelativePath(rel);
-    if (!normalized)
-        return false;
-    if (preservePaths.has(normalized))
-        return true;
-    const prefix = `${normalized}/`;
-    for (const preserved of preservePaths) {
-        if (preserved.startsWith(prefix))
-            return true;
-    }
-    return false;
-}
-export function __testExtractDiffTouchedPaths(diff) {
-    return extractDiffTouchedPaths(diff);
-}
-function extractDiffTouchedPaths(diff) {
-    const paths = new Set();
-    for (const file of parseUnifiedDiff(diff).files) {
-        if (file.oldPath)
-            addReviewerPreservePath(paths, file.oldPath);
-        if (file.newPath)
-            addReviewerPreservePath(paths, file.newPath);
-    }
-    return paths;
-}
-function addReviewerPreservePath(paths, value) {
-    const normalized = normalizeReviewerRelativePath(value);
-    if (normalized)
-        paths.add(normalized);
-}
-function normalizeReviewerRelativePath(value) {
-    if (!value || value === "/dev/null" || isAbsolute(value))
-        return null;
-    const normalized = normalize(value).replace(/\\/g, "/");
-    if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) {
-        return null;
-    }
-    return normalized;
-}
-function isCopyableReviewerSymlink(sourceRoot, resolvedSourceRoot, sourcePath, excludeRoots) {
-    let stat;
-    try {
-        stat = lstatSync(sourcePath);
-    }
-    catch {
-        return false;
-    }
-    if (!stat.isSymbolicLink())
-        return true;
-    let linkTarget = "";
-    let resolvedTarget = "";
-    let targetKind = "other";
-    try {
-        linkTarget = readlinkSync(sourcePath);
-        resolvedTarget = realpathSync(sourcePath);
-        const targetStat = statSync(sourcePath);
-        targetKind = targetStat.isDirectory() ? "directory" : targetStat.isFile() ? "file" : "other";
-    }
-    catch {
-        return false;
-    }
-    return sensitiveResourcePolicy.assessSymlink({
-        sourceRoot,
-        canonicalSourceRoot: resolvedSourceRoot,
-        sourcePath,
-        linkTarget,
-        resolvedTargetPath: resolvedTarget,
-        targetKind,
-        allowedTargetKinds: ["file", "directory"],
-        excludedRoots: excludeRoots,
-        relocationRoot: sourceRoot,
-    }).allowed;
-}
-async function initializeReviewerWorkspaceGit(root) {
-    const noHooks = ["-c", "core.hooksPath=/dev/null"];
-    await runGitOrThrow("init", root, ["-c", "init.templateDir=", ...noHooks, "init"]);
-    for (const [key, value] of [
-        ["user.email", "claudexor-review@example.invalid"],
-        ["user.name", "Claudexor Review"],
-    ]) {
-        await runGitOrThrow(`config ${key}`, root, [...noHooks, "config", key, value]);
-    }
-    await runGitOrThrow("add", root, [...noHooks, "add", "-A", "--force"]);
-    await runGitOrThrow("commit", root, [
-        ...noHooks,
-        "commit",
-        "--allow-empty",
-        "--no-verify",
-        "--no-gpg-sign",
-        "-m",
-        "review baseline",
-    ]);
-}
-async function runGitOrThrow(label, cwd, args) {
-    const gitEnv = Object.fromEntries(Object.keys(process.env)
-        .filter((key) => key.startsWith("GIT_"))
-        .map((key) => [key, null]));
-    gitEnv.GIT_CONFIG_NOSYSTEM = "1";
-    const result = await runCapture("git", args, { cwd, env: gitEnv, timeoutMs: 60_000 });
-    if (result.code === 0)
-        return;
-    const detail = redactSecrets((result.stderr || result.stdout || `exit ${result.code}`).trim());
-    throw new Error(`failed to prepare reviewer workspace (${label}): ${detail}`);
-}
-function isSameOrInside(parent, target) {
-    const rel = relative(resolve(parent), resolve(target));
-    const firstPart = rel.split(/[\\/]+/)[0];
-    return rel === "" || (!!rel && firstPart !== ".." && !isAbsolute(rel));
-}
 function createReviewerArtifactContext(baseDir, index, reviewer) {
     const dir = join(baseDir, `${String(index + 1).padStart(2, "0")}-${safeFilePart(reviewer.adapter.id)}`);
     ensureDir(dir);
@@ -1012,8 +827,11 @@ function createReviewerArtifactContext(baseDir, index, reviewer) {
     return ctx;
 }
 function safeFilePart(value) {
-    const safe = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-    return safe || "reviewer";
+    const safe = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+/, "");
+    let end = safe.length;
+    while (end > 0 && safe[end - 1] === "-")
+        end -= 1;
+    return safe.slice(0, end) || "reviewer";
 }
 function emitReviewerProgress(artifact, reviewer, onReviewerEvent, patch) {
     const event = {