@akagilnc/pi-workflow-roles 0.1.1774 → 0.1.1792

package/dist/public-cli/main.js

@@ -16718,13 +16718,149 @@ var init_invocation = __esm({
   }
 });
 
+// src/reviewer-git-snapshot.ts
+var init_reviewer_git_snapshot = __esm({
+  "src/reviewer-git-snapshot.ts"() {
+    "use strict";
+  }
+});
+
+// src/reviewer-preflight-error.ts
+var init_reviewer_preflight_error = __esm({
+  "src/reviewer-preflight-error.ts"() {
+    "use strict";
+  }
+});
+
+// src/reviewer-pinned-git.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2;
+var init_reviewer_pinned_git = __esm({
+  "src/reviewer-pinned-git.ts"() {
+    "use strict";
+    init_reviewer_git_snapshot();
+    init_sha256();
+    init_reviewer_preflight_error();
+    execFileAsync2 = promisify2(execFile2);
+  }
+});
+
+// src/reviewer-prompt-identity.ts
+var init_reviewer_prompt_identity = __esm({
+  "src/reviewer-prompt-identity.ts"() {
+    "use strict";
+  }
+});
+
+// src/reviewer-scope-prompt.ts
+var init_reviewer_scope_prompt = __esm({
+  "src/reviewer-scope-prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/reviewer-construction.ts
+var REVIEWER_CONSTRUCTION_RECIPE, REVIEWER_AXIS_OUTPUT_ADAPTER, REVIEWER_STANDARDS_CONCLUSION_KEYS, REVIEWER_STANDARDS_CONCLUSION_LABELS;
+var init_reviewer_construction = __esm({
+  "src/reviewer-construction.ts"() {
+    "use strict";
+    init_sha256();
+    init_reviewer_scope_prompt();
+    REVIEWER_CONSTRUCTION_RECIPE = Object.freeze({
+      recipeId: "reviewer-common-bundle",
+      version: 1,
+      runtimeVersion: "1",
+      implementationSha256: sha256Hex("reviewer-common-bundle:v1:direct-text-prompts")
+    });
+    REVIEWER_AXIS_OUTPUT_ADAPTER = Object.freeze({
+      adapterId: "reviewer-axis-output",
+      version: 1,
+      implementationSha256: sha256Hex("reviewer-axis-output:v1:single-axis-verbatim-report+standards-three-priorities")
+    });
+    REVIEWER_STANDARDS_CONCLUSION_KEYS = Object.freeze([
+      "constitutionality",
+      "minimum-necessary-test-cost",
+      "complexity"
+    ]);
+    REVIEWER_STANDARDS_CONCLUSION_LABELS = Object.freeze({
+      constitutionality: "constitutionality",
+      "minimum-necessary-test-cost": "minimum-necessary test cost",
+      complexity: "complexity"
+    });
+  }
+});
+
+// src/reviewer-dispatch.ts
+var REVIEWER_PREFLIGHT_VIOLATIONS;
+var init_reviewer_dispatch = __esm({
+  "src/reviewer-dispatch.ts"() {
+    "use strict";
+    init_reviewer_git_snapshot();
+    init_reviewer_pinned_git();
+    init_reviewer_pinned_git();
+    init_reviewer_prompt_identity();
+    init_sha256();
+    init_reviewer_construction();
+    init_reviewer_preflight_error();
+    init_sha256();
+    init_reviewer_prompt_identity();
+    REVIEWER_PREFLIGHT_VIOLATIONS = ["base-invalid", "range-invalid", "prompt-identity-invalid", "target-drift"];
+  }
+});
+
 // src/public-cli/explicit-internal.ts
-import { execFile as execFile2, spawn } from "node:child_process";
-import { constants } from "node:fs";
-import { access, realpath as realpath3 } from "node:fs/promises";
+import { execFile as execFile3, spawn } from "node:child_process";
+import { constants, writeFileSync } from "node:fs";
+import { access, readFile as readFile5, realpath as realpath3, unlink } from "node:fs/promises";
 import { delimiter as delimiter2, isAbsolute as isAbsolute4, join as join5, resolve as resolve5 } from "node:path";
 import { platform } from "node:process";
-import { promisify as promisify2 } from "node:util";
+import { promisify as promisify3 } from "node:util";
+function isReviewerPreflightViolation(value) {
+  return typeof value === "string" && REVIEWER_PREFLIGHT_VIOLATIONS.includes(value);
+}
+function reviewerDispatchRejectionPath(runDirectory) {
+  return join5(runDirectory, REVIEWER_DISPATCH_REJECTION_FILE);
+}
+async function clearReviewerDispatchRejection(runDirectory) {
+  try {
+    await unlink(reviewerDispatchRejectionPath(runDirectory));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+async function readReviewerDispatchRejection(runDirectory) {
+  let raw;
+  try {
+    raw = await readFile5(reviewerDispatchRejectionPath(runDirectory), "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    const error = new Error("Reviewer dispatch rejection page must be a JSON object");
+    error.name = "ReviewerDispatchRejectionContractError";
+    throw error;
+  }
+  const record4 = parsed;
+  if (typeof record4.diagnostic !== "string" || record4.diagnostic.trim() === "" || !Array.isArray(record4.violations) || record4.violations.length === 0 || record4.violations.some((value) => !isReviewerPreflightViolation(value))) {
+    const error = new Error("Reviewer dispatch rejection page has unusable required fields");
+    error.name = "ReviewerDispatchRejectionContractError";
+    throw error;
+  }
+  return {
+    cause: "activation",
+    diagnostic: record4.diagnostic,
+    identity: { name: "ReviewerDispatchRejectionError" },
+    details: { violations: Object.freeze([...record4.violations]) }
+  };
+}
 function resolveInternalRoleEntrypoint(packageRoot2) {
   return join5(packageRoot2, INTERNAL_ROLE_ENTRYPOINT_RELATIVE);
 }
@@ -16765,7 +16901,7 @@ async function resolveSelectedPi(command, cwd, env) {
 }
 async function selectedPiIdentity(command, cwd, env) {
   const executable = await resolveSelectedPi(command, cwd, env);
-  const { stdout } = await execFileAsync2(executable, ["--version"], {
+  const { stdout } = await execFileAsync3(executable, ["--version"], {
     cwd,
     env,
     encoding: "utf8"
@@ -16802,13 +16938,15 @@ async function runExplicitInternalActivation(options) {
     env
   });
 }
-var execFileAsync2, defaultExplicitInternalPiRunner;
+var REVIEWER_DISPATCH_REJECTION_FILE, execFileAsync3, defaultExplicitInternalPiRunner;
 var init_explicit_internal = __esm({
   "src/public-cli/explicit-internal.ts"() {
     "use strict";
     init_invocation();
     init_registry2();
-    execFileAsync2 = promisify2(execFile2);
+    init_reviewer_dispatch();
+    REVIEWER_DISPATCH_REJECTION_FILE = "typed-known-failure.json";
+    execFileAsync3 = promisify3(execFile3);
     defaultExplicitInternalPiRunner = async (args, options) => {
       const command = options.env.PI_BINARY ?? "pi";
       const piIdentity = await selectedPiIdentity(command, options.cwd, options.env);
@@ -16863,7 +17001,7 @@ var init_explicit_internal = __esm({
 
 // src/package-resources/method-skill.ts
 import { createHash as createHash3 } from "node:crypto";
-import { readFile as readFile5, realpath as realpath4 } from "node:fs/promises";
+import { readFile as readFile6, realpath as realpath4 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 function gitBlobOid(bytes) {
   const body = typeof bytes === "string" ? Buffer.from(bytes, "utf8") : Buffer.from(bytes);
@@ -16982,7 +17120,7 @@ async function loadPackagedMethodSkillMaterial(packageRoot2, name) {
   const provenancePath = join6(rootDirectory, "provenance.json");
   let provenanceRaw;
   try {
-    provenanceRaw = await readFile5(provenancePath, "utf8");
+    provenanceRaw = await readFile6(provenancePath, "utf8");
   } catch (error) {
     throw new PackagedMethodSkillUnavailableError(name, provenancePath, error);
   }
@@ -16999,7 +17137,7 @@ async function loadPackagedMethodSkillMaterial(packageRoot2, name) {
     const absolute = join6(rootDirectory, rel);
     let bytes;
     try {
-      bytes = await readFile5(absolute);
+      bytes = await readFile6(absolute);
     } catch (error) {
       throw new PackagedMethodSkillUnavailableError(name, absolute, error);
     }
@@ -17015,7 +17153,7 @@ async function loadPackagedMethodSkillMaterial(packageRoot2, name) {
   let raw;
   try {
     skillPath = await realpath4(skillPathConfigured);
-    raw = await readFile5(skillPath, "utf8");
+    raw = await readFile6(skillPath, "utf8");
   } catch (error) {
     throw new PackagedMethodSkillUnavailableError(name, skillPathConfigured, error);
   }
@@ -17130,7 +17268,7 @@ var init_public_run_credentials = __esm({
 });
 
 // src/public-cli/run-lifecycle.ts
-import { lstat as lstat2, open, readdir as readdir2, readFile as readFile6, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { lstat as lstat2, open, readdir as readdir2, readFile as readFile7, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 function isV1ResumableProvider(provider) {
   return V1_RESUMABLE_PROVIDERS.includes(provider);
@@ -17140,7 +17278,7 @@ function typedProviderHttpPath(runDirectory) {
 }
 async function clearTypedProviderHttpObservation(runDirectory) {
   try {
-    await unlink(typedProviderHttpPath(runDirectory));
+    await unlink2(typedProviderHttpPath(runDirectory));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return;
@@ -17151,7 +17289,7 @@ async function clearTypedProviderHttpObservation(runDirectory) {
 async function readTypedHttp429Observation(runDirectory) {
   try {
     const raw = JSON.parse(
-      await readFile6(typedProviderHttpPath(runDirectory), "utf8")
+      await readFile7(typedProviderHttpPath(runDirectory), "utf8")
     );
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
       return void 0;
@@ -17184,7 +17322,7 @@ async function writeRoleRunState(runDirectory, record4) {
 async function readRoleRunState(runDirectory) {
   try {
     const raw = JSON.parse(
-      await readFile6(join7(runDirectory, RUN_STATE_FILE), "utf8")
+      await readFile7(join7(runDirectory, RUN_STATE_FILE), "utf8")
     );
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
       return void 0;
@@ -17308,7 +17446,7 @@ async function acquireRunWriterLease(runDirectory) {
 `, "utf8");
     } catch (error) {
       await handle.close().catch(() => void 0);
-      await unlink(lockPath).catch(() => void 0);
+      await unlink2(lockPath).catch(() => void 0);
       throw error;
     }
     let released = false;
@@ -17318,7 +17456,7 @@ async function acquireRunWriterLease(runDirectory) {
         if (released) return;
         released = true;
         await handle.close().catch(() => void 0);
-        await unlink(lockPath).catch(() => void 0);
+        await unlink2(lockPath).catch(() => void 0);
       }
     };
   } catch (error) {
@@ -17387,7 +17525,7 @@ async function loadResumableRunRecord(home, runId) {
   let derived;
   try {
     const raw = JSON.parse(
-      await readFile6(run.admittedRequestPath, "utf8")
+      await readFile7(run.admittedRequestPath, "utf8")
     );
     if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
       const record4 = raw;
@@ -18293,7 +18431,7 @@ var init_terminal = __esm({
 
 // src/public-cli/settlement.ts
 import { randomUUID } from "node:crypto";
-import { lstat as lstat3, mkdir as mkdir3, open as open2, readFile as readFile7, readdir as readdir3, writeFile as writeFile4 } from "node:fs/promises";
+import { lstat as lstat3, mkdir as mkdir3, open as open2, readFile as readFile8, readdir as readdir3, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname6, join as join8 } from "node:path";
 function isChildDiagnosticFloodLine(line2) {
   if (/^at\s+/.test(line2)) return true;
@@ -18349,7 +18487,7 @@ function presentStructuralRejection(error, io) {
 }
 async function inspectJudgeSession(sessionFile) {
   try {
-    await readFile7(sessionFile, "utf8");
+    await readFile8(sessionFile, "utf8");
     return { state: "present" };
   } catch (error) {
     if (isMissingPathError2(error)) return { state: "missing" };
@@ -18385,8 +18523,7 @@ function classifyPostAdmissionFailure(input) {
       return {
         cause: error.knownCause,
         diagnostic: error.message || error.name || "unrecognized exception",
-        identity,
-        ...error.details === void 0 ? {} : { details: error.details }
+        identity
       };
     }
     if (error instanceof Error) {
@@ -18490,7 +18627,7 @@ function sessionReadFailure(error, fallbackMessage) {
   return failed;
 }
 async function readBoundSessionEntries(sessionFile) {
-  const text = await readFile7(sessionFile, "utf8");
+  const text = await readFile8(sessionFile, "utf8");
   const entries = [];
   for (const line2 of text.trim().split("\n").filter(Boolean)) {
     try {
@@ -18678,6 +18815,19 @@ function typedFailedTerminatingToolKnownFailure(entries) {
 }
 async function resolveAuditedRunnerKnownFailure(input) {
   if (input.runner !== void 0) return input.runner;
+  if (input.runDirectory !== void 0) {
+    try {
+      const rejection = await readReviewerDispatchRejection(input.runDirectory);
+      if (rejection !== void 0) return rejection;
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      return {
+        cause: "activation",
+        identity: thrownIdentity(failure),
+        diagnostic: failure.message || failure.name
+      };
+    }
+  }
   try {
     const auditorFailure = await readBoundAuditorKnownFailure(input.sessionFile);
     if (auditorFailure !== void 0) return auditorFailure;
@@ -22897,6 +23047,7 @@ async function dispatchAdmittedReviewer(input) {
     }
     await markRunRunning(admitted.runDirectory);
     await clearTypedProviderHttpObservation(admitted.runDirectory);
+    await clearReviewerDispatchRejection(admitted.runDirectory);
     const childEnv = {
       ...process.env,
       HOME: env.home,
@@ -22991,7 +23142,8 @@ async function dispatchAdmittedReviewer(input) {
     const knownFailure = await resolveAuditedRunnerKnownFailure({
       runner: result2.knownFailure,
       sessionFile: admitted.sessionFile,
-      credential: credentialFailure
+      credential: credentialFailure,
+      runDirectory: admitted.runDirectory
     });
     return await presentControlledFailure7(
       admitted,

package/dist/reviewer-git-snapshot.js

@@ -28,11 +28,5 @@ export function immutableReviewerRefs(refs) {
 }
 export function sameReviewerPinnedTarget(actual, expected) {
     return actual.repositoryRoot === expected.repositoryRoot && actual.objectFormat === expected.objectFormat &&
-        actual.targetHead === expected.targetHead && sameReviewerRefs(actual.refs, expected.refs);
-}
-export function sameReviewerRefs(actual, expected) {
-    const actualEntries = Object.entries(actual).sort(([left], [right]) => left.localeCompare(right));
-    const expectedEntries = Object.entries(expected).sort(([left], [right]) => left.localeCompare(right));
-    return actualEntries.length === expectedEntries.length && actualEntries.every(([name, value], index) => name === expectedEntries[index]?.[0] && value.objectId === expectedEntries[index]?.[1].objectId &&
-        value.peeledCommitId === expectedEntries[index]?.[1].peeledCommitId);
+        actual.targetHead === expected.targetHead;
 }

package/dist/reviewer-workspace.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { parseReviewerRefSnapshot, reviewerRefSnapshotArgs, sameReviewerPinnedTarget, sameReviewerRefs } from "./reviewer-git-snapshot.js";
+import { sameReviewerPinnedTarget } from "./reviewer-git-snapshot.js";
 export class ReviewerProcessError extends Error {
     command;
     args;
@@ -44,20 +44,13 @@ async function runCommand(command, args, options = {}) {
     });
 }
 async function git(cwd, args, signal, allowedCodes) { return runCommand("git", ["-C", cwd, ...args], { ...(signal === undefined ? {} : { signal }), ...(allowedCodes === undefined ? {} : { allowedCodes }) }); }
-async function readRefs(cwd, signal) { return parseReviewerRefSnapshot((await git(cwd, reviewerRefSnapshotArgs(), signal)).stdout.trim()); }
 async function verifySnapshot(cwd, snapshot, signal) {
     if ((await git(cwd, ["rev-parse", "--show-object-format"], signal)).stdout.trim() !== snapshot.objectFormat)
         throw new Error("Review clone object format does not match the pinned session snapshot");
     const head = (await git(cwd, ["rev-parse", "HEAD^{commit}"], signal)).stdout.trim();
     if (head !== snapshot.targetHead)
         throw new Error(`Review clone target mismatch: expected ${snapshot.targetHead}, got ${head}`);
-    if (!sameReviewerRefs(await readRefs(cwd, signal), snapshot.refs))
-        throw new Error("Review clone ref map does not match the pinned session snapshot");
-    for (const entry of Object.values(snapshot.refs)) {
-        await git(cwd, ["cat-file", "-e", `${entry.objectId}^{object}`], signal);
-        if (entry.peeledCommitId !== null)
-            await git(cwd, ["cat-file", "-e", `${entry.peeledCommitId}^{commit}`], signal);
-    }
+    await git(cwd, ["cat-file", "-e", `${snapshot.targetHead}^{commit}`], signal);
 }
 function workspaceError(error, failure, disposition, target) {
     const wrapped = error instanceof Error ? error : new Error(String(error), { cause: error });
@@ -68,31 +61,20 @@ async function prepareSnapshot(accepted, signal, dependencies) {
     try {
         dependencies.fault?.("snapshot.head");
         const objectFormat = (await git(accepted.repositoryRoot, ["rev-parse", "--show-object-format"], signal)).stdout.trim();
-        if (objectFormat !== accepted.objectFormat)
-            throw new Error("Accepted Reviewer object format no longer matches the repository");
         const targetHead = (await git(accepted.repositoryRoot, ["rev-parse", "HEAD^{commit}"], signal)).stdout.trim();
-        dependencies.fault?.("snapshot.refs");
-        const refs = await readRefs(accepted.repositoryRoot, signal);
-        if (!sameReviewerPinnedTarget({ repositoryRoot: accepted.repositoryRoot, objectFormat: accepted.objectFormat, targetHead, refs }, accepted))
-            throw new Error("Accepted Reviewer target/ref identity no longer matches the repository");
+        if (!sameReviewerPinnedTarget({ repositoryRoot: accepted.repositoryRoot, objectFormat: objectFormat, targetHead }, accepted))
+            throw new Error("Accepted Reviewer target identity no longer matches the repository");
+        await git(accepted.repositoryRoot, ["cat-file", "-e", `${targetHead}^{commit}`], signal);
         dependencies.fault?.("mirror.before-create");
         mirrorRoot = await mkdtemp(join(tmpdir(), "ak-reviewer-snapshot-"));
         const mirrorPath = join(mirrorRoot, "repository.git");
         dependencies.fault?.("mirror.create");
-        await runCommand("git", ["clone", "--mirror", "--no-hardlinks", accepted.repositoryRoot, mirrorPath], signal === undefined ? {} : { signal });
-        const present = await git(mirrorPath, ["cat-file", "-e", `${targetHead}^{commit}`], signal, [0, 1, 128]);
-        if (present.code !== 0) {
-            await git(mirrorPath, ["fetch", "--no-tags", accepted.repositoryRoot, targetHead], signal);
-            await git(mirrorPath, ["update-ref", "refs/ak-reviewer/target", targetHead], signal);
-        }
+        await runCommand("git", ["init", "--bare", `--object-format=${accepted.objectFormat}`, mirrorPath], signal === undefined ? {} : { signal });
+        await git(mirrorPath, ["fetch", "--no-tags", accepted.repositoryRoot, targetHead], signal);
+        await git(mirrorPath, ["update-ref", "refs/ak-reviewer/target", targetHead], signal);
         dependencies.fault?.("mirror.verify");
-        if (!sameReviewerRefs(await readRefs(mirrorPath, signal), refs))
-            throw new Error("Bare review mirror ref map changed while the snapshot was prepared");
-        const objects = Object.values(refs).flatMap(e => e.peeledCommitId === null ? [e.objectId] : [e.objectId, e.peeledCommitId]);
-        for (const object of new Set([targetHead, ...objects]))
-            await git(mirrorPath, ["cat-file", "-e", `${object}^{object}`], signal);
-        await git(mirrorPath, ["config", "--remove-section", "remote.origin"], signal, [0, 5, 128]);
-        return { ...accepted, targetHead, refs, mirrorRoot, mirrorPath };
+        await git(mirrorPath, ["cat-file", "-e", `${targetHead}^{commit}`], signal);
+        return { ...accepted, targetHead, mirrorRoot, mirrorPath };
     }
     catch (error) {
         throw workspaceError(error, "snapshot", mirrorRoot === undefined ? "not-created" : { retained: mirrorRoot }, accepted);
@@ -107,8 +89,7 @@ async function prepareClone(snapshot, signal, dependencies) {
         dependencies.fault?.("workspace.init");
         await git(workspace, ["init", `--object-format=${snapshot.objectFormat}`, "--initial-branch=ak-reviewer-unborn"], signal);
         dependencies.fault?.("workspace.fetch");
-        await git(workspace, ["fetch", "--no-tags", "--force", "--update-shallow", snapshot.mirrorPath, snapshot.targetHead, "+refs/heads/*:refs/heads/*", "+refs/tags/*:refs/tags/*", "+refs/remotes/*:refs/remotes/*"], signal);
-        await git(workspace, ["config", "--remove-section", "remote.origin"], signal, [0, 5, 128]);
+        await git(workspace, ["fetch", "--no-tags", snapshot.mirrorPath, snapshot.targetHead], signal);
         await git(workspace, ["checkout", "--detach", snapshot.targetHead], signal);
         dependencies.fault?.("workspace.verify");
         await verifySnapshot(workspace, snapshot, signal);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.1774",
+  "version": "0.1.1792",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/public-cli/explicit-internal.ts

@@ -4,8 +4,8 @@
  * this adapter (or an intentional developer `pi -e`) crosses that boundary.
  */
 import { execFile, spawn } from "node:child_process";
-import { constants } from "node:fs";
-import { access, realpath } from "node:fs/promises";
+import { constants, writeFileSync } from "node:fs";
+import { access, readFile, realpath, unlink } from "node:fs/promises";
 import { delimiter, isAbsolute, join, resolve } from "node:path";
 import { platform } from "node:process";
 import { promisify } from "node:util";
@@ -16,8 +16,106 @@ import {
   recordLaunchedRolePackageIdentity,
 } from "./invocation.ts";
 import { INTERNAL_ROLE_ENTRYPOINT_RELATIVE } from "./registry.ts";
+import {
+  REVIEWER_PREFLIGHT_VIOLATIONS,
+  type ReviewerPreflightViolation,
+} from "../reviewer-dispatch.ts";
 import type { ControlledFailureCause } from "./terminal.ts";
 
+/** Durable Reviewer-rejection child→parent page under AK_ROLE_RUN_DIR. */
+const REVIEWER_DISPATCH_REJECTION_FILE = "typed-known-failure.json";
+
+function isReviewerPreflightViolation(value: unknown): value is ReviewerPreflightViolation {
+  return (
+    typeof value === "string" &&
+    (REVIEWER_PREFLIGHT_VIOLATIONS as readonly string[]).includes(value)
+  );
+}
+
+function reviewerDispatchRejectionPath(runDirectory: string): string {
+  return join(runDirectory, REVIEWER_DISPATCH_REJECTION_FILE);
+}
+
+/**
+ * Clear any prior attempt's Reviewer rejection page so resume/retry cannot
+ * inherit a stale knownFailure.details.
+ */
+export async function clearReviewerDispatchRejection(runDirectory: string): Promise<void> {
+  try {
+    await unlink(reviewerDispatchRejectionPath(runDirectory));
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      (error as { code?: unknown }).code === "ENOENT"
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Synchronous durable write for Reviewer dispatch rejection (child process exit is sync).
+ * Parent public CLI recovers via readReviewerDispatchRejection into knownFailure.
+ */
+export function recordReviewerDispatchRejectionSync(
+  runDirectory: string,
+  rejection: Readonly<{
+    diagnostic: string;
+    violations: readonly ReviewerPreflightViolation[];
+  }>,
+): void {
+  writeFileSync(
+    reviewerDispatchRejectionPath(runDirectory),
+    `${JSON.stringify(rejection)}\n`,
+    "utf8",
+  );
+}
+
+/** Recover a child-written Reviewer dispatch rejection through a fixed mapping. */
+export async function readReviewerDispatchRejection(
+  runDirectory: string,
+): Promise<ExplicitInternalKnownFailure | undefined> {
+  let raw: string;
+  try {
+    raw = await readFile(reviewerDispatchRejectionPath(runDirectory), "utf8");
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      (error as { code?: unknown }).code === "ENOENT"
+    ) {
+      return undefined;
+    }
+    throw error;
+  }
+  const parsed: unknown = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    const error = new Error("Reviewer dispatch rejection page must be a JSON object");
+    error.name = "ReviewerDispatchRejectionContractError";
+    throw error;
+  }
+  const record = parsed as Record<string, unknown>;
+  if (
+    typeof record.diagnostic !== "string" ||
+    record.diagnostic.trim() === "" ||
+    !Array.isArray(record.violations) ||
+    record.violations.length === 0 ||
+    record.violations.some((value) => !isReviewerPreflightViolation(value))
+  ) {
+    const error = new Error("Reviewer dispatch rejection page has unusable required fields");
+    error.name = "ReviewerDispatchRejectionContractError";
+    throw error;
+  }
+  return {
+    cause: "activation",
+    diagnostic: record.diagnostic,
+    identity: { name: "ReviewerDispatchRejectionError" },
+    details: { violations: Object.freeze([...record.violations]) },
+  };
+}
+
 export function resolveInternalRoleEntrypoint(packageRoot: string): string {
   return join(packageRoot, INTERNAL_ROLE_ENTRYPOINT_RELATIVE);
 }

package/src/public-cli/reviewer-run.ts

@@ -14,6 +14,7 @@ import {
   type PackagedMethodSkillProvenance,
 } from "../package-resources/method-skill.ts";
 import {
+  clearReviewerDispatchRejection,
   runExplicitInternalActivation,
   type ExplicitInternalKnownFailure,
   type ExplicitInternalPiRunner,
@@ -267,6 +268,7 @@ async function dispatchAdmittedReviewer(input: {
     }
     await markRunRunning(admitted.runDirectory);
     await clearTypedProviderHttpObservation(admitted.runDirectory);
+    await clearReviewerDispatchRejection(admitted.runDirectory);
 
     const childEnv: NodeJS.ProcessEnv = {
       ...process.env,
@@ -369,6 +371,7 @@ async function dispatchAdmittedReviewer(input: {
       runner: result.knownFailure,
       sessionFile: admitted.sessionFile,
       credential: credentialFailure,
+      runDirectory: admitted.runDirectory,
     });
     return await presentControlledFailure(
       admitted,

package/src/public-cli/settlement.ts

@@ -12,7 +12,7 @@ import { AUDITOR_SOUL_ROLES } from "../auditor-soul.ts";
 import { DOCTOR_AUDIT_TOOL_NAME } from "../doctor-auditor.ts";
 import { JUDGE_AUDIT_TOOL_NAME } from "../judge-auditor.ts";
 import { REVIEWER_AUDIT_TOOL_NAME } from "../reviewer-auditor.ts";
-import { knownFailureFromProviderStop, type ExplicitInternalKnownFailure } from "./explicit-internal.ts";
+import { knownFailureFromProviderStop, type ExplicitInternalKnownFailure, readReviewerDispatchRejection } from "./explicit-internal.ts";
 import {
   AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE,
   AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE,
@@ -338,7 +338,6 @@ export function classifyPostAdmissionFailure(input: {
         cause: error.knownCause,
         diagnostic: error.message || error.name || "unrecognized exception",
         identity,
-        ...(error.details === undefined ? {} : { details: error.details }),
       };
     }
     if (error instanceof Error) {
@@ -783,8 +782,23 @@ export async function resolveAuditedRunnerKnownFailure(input: {
   runner: ExplicitInternalKnownFailure | undefined;
   sessionFile: string;
   credential: ExplicitInternalKnownFailure | undefined;
+  /** Reviewer only: recover child-written rejection page into knownFailure.details. */
+  runDirectory?: string;
 }): Promise<ExplicitInternalKnownFailure | undefined> {
   if (input.runner !== undefined) return input.runner;
+  if (input.runDirectory !== undefined) {
+    try {
+      const rejection = await readReviewerDispatchRejection(input.runDirectory);
+      if (rejection !== undefined) return rejection;
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      return {
+        cause: "activation",
+        identity: thrownIdentity(failure),
+        diagnostic: failure.message || failure.name,
+      };
+    }
+  }
   // Bound auditor evidence outranks a parent failure that the auditor path itself
   // caused (retention EISDIR race). A typed terminating-tool host failure is next:
   // it outranks provider/credential and nonzero fallbacks, but not its recorded cause.

package/src/reviewer-git-snapshot.ts

@@ -37,17 +37,9 @@ export function immutableReviewerRefs(refs: ReviewerRefMap): ReviewerRefMap {
 }
 
 export function sameReviewerPinnedTarget(
-  actual: Readonly<{ repositoryRoot: string; objectFormat: "sha1" | "sha256"; targetHead: string; refs: ReviewerRefMap }>,
-  expected: Readonly<{ repositoryRoot: string; objectFormat: "sha1" | "sha256"; targetHead: string; refs: ReviewerRefMap }>,
+  actual: Readonly<{ repositoryRoot: string; objectFormat: "sha1" | "sha256"; targetHead: string; refs?: ReviewerRefMap }>,
+  expected: Readonly<{ repositoryRoot: string; objectFormat: "sha1" | "sha256"; targetHead: string; refs?: ReviewerRefMap }>,
 ): boolean {
   return actual.repositoryRoot === expected.repositoryRoot && actual.objectFormat === expected.objectFormat &&
-    actual.targetHead === expected.targetHead && sameReviewerRefs(actual.refs, expected.refs);
-}
-
-export function sameReviewerRefs(actual: ReviewerRefMap, expected: ReviewerRefMap): boolean {
-  const actualEntries = Object.entries(actual).sort(([left], [right]) => left.localeCompare(right));
-  const expectedEntries = Object.entries(expected).sort(([left], [right]) => left.localeCompare(right));
-  return actualEntries.length === expectedEntries.length && actualEntries.every(([name, value], index) =>
-    name === expectedEntries[index]?.[0] && value.objectId === expectedEntries[index]?.[1].objectId &&
-    value.peeledCommitId === expectedEntries[index]?.[1].peeledCommitId);
+    actual.targetHead === expected.targetHead;
 }

package/src/reviewer-workspace.ts

@@ -3,11 +3,11 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { parseReviewerRefSnapshot, reviewerRefSnapshotArgs, sameReviewerPinnedTarget, sameReviewerRefs, type ReviewerRefEntry } from "./reviewer-git-snapshot.ts";
+import { sameReviewerPinnedTarget } from "./reviewer-git-snapshot.ts";
 import type { ReviewerTargetSnapshot, ReviewerWorkspaceDisposition } from "./reviewer-execution-ledger.ts";
 
 export type ReviewerWorkspaceFaultPoint =
-  | "snapshot.head" | "snapshot.refs"
+  | "snapshot.head"
   | "mirror.before-create" | "mirror.create" | "mirror.verify"
   | "workspace.before-create" | "workspace.init" | "workspace.fetch" | "workspace.verify";
 export type ReviewerWorkspaceDependencies = Readonly<{ fault?(operation: ReviewerWorkspaceFaultPoint): void }>;
@@ -40,13 +40,11 @@ async function runCommand(command: string, args: string[], options: { cwd?: stri
   });
 }
 async function git(cwd: string, args: string[], signal?: AbortSignal, allowedCodes?: readonly number[]) { return runCommand("git", ["-C", cwd, ...args], { ...(signal === undefined ? {} : { signal }), ...(allowedCodes === undefined ? {} : { allowedCodes }) }); }
-async function readRefs(cwd: string, signal?: AbortSignal): Promise<Record<string, ReviewerRefEntry>> { return parseReviewerRefSnapshot((await git(cwd, reviewerRefSnapshotArgs(), signal)).stdout.trim()); }
 async function verifySnapshot(cwd: string, snapshot: ReviewerTargetSnapshot, signal?: AbortSignal) {
   if ((await git(cwd, ["rev-parse", "--show-object-format"], signal)).stdout.trim() !== snapshot.objectFormat) throw new Error("Review clone object format does not match the pinned session snapshot");
   const head = (await git(cwd, ["rev-parse", "HEAD^{commit}"], signal)).stdout.trim();
   if (head !== snapshot.targetHead) throw new Error(`Review clone target mismatch: expected ${snapshot.targetHead}, got ${head}`);
-  if (!sameReviewerRefs(await readRefs(cwd, signal), snapshot.refs)) throw new Error("Review clone ref map does not match the pinned session snapshot");
-  for (const entry of Object.values(snapshot.refs)) { await git(cwd, ["cat-file", "-e", `${entry.objectId}^{object}`], signal); if (entry.peeledCommitId !== null) await git(cwd, ["cat-file", "-e", `${entry.peeledCommitId}^{commit}`], signal); }
+  await git(cwd, ["cat-file", "-e", `${snapshot.targetHead}^{commit}`], signal);
 }
 function workspaceError(error: unknown, failure: "snapshot" | "workspace", disposition: ReviewerWorkspaceDisposition, target: ReviewerTargetSnapshot): ReviewerWorkspaceError {
   const wrapped = error instanceof Error ? error : new Error(String(error), { cause: error });
@@ -57,19 +55,15 @@ async function prepareSnapshot(accepted: ReviewerTargetSnapshot, signal: AbortSi
   try {
     dependencies.fault?.("snapshot.head");
     const objectFormat = (await git(accepted.repositoryRoot, ["rev-parse", "--show-object-format"], signal)).stdout.trim();
-    if (objectFormat !== accepted.objectFormat) throw new Error("Accepted Reviewer object format no longer matches the repository");
     const targetHead = (await git(accepted.repositoryRoot, ["rev-parse", "HEAD^{commit}"], signal)).stdout.trim();
-    dependencies.fault?.("snapshot.refs"); const refs = await readRefs(accepted.repositoryRoot, signal);
-    if (!sameReviewerPinnedTarget({ repositoryRoot: accepted.repositoryRoot, objectFormat: accepted.objectFormat, targetHead, refs }, accepted)) throw new Error("Accepted Reviewer target/ref identity no longer matches the repository");
+    if (!sameReviewerPinnedTarget({ repositoryRoot: accepted.repositoryRoot, objectFormat: objectFormat as "sha1" | "sha256", targetHead }, accepted)) throw new Error("Accepted Reviewer target identity no longer matches the repository");
+    await git(accepted.repositoryRoot, ["cat-file", "-e", `${targetHead}^{commit}`], signal);
     dependencies.fault?.("mirror.before-create"); mirrorRoot = await mkdtemp(join(tmpdir(), "ak-reviewer-snapshot-")); const mirrorPath = join(mirrorRoot, "repository.git");
-    dependencies.fault?.("mirror.create"); await runCommand("git", ["clone", "--mirror", "--no-hardlinks", accepted.repositoryRoot, mirrorPath], signal === undefined ? {} : { signal });
-    const present = await git(mirrorPath, ["cat-file", "-e", `${targetHead}^{commit}`], signal, [0, 1, 128]);
-    if (present.code !== 0) { await git(mirrorPath, ["fetch", "--no-tags", accepted.repositoryRoot, targetHead], signal); await git(mirrorPath, ["update-ref", "refs/ak-reviewer/target", targetHead], signal); }
-    dependencies.fault?.("mirror.verify"); if (!sameReviewerRefs(await readRefs(mirrorPath, signal), refs)) throw new Error("Bare review mirror ref map changed while the snapshot was prepared");
-    const objects = Object.values(refs).flatMap(e => e.peeledCommitId === null ? [e.objectId] : [e.objectId, e.peeledCommitId]);
-    for (const object of new Set([targetHead, ...objects])) await git(mirrorPath, ["cat-file", "-e", `${object}^{object}`], signal);
-    await git(mirrorPath, ["config", "--remove-section", "remote.origin"], signal, [0, 5, 128]);
-    return { ...accepted, targetHead, refs, mirrorRoot, mirrorPath };
+    dependencies.fault?.("mirror.create"); await runCommand("git", ["init", "--bare", `--object-format=${accepted.objectFormat}`, mirrorPath], signal === undefined ? {} : { signal });
+    await git(mirrorPath, ["fetch", "--no-tags", accepted.repositoryRoot, targetHead], signal);
+    await git(mirrorPath, ["update-ref", "refs/ak-reviewer/target", targetHead], signal);
+    dependencies.fault?.("mirror.verify"); await git(mirrorPath, ["cat-file", "-e", `${targetHead}^{commit}`], signal);
+    return { ...accepted, targetHead, mirrorRoot, mirrorPath };
   } catch (error) { throw workspaceError(error, "snapshot", mirrorRoot === undefined ? "not-created" : { retained: mirrorRoot }, accepted); }
 }
 async function prepareClone(snapshot: GitSnapshot, signal: AbortSignal | undefined, dependencies: ReviewerWorkspaceDependencies): Promise<string> {
@@ -77,8 +71,8 @@ async function prepareClone(snapshot: GitSnapshot, signal: AbortSignal | undefin
   try {
     dependencies.fault?.("workspace.before-create"); workspace = await mkdtemp(join(tmpdir(), "ak-reviewer-leg-"));
     dependencies.fault?.("workspace.init"); await git(workspace, ["init", `--object-format=${snapshot.objectFormat}`, "--initial-branch=ak-reviewer-unborn"], signal);
-    dependencies.fault?.("workspace.fetch"); await git(workspace, ["fetch", "--no-tags", "--force", "--update-shallow", snapshot.mirrorPath, snapshot.targetHead, "+refs/heads/*:refs/heads/*", "+refs/tags/*:refs/tags/*", "+refs/remotes/*:refs/remotes/*"], signal);
-    await git(workspace, ["config", "--remove-section", "remote.origin"], signal, [0, 5, 128]); await git(workspace, ["checkout", "--detach", snapshot.targetHead], signal);
+    dependencies.fault?.("workspace.fetch"); await git(workspace, ["fetch", "--no-tags", snapshot.mirrorPath, snapshot.targetHead], signal);
+    await git(workspace, ["checkout", "--detach", snapshot.targetHead], signal);
     dependencies.fault?.("workspace.verify"); await verifySnapshot(workspace, snapshot, signal); return workspace;
   } catch (error) { throw workspaceError(error, "workspace", workspace === undefined ? "not-created" : { retained: workspace }, target); }
 }

package/src/role-runtime.ts

@@ -44,6 +44,10 @@ import {
   resolveLifecycleInvocationPrincipal,
 } from "./navigator-invocation-identity.ts";
 import { recordTypedProviderHttpStatus } from "./public-cli/run-lifecycle.ts";
+import {
+  ExplicitInternalActivationError,
+  recordReviewerDispatchRejectionSync,
+} from "./public-cli/explicit-internal.ts";
 import { NAVIGATOR_POST_ROLE_GRACE_MS, raceNavigatorGrace } from "./public-cli/settlement.ts";
 import { PACKAGED_ROLE_REGISTRY, packagedRoleMetadata, packagedRoleOutputTool, packagedRolePhaseFlag, type PackagedRole } from "./packaged-role-registry.ts";
 import { isAuditEscalationProjection } from "./audit-escalation.ts";
@@ -223,7 +227,25 @@ function activationStage(role: PackagedRole, runtime: ActivationRuntime): { id:
     case "reviewer": return { id: "load-install-and-dispatch", run: async () => {
       const activation = await runtime.reviewer.activate(runtime.context);
       const result = await activation.dispatcher.dispatch(activation.fixedBaseRevision, { context: runtime.context });
-      if (result.status !== "accepted") throw new Error(`Fixed Reviewer dispatch was not accepted: ${result.status}`);
+      if (result.status !== "accepted") {
+        const rejection = new ExplicitInternalActivationError(
+          `Fixed Reviewer dispatch was not accepted: ${result.status}: ${result.diagnostic}`,
+          {
+            knownCause: "activation",
+            name: "ReviewerDispatchRejectionError",
+          },
+        );
+        // Pi stderr cannot carry the structured violations. Do not mask a durable
+        // write failure: its infrastructure cause is truer than the unwritten page.
+        const runDir = process.env.AK_ROLE_RUN_DIR;
+        if (typeof runDir === "string" && runDir.trim() !== "") {
+          recordReviewerDispatchRejectionSync(runDir, {
+            diagnostic: rejection.message,
+            violations: result.violations,
+          });
+        }
+        throw rejection;
+      }
     } };
     case "collector": return { id: "load-and-install", run: async () => runtime.collector.activate(runtime.context, runtime.event) };
     case "doctor": return { id: "load-and-install", run: async () => runtime.doctor.activate() };