diff --git a/tests/runner-e2e/manual-private-transfer.ts b/tests/runner-e2e/manual-private-transfer.ts
index f0a65165ca6..81f77bb9ca4 100644
--- a/tests/runner-e2e/manual-private-transfer.ts
+++ b/tests/runner-e2e/manual-private-transfer.ts
@@ -13,6 +13,7 @@ import { privateArtifactKey, retainPrivateTransfer, transferPrivateArtifact, ver
 import { authorizeManualPrivateEvidence, MANUAL_PRIVATE_PROTOCOL, manualCellKind, manualPrivateSessionPolicy } from "./manual-private-retention.js";
 import { shippedChatEvidenceAuthority } from "./testops-chat-admission.js";
 import { manualDispatchEvidenceAuthority } from "./manual-dispatch-authority.js";
+import { privateRefusalCode } from "./private-refusal-code.js";
 
 const hash = (bytes: string | Buffer) => createHash("sha256").update(bytes).digest("hex");
 function request(env: NodeJS.ProcessEnv) {
@@ -233,5 +234,6 @@ async function main() {
   else throw new Error("Invalid private evidence command");
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
-  main().catch(() => { process.stderr.write("Restricted manual evidence operation failed; no public fallback\n"); process.exitCode = 1; });
+  // Name only a closed refusal code (never message text) so a refused attempt is diagnosable.
+  main().catch(error => { process.stderr.write(`Restricted manual evidence operation failed (refusal: ${privateRefusalCode(error)}); no public fallback\n`); process.exitCode = 1; });
 }
diff --git a/tests/runner-e2e/private-refusal-code.test.ts b/tests/runner-e2e/private-refusal-code.test.ts
new file mode 100644
index 00000000000..fd62c4589a3
--- /dev/null
+++ b/tests/runner-e2e/private-refusal-code.test.ts
@@ -0,0 +1,41 @@
+import { readFileSync } from "node:fs";
+import { expect, it } from "vitest";
+import { fixedRefusalMessages, privateRefusalCode, PRIVATE_REFUSAL_MODULES } from "./private-refusal-code.js";
+
+it("names only fixed literal refusals from the trusted evidence modules", () => {
+  const fixed = fixedRefusalMessages();
+  expect(fixed.has("Contaminated private evidence cannot be uploaded")).toBe(true);
+  expect(fixed.has("Original evidence byte accounting changed")).toBe(true);
+  expect(privateRefusalCode(new Error("Contaminated private evidence cannot be uploaded"))).toBe("contaminated-private-evidence-cannot-be-uploaded");
+});
+
+it("never returns the text of a dynamic or system message", () => {
+  const leaked = "/home/runner/_work/private/secret-token-abc";
+  expect(privateRefusalCode(new Error(`Secret leak in ${leaked}`))).toBe("dynamic");
+  expect(privateRefusalCode(Object.assign(new Error(`ENOENT: no such file, open '${leaked}'`), { code: "ENOENT" }))).toBe("fs-ENOENT");
+  expect(privateRefusalCode(new TypeError(`bad ${leaked}`))).toBe("error-type-TypeError");
+  expect(privateRefusalCode(leaked)).toBe("non-error-thrown");
+  for (const value of [new Error(`x ${leaked}`), new TypeError(leaked), leaked]) expect(privateRefusalCode(value)).not.toContain("secret");
+});
+
+it("names refusals from the dispatch-authority and admission modules the transfer calls", () => {
+  const fixed = fixedRefusalMessages();
+  for (const file of ["manual-dispatch-authority.ts", "testops-chat-admission.ts"]) {
+    const literals = [...readFileSync(new URL(`./${file}`, import.meta.url), "utf8").matchAll(/new Error\("([^"$`\\]+)"\)/g)].map(match => match[1]!);
+    expect(literals.length, file).toBeGreaterThan(0);
+    for (const message of literals) expect(privateRefusalCode(new Error(message), fixed), message).not.toBe("dynamic");
+  }
+});
+
+it("covers every local module the trusted transfer imports that has fixed refusals", () => {
+  const transfer = readFileSync(new URL("./manual-private-transfer.ts", import.meta.url), "utf8");
+  const imported = [...transfer.matchAll(/from "\.\/([a-z0-9-]+)\.js"/g)].map(match => `${match[1]}.ts`);
+  for (const file of imported.filter(name => name !== "private-refusal-code.ts")) {
+    const source = readFileSync(new URL(`./${file}`, import.meta.url), "utf8");
+    if (/new Error\("[^"$`\\]+"\)/.test(source)) expect(PRIVATE_REFUSAL_MODULES as readonly string[], file).toContain(file);
+  }
+});
+it("never throws while naming a refusal", () => {
+  const broken = new Proxy(new Set<string>(), { get() { throw new Error("read failed /private/path"); } });
+  expect(privateRefusalCode(new Error("x"), broken)).toBe("unnamed");
+});
diff --git a/tests/runner-e2e/private-refusal-code.ts b/tests/runner-e2e/private-refusal-code.ts
new file mode 100644
index 00000000000..eb442080d54
--- /dev/null
+++ b/tests/runner-e2e/private-refusal-code.ts
@@ -0,0 +1,36 @@
+import { readFileSync } from "node:fs";
+
+/** Trusted evidence modules whose fixed refusal messages may be named publicly. */
+export const PRIVATE_REFUSAL_MODULES = [
+  "manual-private-transfer.ts", "manual-private-handoff.ts", "manual-private-retention.ts", "manual-private-report-assets.ts",
+  "private-history.ts", "private-framework-report.ts", "history-budget.ts", "evidence.ts", "redaction.ts",
+  "manual-dispatch-authority.ts", "testops-chat-admission.ts",
+] as const;
+
+let known: ReadonlySet<string> | undefined;
+/** Literal `new Error("...")` messages in the trusted modules; dynamic messages are never included. */
+export function fixedRefusalMessages(): ReadonlySet<string> {
+  known ??= new Set(PRIVATE_REFUSAL_MODULES.flatMap(file => {
+    const source = readFileSync(new URL(`./${file}`, import.meta.url), "utf8");
+    return [...source.matchAll(/new Error\("([^"$`\\]+)"\)/g)].map(match => match[1]!);
+  }));
+  return known;
+}
+
+/**
+ * A closed, public-safe name for why a private evidence operation refused. Only a fixed literal
+ * message from the trusted modules is named (as a slug); otherwise a Node error code, an error type,
+ * or "dynamic". The message text of anything else is never returned.
+ */
+export function privateRefusalCode(error: unknown, fixed?: ReadonlySet<string>): string {
+  // Naming must never prevent the fixed failure line: a module read failure degrades to "unnamed".
+  try { return refusalCode(error, fixed ?? fixedRefusalMessages()); } catch { return "unnamed"; }
+}
+function refusalCode(error: unknown, fixed: ReadonlySet<string>): string {
+  if (!(error instanceof Error)) return "non-error-thrown";
+  if (fixed.has(error.message)) return error.message.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 96);
+  const code = (error as NodeJS.ErrnoException).code;
+  if (typeof code === "string" && /^(?:E[A-Z]{2,15}|ERR_[A-Z0-9_]{2,48})$/.test(code)) return `fs-${code}`;
+  if (error.name !== "Error" && /^[A-Z][A-Za-z]{2,40}$/.test(error.name)) return `error-type-${error.name}`;
+  return "dynamic";
+}