@akagilnc/pi-workflow-roles 0.1.3932 → 0.1.3975

package/dist/worker-submission-gates.js

@@ -1,305 +0,0 @@
-/** #242/#369 worker gates ①② at submission seam. Durability: ADR 0065 createRecordSession only. */
-import { execFileSync } from "node:child_process";
-import { existsSync, lstatSync, readdirSync, readFileSync, rmdirSync, rmSync } from "node:fs";
-import { resolve } from "node:path";
-import { createRecordSession, WORKER_SUBMISSION_GATE_KIND, } from "./archivist-record-entry.js";
-import { sitianReport } from "./sitian-facade.js";
-import { WorkerCommitReminderError, WorkerPrefixReminderError, WorkerUnfinishedReasonReminderError, } from "./submission-errors.js";
-export { WorkerCommitReminderError, WorkerPrefixReminderError, WorkerUnfinishedReasonReminderError } from "./submission-errors.js";
-export const WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
-export const WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
-export const WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE = "commit-reminder-bounce";
-export const WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE = "prefix-reminder-bounce";
-/** Statuses that enter the officer submission gate (ADR 0066 gate-1-status-matrix / ADR 0072 skip-statuses). */
-export const WORKER_DONE_STATUSES = new Set(["completed", "partially_completed"]);
-/** Historical package hook ownership marker — uninstall criterion only. */
-const HOOK_MARKER = "ak-roles: worker-submission-gates reference-transaction";
-const HOOKS_DIR = "ak-roles-hooks";
-const HOOK_FILE = "reference-transaction";
-/** Open platform-prefix domain (constitution #10) — not a closed singleton. */
-const PLATFORM_PREFIX = /^[A-Za-z][A-Za-z0-9_-]*:/;
-const UNFINISHED_REASON_BOUNCE_LIMIT = 2;
-function git(cwd, args) {
-    return execFileSync("git", args, {
-        cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, GIT_DIR: undefined, GIT_WORK_TREE: undefined, GIT_COMMON_DIR: undefined },
-    }).trim();
-}
-function gitFile(file, args) {
-    return execFileSync("git", ["config", "--file", file, ...args], {
-        encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, GIT_DIR: undefined, GIT_WORK_TREE: undefined, GIT_COMMON_DIR: undefined },
-    }).trim();
-}
-function statusOf(error) {
-    return typeof error === "object" && error !== null && "status" in error
-        ? error.status
-        : undefined;
-}
-function tryGetAll(file, key) {
-    if (!existsSync(file))
-        return [];
-    try {
-        const out = gitFile(file, ["--get-all", key]);
-        return out.length === 0 ? [] : out.split("\n");
-    }
-    catch (error) {
-        // --get-all exit 1 = absent; other failures stay loud.
-        if (statusOf(error) !== 1)
-            throw error;
-        return [];
-    }
-}
-/** True only when the file exists and carries the historical package marker.
- *  Read failures propagate — never disguised as "not owned". */
-function ownedHook(path) {
-    if (!existsSync(path))
-        return false;
-    return readFileSync(path, "utf8").includes(HOOK_MARKER);
-}
-/** Escape a hooksPath value for git config --unset value-pattern (POSIX ERE). */
-function escapeGitConfigValueRegex(value) {
-    return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-}
-/**
- * Remove only package-owned core.hooksPath values; keep every foreign value.
- * --unset without a value-pattern exits 5 for both "absent" and "multi-value",
- * so multi-valued keys must be addressed per matching value.
- */
-function unsetOwnedHooksPath(file) {
-    const owned = [];
-    for (const value of tryGetAll(file, "core.hooksPath")) {
-        if (!ownedHook(resolve(value, HOOK_FILE)))
-            continue;
-        try {
-            // --unset-all + exact value-pattern drops every duplicate owned copy; foreign stays.
-            gitFile(file, [
-                "--unset-all",
-                "core.hooksPath",
-                `^${escapeGitConfigValueRegex(value)}$`,
-            ]);
-        }
-        catch (error) {
-            // 5 = this specific value already absent (not multi-value ambiguity).
-            if (statusOf(error) !== 5)
-                throw error;
-        }
-        owned.push(value);
-    }
-    return owned;
-}
-/** Delete only the package-owned hook file; rmdir solely when empty. */
-function rmOwnedDir(dir) {
-    const hookPath = resolve(dir, HOOK_FILE);
-    if (!ownedHook(hookPath))
-        return;
-    rmSync(hookPath, { force: true });
-    if (existsSync(dir) && readdirSync(dir).length === 0)
-        rmdirSync(dir);
-}
-function linkedGitDirs(commonDir) {
-    const root = resolve(commonDir, "worktrees");
-    if (!existsSync(root))
-        return [];
-    // Enumeration/lstat failures propagate — never skip a linked admin dir silently.
-    // lstat does not follow: symlink entries are not directories and stay out of range.
-    return readdirSync(root)
-        .map((name) => resolve(root, name))
-        .filter((dir) => lstatSync(dir).isDirectory());
-}
-/**
- * ADR 0070 §4 — private one-shot uninstall on arm.
- * Range: current repo + enumerable worktree admin dirs. Owned hooksPath/files only.
- * Never rolls back extensions.worktreeConfig / migrated bare|worktree / foreign hooksPath.
- */
-function uninstallPackageWorkerHooks(cwd) {
-    let inside;
-    try {
-        inside = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
-    }
-    catch {
-        return;
-    }
-    if (inside !== "true")
-        return;
-    const commonDir = git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-    // Unset owned hooksPath before deleting the marker file (ownership check needs it).
-    const clear = (configFile) => {
-        for (const hooks of unsetOwnedHooksPath(configFile))
-            rmOwnedDir(hooks);
-    };
-    clear(resolve(commonDir, "config"));
-    clear(resolve(commonDir, "config.worktree"));
-    rmOwnedDir(resolve(commonDir, HOOKS_DIR));
-    const legacy = resolve(commonDir, "hooks", HOOK_FILE);
-    if (ownedHook(legacy))
-        rmSync(legacy, { force: true });
-    for (const gitDir of linkedGitDirs(commonDir)) {
-        clear(resolve(gitDir, "config.worktree"));
-        rmOwnedDir(resolve(gitDir, HOOKS_DIR));
-    }
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function unfinishedReasonPresent(details) {
-    if (typeof details !== "object" || details === null)
-        return false;
-    const reason = details.reason;
-    return typeof reason === "string" && reason.trim().length > 0;
-}
-function readGateState(session) {
-    let baseline;
-    let reminded = false;
-    let prefixReminded = false;
-    for (const entry of session.getEntries()) {
-        if (entry.type !== "custom")
-            continue;
-        if (entry.customType === WORKER_COMMIT_BASELINE_ENTRY_TYPE) {
-            const data = entry.data;
-            if (isRecord(data) && (data.head === null || typeof data.head === "string")) {
-                baseline = data.head;
-            }
-        }
-        else if (entry.customType === WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE) {
-            reminded = true;
-        }
-        else if (entry.customType === WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE) {
-            prefixReminded = true;
-        }
-    }
-    return { baseline, reminded, prefixReminded };
-}
-function isAncestor(cwd, ancestor, descendant) {
-    try {
-        git(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
-        return true;
-    }
-    catch (error) {
-        if (statusOf(error) === 1)
-            return false;
-        throw error;
-    }
-}
-/**
- * Reliable window (ADR 0070). null = unreliable tip-SHA baseline; [] = empty.
- * Structured git-log fields only — never parse a shell command string.
- */
-function reliableWindow(cwd, baseline, head) {
-    if (baseline !== null && !isAncestor(cwd, baseline, head))
-        return null;
-    const range = baseline === null ? head : `${baseline}..${head}`;
-    const raw = git(cwd, ["log", "--format=%P%x1e%s", range]);
-    if (raw.length === 0)
-        return [];
-    return raw.split("\n").flatMap((line) => {
-        const sep = line.indexOf("\x1e");
-        if (sep < 0)
-            return [];
-        return [{
-                subject: line.slice(sep + 1),
-                merge: line.slice(0, sep).trim().includes(" "),
-            }];
-    });
-}
-export function createWorkerSubmissionGate(options = {}) {
-    let baseline;
-    let root;
-    let reminded = false;
-    let prefixReminded = false;
-    let unfinishedReasonBounces = 0;
-    let record;
-    /** Parent session file retained so every gate sitian write path-derives the same ledger home. */
-    let sessionParent;
-    const explicitHome = typeof options.home === "string" && options.home.length > 0 ? options.home : undefined;
-    const head = (cwd) => {
-        try {
-            return git(cwd, ["rev-parse", "HEAD"]);
-        }
-        catch {
-            git(cwd, ["rev-parse", "--git-dir"]); // surface real git failures
-            return null;
-        }
-    };
-    const gateSitian = (cwd, payload) => {
-        sitianReport({
-            level: "event",
-            kind: "gate",
-            cwd,
-            ...(sessionParent === undefined ? {} : { sessionParent }),
-            ...(explicitHome === undefined ? {} : { home: explicitHome }),
-            payload,
-            source: "worker-submission-gates",
-        });
-    };
-    return {
-        arm(cwd, parent) {
-            uninstallPackageWorkerHooks(cwd);
-            root = cwd;
-            sessionParent = parent?.getSessionFile();
-            record = createRecordSession({
-                cwd,
-                kind: WORKER_SUBMISSION_GATE_RECORD_KIND,
-                ...(parent === undefined ? {} : { parent }),
-            });
-            const prior = readGateState(record);
-            if (prior.baseline !== undefined) {
-                baseline = prior.baseline;
-                reminded = prior.reminded;
-                prefixReminded = prior.prefixReminded;
-                return;
-            }
-            baseline = head(cwd);
-            reminded = false;
-            prefixReminded = false;
-            record.appendCustomEntry(WORKER_COMMIT_BASELINE_ENTRY_TYPE, {
-                version: 1,
-                head: baseline,
-            });
-            gateSitian(cwd, {
-                type: WORKER_COMMIT_BASELINE_ENTRY_TYPE,
-                version: 1,
-                head: baseline,
-            });
-        },
-        assertAcceptable(status, details) {
-            if (status === "unfinished" && !unfinishedReasonPresent(details)) {
-                if (unfinishedReasonBounces < UNFINISHED_REASON_BOUNCE_LIMIT) {
-                    unfinishedReasonBounces += 1;
-                    throw new WorkerUnfinishedReasonReminderError();
-                }
-            }
-            if (baseline === undefined || root === undefined || !WORKER_DONE_STATUSES.has(status))
-                return;
-            const now = head(root);
-            const headMoved = now !== null && (baseline === null || now !== baseline);
-            // Gate ① — forgetfulness reminder (ADR 0066; behavior unchanged).
-            if (!headMoved && !reminded) {
-                reminded = true;
-                record?.appendCustomEntry(WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
-                gateSitian(root, {
-                    type: WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE,
-                    version: 1,
-                });
-                throw new WorkerCommitReminderError();
-            }
-            reminded = true;
-            // Gate ② — open platform-prefix soft reminder (ADR 0070).
-            if (prefixReminded || now === null)
-                return;
-            const window = reliableWindow(root, baseline, now);
-            if (window === null ||
-                window.length === 0 ||
-                !window.some((c) => !c.merge && !PLATFORM_PREFIX.test(c.subject))) {
-                return;
-            }
-            prefixReminded = true;
-            record?.appendCustomEntry(WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
-            gateSitian(root, {
-                type: WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE,
-                version: 1,
-            });
-            throw new WorkerPrefixReminderError();
-        },
-    };
-}

package/src/collector-receipt.ts

@@ -1,140 +0,0 @@
-import { COLLECTOR_HOST } from "./collector-config.ts";
-import type { CollectorClock, CollectorEvidenceRecord, CollectorSnapshot } from "./collector-evidence.ts";
-import type { CollectorLedger, CollectorRequestAttempt } from "./collector-ledger.ts";
-import {
-  enrichCollectorFindings,
-  extractCollectorEvidenceIdentityGroups,
-  extractCollectorUnfinishedReasons,
-  type ExtractedCollectorIdentityGroup,
-} from "./collector-identity.ts";
-import {
-  validateAcceptedCollectorReceipt,
-  type CollectorEvidenceRecord as ReceiptEvidenceRecord,
-  type CollectorReceipt as PackageCollectorReceipt,
-  type CollectorSubmissionProjection,
-} from "./package-contracts/collector-output.ts";
-
-export { validateAcceptedCollectorReceipt };
-export type { CollectorSubmissionProjection };
-
-/**
- * #641 chain① receipt-local evidence projection: machine identity, integrity
- * digest and resolvable pointer fields only. Bodies/raw stay in the volume
- * (observe details + GitHub pointer); they are never transcribed into the receipt.
- */
-export type CollectorReceiptEvidenceRecord = ReceiptEvidenceRecord;
-
-/**
- * #676 C: single authority for receipt shape is package-contracts/collector-output.
- * Production builder always emits the full projection object and concrete prState;
- * package leaf keeps those optional so old volumes stay readable.
- */
-export type CollectorReceipt = PackageCollectorReceipt & {
-  prState: string;
-  groups: ExtractedCollectorIdentityGroup[];
-  submissionProjection: CollectorSubmissionProjection;
-  requestAttempts: CollectorRequestAttempt[];
-  snapshots: CollectorSnapshot[];
-  evidenceRecords: CollectorReceiptEvidenceRecord[];
-};
-
-function fail(message: string): never { throw new Error(message); }
-
-/** Runtime output assembles findings pointers from the model submission into the typed receipt. */
-export function buildCollectorReceipt(
-  ledger: CollectorLedger,
-  candidateRaw: unknown,
-  clock?: CollectorClock,
-): CollectorReceipt {
-  ledger.assertNotFatal();
-  if (ledger.unresolvedTransportFailure) fail("Collector cannot output while a transport failure is unrecovered");
-  if (ledger.latestCompleteSnapshotId === undefined) fail("Collector output requires a complete final snapshot");
-  if (ledger.activationTime === undefined || ledger.deadlineTime === undefined) fail("Collector output requires activation timeline");
-  if (ledger.config.prNumber === undefined) {
-    fail("Collector output requires a bound PR target; call ak_collector_bind_target first or pass --pr");
-  }
-
-  if (clock !== undefined) ledger.assertOutputObservationLaw(clock);
-  else if (ledger.observedGeneration !== ledger.mutationGeneration ||
-    (ledger.finalObservationRequired && !ledger.finalObservationCompleted)) {
-    fail("Collector output requires a complete observe after the latest request/wait mutation");
-  }
-
-  const finalSnapshot = ledger.getSnapshot(ledger.latestCompleteSnapshotId);
-  if (finalSnapshot === undefined || !finalSnapshot.complete) fail("Collector final snapshot is incomplete");
-  // #676 D6: closed/merged still deliver collected materials; status is a fact on the receipt.
-
-  const evidenceRecords: CollectorEvidenceRecord[] = [...ledger.allEvidence()];
-  const snapshots = [...ledger.allSnapshots()];
-  const evidenceIndex = new Map(evidenceRecords.map((record) => [record.evidenceId, record]));
-  const snapshotIndex = new Map(snapshots.map((snapshot) => [snapshot.snapshotId, snapshot]));
-  if (evidenceIndex.size !== evidenceRecords.length) fail("Collector receipt evidenceId collision");
-  if (snapshotIndex.size !== snapshots.length) fail("Collector receipt snapshotId collision");
-  for (const id of evidenceIndex.keys()) if (snapshotIndex.has(id)) fail(`Collector receipt id "${id}" is ambiguous`);
-  if (!snapshotIndex.has(finalSnapshot.snapshotId)) fail("Collector receipt lacks final snapshot");
-  for (const snapshot of snapshots) {
-    for (const id of snapshot.evidenceIds) if (!evidenceIndex.has(id)) fail(`Collector snapshot ref "${id}" does not resolve`);
-  }
-
-  const groups = extractCollectorEvidenceIdentityGroups(evidenceRecords, finalSnapshot.headOid);
-  // #641 chain①: the collector LLM submits findings as pointer refs; the runtime
-  // enriches each with the machine locator from the same stored record.
-  const findingsProjection = enrichCollectorFindings({
-    candidate: candidateRaw,
-    records: evidenceRecords,
-    groups,
-    targetHead: finalSnapshot.headOid,
-    repository: ledger.config.repository.canonical,
-    prNumber: ledger.config.prNumber,
-  });
-  for (const group of groups) {
-    for (const material of group.materials) {
-      if (material.evidenceId === undefined || !evidenceIndex.has(material.evidenceId)) fail("Collector material lacks a receipt-local evidence ref");
-    }
-    for (const finding of group.findings) {
-      if (finding.source.evidenceId === undefined || !evidenceIndex.has(finding.source.evidenceId)) fail("Collector finding lacks a receipt-local evidence ref");
-    }
-  }
-  const unfinished = extractCollectorUnfinishedReasons(candidateRaw);
-  const submissionProjection: CollectorSubmissionProjection = {
-    findingsSource: findingsProjection.findingsSource,
-    findingsProjectedCount: findingsProjection.findingsProjectedCount,
-    findingsUnprojected: findingsProjection.findingsUnprojected,
-    unfinishedReasonsSource: unfinished.source,
-    unfinishedReasonsProjectedCount: unfinished.reasons?.length ?? 0,
-    unfinishedReasonsUnprojected: unfinished.unprojected,
-  };
-
-  return {
-    host: COLLECTOR_HOST,
-    repository: ledger.config.repository.canonical,
-    prNumber: ledger.config.prNumber,
-    prState: finalSnapshot.prState,
-    manifestDigest: ledger.config.manifest.digest,
-    activationTime: ledger.activationTime.toISOString(),
-    deadlineTime: ledger.deadlineTime.toISOString(),
-    finalObservationTime: finalSnapshot.completedAt ?? finalSnapshot.observedAt,
-    finalSnapshotId: finalSnapshot.snapshotId,
-    targetHead: finalSnapshot.headOid,
-    groups,
-    ...(unfinished.reasons === undefined ? {} : { unfinishedReasons: unfinished.reasons }),
-    submissionProjection,
-    requestAttempts: [...ledger.requestAttempts()],
-    snapshots,
-    evidenceRecords: evidenceRecords.map(toReceiptEvidenceRecord),
-  };
-}
-
-function toReceiptEvidenceRecord(record: CollectorEvidenceRecord): CollectorReceiptEvidenceRecord {
-  return {
-    evidenceId: record.evidenceId,
-    kind: record.kind,
-    versionId: record.versionId,
-    contentDigest: record.contentDigest,
-    firstObservedAt: record.firstObservedAt,
-    ...(record.githubId === undefined ? {} : { githubId: record.githubId }),
-    ...(record.authorLogin === undefined ? {} : { authorLogin: record.authorLogin }),
-    ...(record.htmlUrl === undefined ? {} : { htmlUrl: record.htmlUrl }),
-    ...(record.authoritativeTime === undefined ? {} : { authoritativeTime: record.authoritativeTime }),
-  };
-}

package/src/diagnostic-tail.ts

@@ -1,18 +0,0 @@
-/**
- * Bound diagnostic text: rolling tail only, not a dossier/transcript face.
- * One authority for host stderr retention (headless + ACP).
- */
-
-/** Fixed cap for retained diagnostic tails. */
-export const DIAGNOSTIC_TAIL_CAP = 16 * 1024;
-
-const CLIP_MARK = "…[stderr clipped]\n";
-
-/**
- * Retain at most DIAGNOSTIC_TAIL_CAP characters, keeping the newest bytes
- * when over budget. Clip mark is included inside the fixed cap.
- */
-export function retainDiagnosticTail(text: string): string {
-  if (text.length <= DIAGNOSTIC_TAIL_CAP) return text;
-  return CLIP_MARK + text.slice(text.length - (DIAGNOSTIC_TAIL_CAP - CLIP_MARK.length));
-}

package/src/reviewer-agent.ts

@@ -1,135 +0,0 @@
-import type { HostContext } from "./host-contracts.ts";
-import { isReviewerPromptText, type ReviewerPromptText } from "./reviewer-prompt-identity.ts";
-import type { AcceptedReviewerExecution } from "./reviewer-dispatch.ts";
-import type { ReviewerTargetSnapshot, ReviewerWorkspaceDisposition, ReviewerFailureClassification, ReviewerUsage } from "./reviewer-execution-ledger.ts";
-import { executeReviewerChild } from "./reviewer-child-executor.ts";
-import { createReviewerWorkspaceOwner, type ReviewerWorkspaceFaultPoint } from "./reviewer-workspace.ts";
-import { normalizeReviewerFailureDiagnostic } from "./reviewer-failure-diagnostic.ts";
-
-type ReviewerLegRunResultCommon = Readonly<{ target: ReviewerTargetSnapshot; prompt: ReviewerPromptText; workspaceDisposition: ReviewerWorkspaceDisposition }>;
-export type ReviewerSuccessfulLegRunResult = ReviewerLegRunResultCommon & Readonly<{ status: "successful"; report: unknown; usage: ReviewerUsage; failure?: never }>;
-export type ReviewerFailedLegRunResult = ReviewerLegRunResultCommon & Readonly<{ status: "failed"; failure: ReviewerFailureClassification; diagnostic: string; cause?: unknown; report?: never; usage?: never }>;
-export type ReviewerLegRunResult = ReviewerSuccessfulLegRunResult | ReviewerFailedLegRunResult;
-type Envelope<L> = Readonly<{ identity: string; target: ReviewerTargetSnapshot; legs: Readonly<L> }>;
-export type ReviewerDispatchRunResult = Envelope<{ standards: ReviewerLegRunResult; spec?: never }> | Envelope<{ standards: ReviewerLegRunResult; spec: ReviewerLegRunResult }>;
-export type ReviewerSuccessfulDispatchRunResult = Envelope<{ standards: ReviewerSuccessfulLegRunResult; spec?: never }> | Envelope<{ standards: ReviewerSuccessfulLegRunResult; spec: ReviewerSuccessfulLegRunResult }>;
-function reviewerDispatchFailureMessage(outcome: ReviewerDispatchRunResult): string {
-  const diagnostics = [...new Set(
-    Object.values(outcome.legs)
-      .filter((leg): leg is ReviewerFailedLegRunResult => leg?.status === "failed")
-      .map((leg) => leg.diagnostic.trim())
-      .filter((diagnostic) => diagnostic.length > 0),
-  )];
-  if (diagnostics.length === 0) return "Reviewer dispatch execution failed";
-  return diagnostics.length === 1 ? diagnostics[0]! : diagnostics.join("; ");
-}
-export class ReviewerDispatchExecutionError extends Error {
-  constructor(readonly outcome: ReviewerDispatchRunResult) {
-    super(reviewerDispatchFailureMessage(outcome));
-    this.name = "ReviewerDispatchExecutionError";
-  }
-}
-export type ReviewerDispatchRunOptions = Readonly<{
-  context: HostContext;
-  signal?: AbortSignal;
-  /**
-   * Request-scoped RoleHost flag reader (#818).
-   * Forwards to axis sub-session so envelope legs arm engine from request.engine,
-   * not ambient process.env (same resolveEngineName gate as parent registration).
-   */
-  getFlag?: (name: string) => boolean | string | undefined;
-}>;
-export type ReviewerAgentRunner = { run(dispatch: AcceptedReviewerExecution, options: ReviewerDispatchRunOptions): Promise<ReviewerSuccessfulDispatchRunResult>; shutdown(): Promise<void> };
-export type ReviewerAgentFaultPoint = ReviewerWorkspaceFaultPoint;
-type Dependencies = Readonly<{
-  fault?(operation: ReviewerAgentFaultPoint): void;
-  /** When set, child credential/config scratch is created under this parent so cleanup proofs stay process-local. */
-  credentialScratchParent?: string;
-  /** Package root for optional engine method-material on legs (#378). */
-  packageRoot?: string;
-}>;
-function classify(error: unknown, signal?: AbortSignal): ReviewerFailureClassification { if (signal?.aborted) return "cancelled"; if (typeof error === "object" && error !== null && "reviewerFailure" in error) return (error as { reviewerFailure: ReviewerFailureClassification }).reviewerFailure; return "unknown"; }
-function failed(error: unknown, target: ReviewerTargetSnapshot, prompt: ReviewerPromptText, signal?: AbortSignal, retained?: string): ReviewerFailedLegRunResult {
-  const attached = typeof error === "object" && error !== null ? error as { targetSnapshot?: ReviewerTargetSnapshot; workspaceDisposition?: ReviewerWorkspaceDisposition } : {};
-  const failure = classify(error, signal);
-  const diagnostic = normalizeReviewerFailureDiagnostic(error, failure);
-  return Object.freeze({
-    status: "failed",
-    failure,
-    diagnostic,
-    cause: error,
-    target: attached.targetSnapshot ?? target,
-    prompt,
-    workspaceDisposition: retained === undefined ? attached.workspaceDisposition ?? "not-created" : { retained },
-  });
-}
-export function createReviewerAgentRunner(dependencies: Dependencies = {}): ReviewerAgentRunner {
-  const workspaceOwner = createReviewerWorkspaceOwner(dependencies.fault === undefined ? {} : { fault: dependencies.fault }); let accepted = false;
-  return {
-    async run(dispatch, options) {
-      if (dispatch.recipe !== "reviewer-common-bundle-v1" || dispatch.legs.length < 1 || dispatch.legs.length > 2 || dispatch.legs[0]?.axis !== "standards" || (dispatch.legs.length === 2 && dispatch.legs[1]?.axis !== "spec")) throw new Error("Invalid accepted Reviewer dispatch cardinality or axes");
-      if (accepted) throw new Error("Reviewer runner accepts exactly one dispatch"); accepted = true;
-      for (const leg of dispatch.legs) if (!isReviewerPromptText(leg.prompt)) throw new Error("Accepted Reviewer prompt evidence mismatch");
-      let batch;
-      try { batch = await workspaceOwner.prepare(dispatch.targetSnapshot, dispatch.legs.map(l => l.axis), options.signal); }
-      catch (error) {
-        const prepared = typeof error === "object" && error !== null && "preparedWorkspaces" in error ? (error as { preparedWorkspaces?: readonly { axis: string; path: string }[] }).preparedWorkspaces ?? [] : [];
-        const failedIndex = prepared.length;
-        const legs = Object.fromEntries(dispatch.legs.map((leg, index) => [leg.axis, failed(error, dispatch.targetSnapshot, leg.prompt, options.signal, index < failedIndex ? prepared[index]!.path : undefined)]));
-        // Siblings not yet attempted have no workspace; do not borrow the failed leg's retained path.
-        for (let index = failedIndex + 1; index < dispatch.legs.length; index += 1) { const axis = dispatch.legs[index]!.axis; legs[axis] = Object.freeze({ ...legs[axis]!, workspaceDisposition: "not-created" }); }
-        const target = Object.values(legs)[0]!.target; throw new ReviewerDispatchExecutionError(Object.freeze({ identity: dispatch.identity, target, legs: Object.freeze(legs) }) as ReviewerDispatchRunResult);
-      }
-      const settled = await Promise.allSettled(batch.workspaces.map(async workspace => {
-        const leg = dispatch.legs.find(candidate => candidate.axis === workspace.axis)!;
-        try {
-          const child = await executeReviewerChild(workspace.path, leg, options.context, {
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            ...(dependencies.credentialScratchParent === undefined
-              ? {}
-              : { credentialScratchParent: dependencies.credentialScratchParent }),
-            ...(dependencies.packageRoot === undefined
-              ? {}
-              : { packageRoot: dependencies.packageRoot }),
-            ...(options.getFlag === undefined ? {} : { getFlag: options.getFlag }),
-          });
-          const disposition = await workspaceOwner.dispose(workspace);
-          return [leg.axis, Object.freeze({ status: "successful" as const, report: child.report, usage: child.usage, target: batch.target, prompt: child.prompt, workspaceDisposition: disposition })] as const;
-        } catch (error) {
-          // Failed legs retain their workspace for the durable failure evidence and caller cleanup.
-          return [leg.axis, failed(error, batch.target, leg.prompt, options.signal, workspace.path)] as const;
-        }
-      }));
-      const pairs = settled.map(item => item.status === "fulfilled" ? item.value : (() => { throw item.reason; })());
-      const outcome = Object.freeze({ identity: dispatch.identity, target: batch.target, legs: Object.freeze(Object.fromEntries(pairs)) }) as ReviewerDispatchRunResult;
-      if (Object.values(outcome.legs).some(leg => leg?.status === "failed")) throw new ReviewerDispatchExecutionError(outcome);
-      return outcome as ReviewerSuccessfulDispatchRunResult;
-    },
-    shutdown: () => workspaceOwner.shutdown(),
-  };
-}
-
-/**
- * Host-level Reviewer binding: each accepted dispatch gets a fresh one-shot runner.
- * Auto-resume turns must not reuse the inner one-shot slot.
- */
-export function createPerDispatchReviewerAgent(dependencies: Dependencies = {}): ReviewerAgentRunner {
-  const active = new Set<ReviewerAgentRunner>();
-  return {
-    async run(dispatch, options) {
-      const runner = createReviewerAgentRunner(dependencies);
-      active.add(runner);
-      try {
-        return await runner.run(dispatch, options);
-      } finally {
-        active.delete(runner);
-        await runner.shutdown();
-      }
-    },
-    async shutdown() {
-      const runners = [...active];
-      active.clear();
-      await Promise.all(runners.map((runner) => runner.shutdown()));
-    },
-  };
-}