@akagilnc/pi-workflow-roles 0.1.3572 → 0.1.3621

package/dist/public-cli/terminal.js

@@ -0,0 +1,135 @@
+/**
+ * Terminal result: typed semantic regions for one admitted Role run (ADR 0052 / #106).
+ * Presentation may rearrange labels/order; only regions and typed facts are stable.
+ *
+ * Free-text cells are JSON-string encoded so legitimate newlines/tabs cannot forge
+ * extra rows or shift column boundaries (note / fix.summary / decision question / reason).
+ */
+import { isPublicCallableRole, renderPublicAkRoleCommand, } from "./command-renderer.js";
+/** Encode one free-text Terminal cell. JSON string form cannot embed raw tab/newline. */
+export function encodeTerminalField(value) {
+    return JSON.stringify(value);
+}
+/** Lawful typed terminal results exit zero (including audit_escalation). */
+export function isLawfulTypedTerminalOutcome(outcome) {
+    return outcome.kind === "accepted" || outcome.kind === "audit_escalation" || outcome.kind === "no_receipt";
+}
+export function exitCodeForTerminalOutcome(outcome) {
+    return isLawfulTypedTerminalOutcome(outcome) ? 0 : 1;
+}
+export function buildResidualIncompleteTerminalOutcome(input) {
+    return {
+        kind: "incomplete",
+        role: input.role,
+        status: "incomplete",
+        decision: "no-usable-result",
+        candidate: input.candidate,
+        diagnostic: input.diagnostic,
+        acceptedReceipt: false,
+        decisiveFacts: {
+            decision: "no-usable-result",
+            candidate: input.candidate,
+            diagnostic: input.diagnostic,
+            acceptedReceipt: false,
+        },
+    };
+}
+/** Public free-text stand-in when an exact Role run ID is stripped outside resume.command. */
+export const REDACTED_RUN_ID_TOKEN = "[run-id]";
+/**
+ * Remove an exact Role run ID from untrusted free text at the public Terminal boundary.
+ * Private durable artifacts keep the original bytes; only resume.command may disclose it.
+ */
+export function redactExactRunId(text, runId) {
+    if (runId.length === 0)
+        return text;
+    if (!text.includes(runId))
+        return text;
+    return text.split(runId).join(REDACTED_RUN_ID_TOKEN);
+}
+/**
+ * Build a recommendation navigator fact. Command is always registry-rendered;
+ * any model-authored command string is ignored.
+ */
+export function recommendationNavigatorFact(input) {
+    void input.modelCommand;
+    if (!isPublicCallableRole(input.next.role)) {
+        return {
+            disposition: "unavailable",
+            source: "unknown",
+            reason: `recommended role is not a public callable seat: ${input.next.role}`,
+        };
+    }
+    const command = renderPublicAkRoleCommand(input.next);
+    return {
+        disposition: "recommendation",
+        next: input.next,
+        reason: input.reason,
+        ...(command === undefined ? {} : { command }),
+        ...(input.route === undefined ? {} : { route: input.route }),
+        ...(input.advisoryDiagnostic === undefined ? {} : { advisoryDiagnostic: input.advisoryDiagnostic }),
+    };
+}
+/**
+ * Present one Terminal result for humans. Labels, row order, wording, and layout
+ * are unfrozen (ADR 0052). Machine consumers and tests must read typed
+ * TerminalResult / settlement owners — never bite this presentation.
+ */
+export function formatTerminalResult(result) {
+    const lines = [];
+    lines.push("role\toutcome\tstatus");
+    const outcomeStatus = result.roleOutcome.kind === "failure"
+        ? result.roleOutcome.cause
+        : result.roleOutcome.status;
+    lines.push(`${result.roleOutcome.role}\t${result.roleOutcome.kind}\t${encodeTerminalField(outcomeStatus)}`);
+    if (result.roleOutcome.kind === "failure") {
+        lines.push(`diagnostic\t${encodeTerminalField(result.roleOutcome.diagnostic)}`);
+    }
+    const facts = result.roleOutcome.decisiveFacts;
+    for (const [key, value] of Object.entries(facts)) {
+        if (value === undefined)
+            continue;
+        const rendered = typeof value === "string" ? value : JSON.stringify(value);
+        lines.push(`fact\t${encodeTerminalField(key)}\t${encodeTerminalField(rendered)}`);
+    }
+    lines.push(`navigator\t${result.navigator.disposition}`);
+    if (result.navigator.advisoryDiagnostic !== undefined) {
+        lines.push(`navigator-advisory\t${encodeTerminalField(result.navigator.advisoryDiagnostic)}`);
+    }
+    if (result.navigator.disposition === "recommendation") {
+        lines.push(`next\t${result.navigator.next.role}\t${result.navigator.next.phase ?? "none"}`);
+        lines.push(`reason\t${encodeTerminalField(result.navigator.reason)}`);
+        if (result.navigator.command !== undefined) {
+            lines.push(`command\t${encodeTerminalField(result.navigator.command)}`);
+        }
+    }
+    else if (result.navigator.disposition === "unavailable") {
+        lines.push(`unavailable\t${result.navigator.source}\t${encodeTerminalField(result.navigator.reason)}`);
+    }
+    for (const artifact of result.artifacts) {
+        lines.push(`artifact\t${artifact.kind}\t${encodeTerminalField(artifact.path)}`);
+    }
+    // Gate region is unfrozen presentation of typed facts (ADR 0052) — machines
+    // read result.gate, never these row labels.
+    if (result.gate !== undefined) {
+        lines.push(`gate\t${encodeTerminalField(result.gate.actualSeats.join(","))}\t${result.gate.rounds.length}`);
+        for (const round of result.gate.rounds) {
+            const reason = round.dispatch.kind === "historical_dispatch"
+                && round.dispatch.reason !== undefined
+                ? encodeTerminalField(round.dispatch.reason)
+                : "";
+            lines.push(`gate-round\t${round.roundIndex}\t${round.dispatch.kind}\t${round.dispatch.officer}\t${reason}\t${round.officer.seat}\t${encodeTerminalField(round.officer.status)}\t${encodeTerminalField(JSON.stringify(round.officer.findings))}`);
+        }
+    }
+    if (result.resume !== undefined) {
+        // Resumable failure: run ID is revealed only inside the complete resume command.
+        lines.push(`resume\t${encodeTerminalField(result.resume.command)}`);
+    }
+    else if (result.runId !== undefined) {
+        lines.push(`run\t${encodeTerminalField(result.runId)}`);
+    }
+    if (result.autoResumeCount !== undefined) {
+        lines.push(`autoResumeCount\t${encodeTerminalField(String(result.autoResumeCount))}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/public-cli/turn-request.js

@@ -0,0 +1,25 @@
+export function projectRoleTurnRequest(admitted, roleDetails, options) {
+    const cwd = admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
+    if (cwd === undefined)
+        throw new Error("admitted invocation missing working directory");
+    if (admitted.principal === undefined)
+        throw new Error("admitted invocation missing principal");
+    // #617 DK-3: turn model is the live seat/env model only — never the admitted
+    // birth model. Resume and new legs share this projection.
+    return {
+        principal: admitted.principal,
+        activation: roleDetails.activation,
+        methods: roleDetails.methods ?? [],
+        continuation: options.continuation,
+        ...(options.model === undefined ? {} : { model: options.model }),
+        ...(options.engine === undefined ? {} : { engine: options.engine }),
+        cwd,
+        home: options.home,
+        agentDir: options.agentDir,
+        runDirectory: admitted.runDirectory,
+        ...(options.correlationId === undefined || options.correlationId.trim() === ""
+            ? {}
+            : { correlationId: options.correlationId }),
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+    };
+}

package/dist/public-role-summons.js

@@ -0,0 +1,301 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+const AK_ROLE_PACKAGE_ROOT_ENV = "AK_ROLE_PACKAGE_ROOT";
+function createCapturingIo() {
+  const chunks = [];
+  return {
+    io: {
+      stdout() {
+      },
+      stderr(text) {
+        chunks.push(text);
+      }
+    },
+    stderrText: () => chunks.join("")
+  };
+}
+function parentDir(path) {
+  const end = path.endsWith("/") || path.endsWith("\\") ? path.slice(0, -1) : path;
+  const idx = Math.max(end.lastIndexOf("/"), end.lastIndexOf("\\"));
+  if (idx <= 0) return end;
+  return end.slice(0, idx);
+}
+function walkPackageRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 12; i += 1) {
+    if (existsSync(join(dir, "package.json")) && existsSync(join(dir, "souls"))) {
+      return dir;
+    }
+    const parent = parentDir(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function resolveSummonsPackageRoot(explicit) {
+  if (typeof explicit === "string" && explicit.trim() !== "") {
+    return explicit;
+  }
+  const fromEnv = process.env[AK_ROLE_PACKAGE_ROOT_ENV];
+  if (typeof fromEnv === "string" && fromEnv.trim() !== "") {
+    return fromEnv;
+  }
+  const fromCwd = walkPackageRoot(process.cwd());
+  if (fromCwd !== void 0) return fromCwd;
+  try {
+    const metaUrl = import.meta.url;
+    if (typeof metaUrl === "string" && metaUrl.startsWith("file:")) {
+      const filePath = decodeURIComponent(metaUrl.slice("file://".length));
+      const fromMeta = walkPackageRoot(parentDir(filePath));
+      if (fromMeta !== void 0) return fromMeta;
+    }
+  } catch {
+  }
+  throw new Error(
+    "public role summons cannot resolve package root (pass packageRoot or set AK_ROLE_PACKAGE_ROOT)"
+  );
+}
+async function resolveSummonHome(options) {
+  if (options.home !== void 0 && options.home.trim() !== "") {
+    return options.home;
+  }
+  const { tryHomeFromAkRolesPath, packageMachineHome } = await import("./activation-ledger-topology.js");
+  const fromCwd = tryHomeFromAkRolesPath(options.cwd);
+  if (fromCwd !== void 0 && fromCwd.length > 0) return fromCwd;
+  return packageMachineHome();
+}
+function projectSeatEngine(seat) {
+  return seat.engine === void 0 ? {} : { engine: seat.engine };
+}
+function projectSeatHost(seat) {
+  return seat.host === void 0 ? {} : { host: seat.host };
+}
+function projectSeatModel(seat) {
+  return seat.selection === void 0 ? {} : { model: seat.selection };
+}
+async function createSummonEnv(options) {
+  const [{ piDurablePrincipalAuthority }, { appendPiSessionCustomEntry, createPiRoleTurnHost }] = await Promise.all([
+    import("./pi/durable-principal.js"),
+    import("./pi/role-turn-host.js")
+  ]);
+  const principalAuthority = piDurablePrincipalAuthority;
+  const piRecords = {
+    async recordLaunchedPiIdentity(runDirectory, identity) {
+      const { recordLaunchedPiIdentity } = await import("./public-cli/invocation.js");
+      return recordLaunchedPiIdentity(runDirectory, identity);
+    },
+    async recordLaunchedRolePackageIdentity(runDirectory, identity) {
+      const { recordLaunchedRolePackageIdentity } = await import("./public-cli/invocation.js");
+      return recordLaunchedRolePackageIdentity(runDirectory, identity);
+    },
+    async observeLaunchedRolePackageIdentity(root, roleEntry) {
+      const { observeLaunchedRolePackageIdentity } = await import("./public-cli/invocation.js");
+      return observeLaunchedRolePackageIdentity(root, roleEntry);
+    }
+  };
+  const piHost = createPiRoleTurnHost({
+    packageRoot: options.packageRoot,
+    principalAuthority,
+    ...options.extraPiArgs === void 0 || options.extraPiArgs.length === 0 ? {} : { extraPiArgs: options.extraPiArgs },
+    ...piRecords
+  });
+  const hostName = options.seat.host ?? "pi";
+  let roleTurnHost = piHost;
+  if (hostName !== "pi") {
+    const { lookupHostDescription } = await import("./host-descriptions.js");
+    const { loadProductionAcpHostFactory } = await import("./public-cli/load-production-acp-host.js");
+    if (lookupHostDescription(hostName) === void 0) {
+      throw new Error(
+        `public role summons host unregistered: host=${hostName} seat=${options.role}`
+      );
+    }
+    let hostPromise;
+    roleTurnHost = {
+      executeTurn: async (request) => {
+        hostPromise ??= loadProductionAcpHostFactory(options.packageRoot, hostName).then(
+          (create) => create({
+            packageRoot: options.packageRoot,
+            principalAuthority
+          })
+        );
+        return (await hostPromise).executeTurn(request);
+      }
+    };
+  }
+  return {
+    home: options.home,
+    principalAuthority,
+    agentDir: options.agentDir,
+    sessionAppender: appendPiSessionCustomEntry,
+    packageRoot: options.packageRoot,
+    roleTurnHost,
+    cwd: options.cwd,
+    credentials: options.credentials,
+    ...projectSeatModel(options.seat),
+    ...projectSeatEngine(options.seat),
+    ...projectSeatHost(options.seat)
+  };
+}
+async function summonPublicRole(options) {
+  const packageRoot = resolveSummonsPackageRoot(options.packageRoot);
+  const home = await resolveSummonHome(options);
+  const agentDir = options.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join(home, ".pi", "agent");
+  const {
+    loadCredentialProviders,
+    loadPublicCliConfig,
+    resolveEffectiveSeat
+  } = await import("./public-cli/config.js");
+  const credentials = options.credentials ?? await loadCredentialProviders(agentDir);
+  const config = await loadPublicCliConfig(home);
+  const seat = resolveEffectiveSeat(config, options.role, credentials);
+  const env = {
+    ...await createSummonEnv({
+      role: options.role,
+      home,
+      agentDir,
+      cwd: options.cwd,
+      packageRoot,
+      credentials,
+      seat,
+      ...options.extraPiArgs === void 0 ? {} : { extraPiArgs: options.extraPiArgs }
+    }),
+    // Host config passthrough only — same face as public CLI (#422 / #675).
+    ...config.autoResumeLimit === void 0 ? {} : { autoResumeLimit: config.autoResumeLimit },
+    // Parent cancellation reaches the nested activation's own turn dispatch.
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  };
+  const captured = options.io === void 0 ? createCapturingIo() : void 0;
+  const io = options.io ?? captured.io;
+  let result;
+  switch (options.role) {
+    case "notary": {
+      const [{ runPublicNotary }, { parseNotaryArgv }] = await Promise.all([
+        import("./public-cli/notary-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicNotary(options.argv, env, io, parseNotaryArgv);
+      break;
+    }
+    case "inspector": {
+      const [{ runPublicInspector }, { parseInspectorArgv }] = await Promise.all([
+        import("./public-cli/inspector-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicInspector(options.argv, env, io, parseInspectorArgv);
+      break;
+    }
+    case "auditor": {
+      const [{ runPublicInstructionSeat }, { parseAuditorArgv }] = await Promise.all([
+        import("./public-cli/instruction-seat-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicInstructionSeat(
+        options.argv,
+        env,
+        io,
+        "auditor",
+        parseAuditorArgv
+      );
+      break;
+    }
+    case "evidence-child": {
+      const [{ runPublicInstructionSeat }, { parseEvidenceChildArgv }] = await Promise.all([
+        import("./public-cli/instruction-seat-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicInstructionSeat(
+        options.argv,
+        env,
+        io,
+        "evidence-child",
+        parseEvidenceChildArgv
+      );
+      break;
+    }
+    case "navigator": {
+      const [{ runPublicInstructionSeat }, { parseNavigatorArgv }] = await Promise.all([
+        import("./public-cli/instruction-seat-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicInstructionSeat(
+        options.argv,
+        env,
+        io,
+        "navigator",
+        parseNavigatorArgv
+      );
+      break;
+    }
+    case "gatekeeper": {
+      const [{ runPublicInstructionSeat }, { parseGatekeeperArgv }] = await Promise.all([
+        import("./public-cli/instruction-seat-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicInstructionSeat(
+        options.argv,
+        env,
+        io,
+        "gatekeeper",
+        parseGatekeeperArgv
+      );
+      break;
+    }
+    case "judge": {
+      const [{ runPublicJudge }, { parseJudgeArgv }] = await Promise.all([
+        import("./public-cli/judge-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicJudge(options.argv, env, io, parseJudgeArgv);
+      break;
+    }
+    case "doctor": {
+      const [{ runPublicDoctor }, { parseDoctorArgv }] = await Promise.all([
+        import("./public-cli/doctor-run.js"),
+        import("./public-cli/invocation.js")
+      ]);
+      result = await runPublicDoctor(options.argv, env, io, parseDoctorArgv);
+      break;
+    }
+  }
+  const stderr = captured?.stderrText();
+  const runDirectory = result.admitted?.runDirectory;
+  return {
+    exitCode: result.exitCode,
+    ...result.terminal === void 0 ? {} : { terminal: result.terminal },
+    ...typeof runDirectory === "string" && runDirectory.trim() !== "" ? { runDirectory } : {},
+    ...stderr === void 0 || stderr === "" ? {} : { stderr }
+  };
+}
+async function summonGateOfficer(options) {
+  let home = options.home;
+  if (home === void 0) {
+    const { homeFromRunDirectory } = await import("./activation-ledger-topology.js");
+    home = homeFromRunDirectory(options.sourceRunDirectory);
+  }
+  if (options.officer === "notary") {
+    return summonPublicRole({
+      role: "notary",
+      argv: ["--source-run", options.sourceRunDirectory, "--project", options.cwd],
+      cwd: options.cwd,
+      ...home === void 0 ? {} : { home },
+      ...options.packageRoot === void 0 ? {} : { packageRoot: options.packageRoot },
+      ...options.io === void 0 ? {} : { io: options.io },
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    });
+  }
+  return summonPublicRole({
+    role: "inspector",
+    argv: [`\u5377\u5B97\u6307\u9488\uFF1A${options.sourceRunDirectory}`],
+    cwd: options.cwd,
+    ...home === void 0 ? {} : { home },
+    ...options.packageRoot === void 0 ? {} : { packageRoot: options.packageRoot },
+    ...options.io === void 0 ? {} : { io: options.io },
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  });
+}
+export {
+  AK_ROLE_PACKAGE_ROOT_ENV,
+  resolveSummonsPackageRoot,
+  summonGateOfficer,
+  summonPublicRole
+};

package/dist/receipt-delivery-policy.js

@@ -60,6 +60,16 @@ function createReceiptDeliveryPolicy() {
     recordDeliveryRequest() {
       deliveryTurns = Math.min(RECEIPT_DELIVERY_TURN_LIMIT, deliveryTurns + 1);
     },
+    /**
+     * A nested session settled without an accepted receipt after spending its own
+     * delivery budget. Adopt its facts and close this budget: another prompt would
+     * open an independent session, not a delivery request on the settled one.
+     */
+    recordNestedNoReceipt(facts) {
+      terminalToolCalled = terminalToolCalled || facts.terminalToolCalled;
+      rejectedReceipts.push(...facts.rejectedReceipts);
+      deliveryTurns = RECEIPT_DELIVERY_TURN_LIMIT;
+    },
     nextAction() {
       if (accepted) return "accepted";
       return deliveryTurns < RECEIPT_DELIVERY_TURN_LIMIT ? "request-delivery" : "no-receipt";

package/dist/reviewer-child-executor.js

@@ -1,4 +1,4 @@
-import { executeEvidenceChild } from "./evidence-child-executor.js";
+import { auditorRunDirectory } from "./auditor-dossier-tool.js";
 /**
  * Single conversion at the Reviewer adapter boundary: shared child classifications
  * become Reviewer failure classifications without a second error taxonomy.
@@ -12,15 +12,87 @@ export function projectSharedChildFailure(error) {
     }
     return error;
 }
-/** Reviewer policy adapter over the shared evidence-child lifecycle seam. */
+function failureClassification(cause) {
+    if (cause === "provider")
+        return "provider";
+    if (cause === "output"
+        || cause === "timeout"
+        || cause === "activation"
+        || cause === "session"
+        || cause === "unrecognized") {
+        return "child";
+    }
+    return "unknown";
+}
+function reportFromSummon(summoned) {
+    const outcome = summoned.terminal?.roleOutcome;
+    if (outcome === undefined) {
+        throw Object.assign(new Error(`Evidence-child public summon produced no terminal (exit ${summoned.exitCode})`), { evidenceChildFailure: "child" });
+    }
+    if (outcome.kind === "failure") {
+        throw Object.assign(new Error(outcome.diagnostic), {
+            evidenceChildFailure: failureClassification(outcome.cause),
+        });
+    }
+    if (outcome.kind === "accepted") {
+        // No field-presence reject (ADR 0055 / #675). Keep original accepted bytes:
+        // report key when present, otherwise the whole decisiveFacts body.
+        const facts = outcome.decisiveFacts;
+        if (Object.hasOwn(facts, "report"))
+            return facts.report;
+        return facts;
+    }
+    throw Object.assign(new Error("Evidence-child public summon returned no accepted report body"), { evidenceChildFailure: "child" });
+}
+/** Reviewer evidence leg via the public evidence-child activation path (#675). */
 export async function executeReviewerChild(workspace, leg, context, options = {}) {
     try {
-        return await executeEvidenceChild(workspace, leg.prompt, context, {
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            ...(options.credentialScratchParent === undefined ? {} : { credentialScratchParent: options.credentialScratchParent }),
-            ...(options.runDirectory === undefined ? {} : { runDirectory: options.runDirectory }),
-            ...(options.packageRoot === undefined ? {} : { packageRoot: options.packageRoot }),
-        });
+        if (options.signal?.aborted) {
+            throw Object.assign(new DOMException("The operation was aborted.", "AbortError"), {
+                evidenceChildFailure: "child",
+            });
+        }
+        const runDirectory = options.runDirectory ?? auditorRunDirectory(context);
+        const pointer = runDirectory === undefined
+            ? ""
+            : `\n卷宗指针：${runDirectory}`;
+        const argv = [`${String(leg.prompt)}${pointer}`];
+        const summon = options.summonEvidenceChild
+            ?? (async (nextArgv, childSignal) => {
+                const { summonPublicRole } = await import("./public-role-summons.js");
+                // Parent run home owns nested public seats; leg workspace cwd is a bare worktree.
+                let home;
+                if (runDirectory !== undefined) {
+                    const { homeFromRunDirectory } = await import("./activation-ledger-topology.js");
+                    // Hard path resolve: fail loud — no packageMachineHome fallback (#604 / #675).
+                    home = homeFromRunDirectory(runDirectory);
+                }
+                return summonPublicRole({
+                    role: "evidence-child",
+                    argv: nextArgv,
+                    cwd: workspace,
+                    ...(home === undefined ? {} : { home }),
+                    ...(options.packageRoot === undefined ? {} : { packageRoot: options.packageRoot }),
+                    ...(childSignal === undefined ? {} : { signal: childSignal }),
+                });
+            });
+        const summoned = await summon(argv, options.signal);
+        if (options.signal?.aborted) {
+            throw Object.assign(new DOMException("The operation was aborted.", "AbortError"), {
+                evidenceChildFailure: "child",
+            });
+        }
+        const report = reportFromSummon(summoned);
+        const { usageFromPublicSummon } = await import("./session-assistant-usage.js");
+        // Real session usage when present; no session → token-zero without inventing cost.
+        const usage = (await usageFromPublicSummon(summoned)) ?? {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+        };
+        return { report, usage, prompt: leg.prompt };
     }
     catch (error) {
         throw projectSharedChildFailure(error);

package/dist/reviewer-execution-ledger.js

@@ -129,7 +129,8 @@ export function createReviewerExecutionLedger() {
         if (!sameReviewerPinnedTarget(event.target, accepted.target))
             throw new Error("Runner target does not match shared pinned target");
         if (event.status === "successful") {
-            if (typeof event.report !== "string" || event.report.length === 0 || event.failure !== undefined)
+            // Report field required; no type/blank reshape gate (ADR 0055 / #675).
+            if (event.report === undefined || event.failure !== undefined)
                 throw new Error("Successful settlement requires a report");
         }
         else if (event.failure === undefined || event.report !== undefined) {