@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/chunk-X75E3D2N.js

@@ -0,0 +1,686 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  parseJsonObjectPayload,
+  parseVerifierResult
+} from "./chunk-DYJP44XW.js";
+import {
+  atomicWrite
+} from "./chunk-76ONBSIA.js";
+import {
+  clioStateDir
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/gate-decisions.ts
+init_esm_shims();
+import { createHash, randomBytes } from "node:crypto";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+function parseReviewGateResult(output) {
+  const result = parseVerifierResult(output);
+  return result === null ? { ok: false, reason: "reviewer did not return a valid verifier report" } : { ok: true, result };
+}
+function decideReviewGate(input) {
+  const base = {
+    group: input.group,
+    topology: "review",
+    cycle: input.cycle,
+    subjects: input.subjects,
+    decider: input.decider,
+    correlation: input.correlation
+  };
+  const parsed = parseReviewGateResult(input.output);
+  if (!parsed.ok) {
+    return {
+      draft: { ...base, outcome: "exhausted", detail: parsed.reason },
+      verdict: null,
+      findings: null,
+      needsDecision: `review gate produced no structured verdict in cycle ${input.cycle}: ${parsed.reason}`
+    };
+  }
+  if (parsed.result.verdict === "pass" || input.terminalCycle) {
+    return {
+      draft: { ...base, outcome: parsed.result.verdict },
+      verdict: parsed.result.verdict,
+      findings: null,
+      needsDecision: null
+    };
+  }
+  const failed = parsed.result.checks.filter((check) => !check.passed);
+  return {
+    draft: { ...base, outcome: "revise", detail: `reviewer reported ${failed.length} failed check(s)` },
+    verdict: null,
+    findings: JSON.stringify({ verdict: "fail", checks: failed }),
+    needsDecision: null
+  };
+}
+function parseGateChecks(value) {
+  if (!Array.isArray(value) || value.length === 0) return null;
+  const checks = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) return null;
+    const keys = Object.keys(entry);
+    if (keys.some((key) => key !== "name" && key !== "passed" && key !== "evidence") || typeof entry.name !== "string" || entry.name.trim().length === 0 || typeof entry.passed !== "boolean" || typeof entry.evidence !== "string" || entry.evidence.trim().length === 0) {
+      return null;
+    }
+    checks.push({ name: entry.name, passed: entry.passed, evidence: entry.evidence });
+  }
+  return checks;
+}
+function parseCompeteGateResult(output, candidateCount) {
+  const parsed = parseJsonObjectPayload(output);
+  if (!parsed.ok) {
+    return {
+      ok: false,
+      reason: parsed.reason === "not-object" ? "judge result must be a JSON object" : "judge result must be valid JSON"
+    };
+  }
+  const value = parsed.value;
+  if (Object.keys(value).some((key) => key !== "winner" && key !== "checks")) {
+    return { ok: false, reason: "judge result has unknown fields" };
+  }
+  const winner = value.winner;
+  if (typeof winner !== "number" || !Number.isSafeInteger(winner) || winner < 1 || winner > candidateCount) {
+    return { ok: false, reason: `judge winner must be an integer 1..${candidateCount}` };
+  }
+  const checks = parseGateChecks(value.checks);
+  if (checks === null) return { ok: false, reason: "judge result must carry typed checks with evidence" };
+  return { ok: true, result: { winner, checks } };
+}
+function gateDecisionsDirectory(stateDir = clioStateDir()) {
+  return join(stateDir, "gate-decisions");
+}
+function decisionsDirectory(stateDir = clioStateDir()) {
+  return gateDecisionsDirectory(stateDir);
+}
+function pendingDecisionsDirectory(stateDir = clioStateDir()) {
+  return join(decisionsDirectory(stateDir), "pending");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSubjectRef(value) {
+  if (!isRecord(value) || typeof value.runId !== "string" || value.runId.trim().length === 0) return false;
+  return typeof value.digest === "string" && /^[0-9a-f]{64}$/.test(value.digest);
+}
+function isSafeDecisionId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 256 && /^[A-Za-z0-9._-]+$/.test(value);
+}
+function isCorrelation(value) {
+  if (!isRecord(value)) return false;
+  const fields = ["agent", "target", "modelFamily", "runtime", "node", "independent"];
+  if (Object.keys(value).some((key) => !fields.includes(key))) return false;
+  if (!fields.every((field) => typeof value[field] === "boolean")) return false;
+  return value.independent === (!value.agent && !value.modelFamily);
+}
+function semanticError(value) {
+  if (!isRecord(value)) return "gate decision is not an object";
+  if (value.version !== 2) return "unsupported gate decision version";
+  if (!isSafeDecisionId(value.id)) return "gate decision id invalid";
+  if (typeof value.group !== "string" || value.group.length === 0) return "gate decision group invalid";
+  if (value.topology !== "review" && value.topology !== "compete") return "gate decision topology invalid";
+  if (typeof value.cycle !== "number" || !Number.isInteger(value.cycle) || value.cycle < 1) {
+    return "gate decision cycle invalid";
+  }
+  const reviewOutcome = value.outcome === "pass" || value.outcome === "fail" || value.outcome === "revise" || value.outcome === "exhausted";
+  const competeOutcome = value.outcome === "winner" || value.outcome === "no-winner" || value.outcome === "operator-confirmed" || value.outcome === "full-auto-applied";
+  if (value.topology === "review" && !reviewOutcome || value.topology === "compete" && !competeOutcome) {
+    return "gate decision outcome is incompatible with topology";
+  }
+  if (!Array.isArray(value.subjects) || value.subjects.length === 0 || !value.subjects.every(isSubjectRef)) {
+    return "gate decision subjects invalid";
+  }
+  if (value.decider !== void 0 && !isSubjectRef(value.decider)) return "gate decision decider invalid";
+  if (value.decider === void 0) {
+    if (value.correlation !== void 0) return "gate decision correlation requires a decider";
+  } else if (!isCorrelation(value.correlation)) {
+    return "gate decision correlation invalid";
+  }
+  if (typeof value.createdAt !== "string" || !Number.isFinite(Date.parse(value.createdAt))) {
+    return "gate decision timestamp invalid";
+  }
+  const needsWinner = value.outcome === "winner" || value.outcome === "operator-confirmed" || value.outcome === "full-auto-applied";
+  if (needsWinner) {
+    if (!isRecord(value.winner) || typeof value.winner.index !== "number" || !Number.isInteger(value.winner.index) || value.winner.index < 1 || !isSubjectRef(value.winner.subject) || typeof value.winner.branch !== "string" || value.winner.branch !== `clio/compete/${value.group}/${value.winner.index}`) {
+      return "gate decision winner invalid";
+    }
+    const winnerSubject = value.winner.subject;
+    if (!value.subjects.some((subject) => subject.runId === winnerSubject.runId)) {
+      return "gate decision winner is not a subject";
+    }
+  } else if (value.winner !== void 0) {
+    return "gate decision winner is not valid for this outcome";
+  }
+  const needsConfirmation = value.outcome === "operator-confirmed" || value.outcome === "full-auto-applied";
+  if (needsConfirmation) {
+    if (!isRecord(value.confirmation) || typeof value.confirmation.id !== "string" || value.confirmation.id.length === 0 || typeof value.confirmation.digest !== "string" || !/^[0-9a-f]{64}$/.test(value.confirmation.digest)) {
+      return "gate decision confirmation invalid";
+    }
+  } else if (value.confirmation !== void 0) {
+    return "gate decision confirmation is not valid for this outcome";
+  }
+  if (value.detail !== void 0 && typeof value.detail !== "string") return "gate decision detail invalid";
+  if (!isRecord(value.integrity) || value.integrity.algorithm !== "sha256" || typeof value.integrity.digest !== "string") {
+    return "gate decision integrity invalid";
+  }
+  return null;
+}
+function safeGroup(group) {
+  const safe = group.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128);
+  return safe.length > 0 ? safe : "gate";
+}
+function newDecisionId(group) {
+  return `${safeGroup(group)}-${Date.now().toString(36)}-${randomBytes(6).toString("hex")}`;
+}
+function decisionArtifactPath(id, stateDir = clioStateDir()) {
+  return join(decisionsDirectory(stateDir), `${id}.json`);
+}
+function pendingDecisionPath(id, stateDir = clioStateDir()) {
+  return join(pendingDecisionsDirectory(stateDir), `${id}.json`);
+}
+function decisionPayload(decision) {
+  return {
+    contract: "clio.gateDecision.integrity",
+    version: decision.version,
+    id: decision.id,
+    group: decision.group,
+    topology: decision.topology,
+    cycle: decision.cycle,
+    outcome: decision.outcome,
+    subjects: decision.subjects.map((subject) => ({ runId: subject.runId, digest: subject.digest })),
+    ...decision.decider !== void 0 ? { decider: { runId: decision.decider.runId, digest: decision.decider.digest } } : {},
+    ...decision.correlation !== void 0 ? { correlation: { ...decision.correlation } } : {},
+    ...decision.winner !== void 0 ? {
+      winner: {
+        index: decision.winner.index,
+        subject: {
+          runId: decision.winner.subject.runId,
+          digest: decision.winner.subject.digest
+        },
+        branch: decision.winner.branch
+      }
+    } : {},
+    ...decision.confirmation !== void 0 ? { confirmation: { id: decision.confirmation.id, digest: decision.confirmation.digest } } : {},
+    ...decision.detail !== void 0 ? { detail: decision.detail } : {},
+    createdAt: decision.createdAt
+  };
+}
+function decisionDigest(decision) {
+  return createHash("sha256").update(JSON.stringify(decisionPayload(decision)), "utf8").digest("hex");
+}
+function artifactWithoutIntegrity(artifact) {
+  const result = {
+    version: artifact.version,
+    id: artifact.id,
+    group: artifact.group,
+    topology: artifact.topology,
+    cycle: artifact.cycle,
+    outcome: artifact.outcome,
+    subjects: artifact.subjects.map((subject) => ({ ...subject })),
+    createdAt: artifact.createdAt
+  };
+  if (artifact.decider !== void 0) result.decider = { ...artifact.decider };
+  if (artifact.correlation !== void 0) result.correlation = { ...artifact.correlation };
+  if (artifact.winner !== void 0) {
+    result.winner = {
+      index: artifact.winner.index,
+      subject: { ...artifact.winner.subject },
+      branch: artifact.winner.branch
+    };
+  }
+  if (artifact.confirmation !== void 0) result.confirmation = { ...artifact.confirmation };
+  if (artifact.detail !== void 0) result.detail = artifact.detail;
+  return result;
+}
+function verifyGateDecisionArtifact(artifact) {
+  const invalid = semanticError(artifact);
+  if (invalid !== null) return { ok: false, reason: invalid };
+  if (!/^[0-9a-f]{64}$/.test(artifact.integrity.digest)) return { ok: false, reason: "gate decision integrity invalid" };
+  return decisionDigest(artifactWithoutIntegrity(artifact)) === artifact.integrity.digest ? { ok: true } : { ok: false, reason: "gate decision integrity mismatch" };
+}
+function buildGateDecisionArtifact(draft, id = newDecisionId(draft.group), createdAt = draft.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()) {
+  if (draft.group.trim().length === 0) throw new Error("gate decision group is required");
+  if (!Number.isInteger(draft.cycle) || draft.cycle < 1)
+    throw new Error("gate decision cycle must be a positive integer");
+  if (draft.subjects.length === 0) throw new Error("gate decision requires at least one subject receipt");
+  const withoutIntegrity = {
+    version: 2,
+    id,
+    group: draft.group,
+    topology: draft.topology,
+    cycle: draft.cycle,
+    outcome: draft.outcome,
+    subjects: draft.subjects.map((subject) => ({ ...subject })),
+    createdAt
+  };
+  if (draft.decider !== void 0) withoutIntegrity.decider = { ...draft.decider };
+  if (draft.correlation !== void 0) withoutIntegrity.correlation = { ...draft.correlation };
+  if (draft.winner !== void 0) {
+    withoutIntegrity.winner = {
+      index: draft.winner.index,
+      subject: { ...draft.winner.subject },
+      branch: draft.winner.branch
+    };
+  }
+  if (draft.confirmation !== void 0) withoutIntegrity.confirmation = { ...draft.confirmation };
+  if (draft.detail !== void 0) withoutIntegrity.detail = draft.detail;
+  const artifact = {
+    ...withoutIntegrity,
+    integrity: { algorithm: "sha256", digest: decisionDigest(withoutIntegrity) }
+  };
+  const verification = verifyGateDecisionArtifact(artifact);
+  if (!verification.ok) throw new Error(verification.reason);
+  return artifact;
+}
+function readVerifiedArtifact(path) {
+  let value;
+  try {
+    value = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `gate decision artifact is unreadable at ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const artifact = value;
+  const verification = verifyGateDecisionArtifact(artifact);
+  if (!verification.ok) throw new Error(`gate decision artifact is invalid at ${path}: ${verification.reason}`);
+  return artifact;
+}
+function persistGateDecisionArtifact(artifact, stateDir, allowIdenticalExisting) {
+  const verification = verifyGateDecisionArtifact(artifact);
+  if (!verification.ok) throw new Error(verification.reason);
+  const directory = decisionsDirectory(stateDir);
+  mkdirSync(directory, { recursive: true });
+  const path = decisionArtifactPath(artifact.id, stateDir);
+  if (existsSync(path)) {
+    const existing = readVerifiedArtifact(path);
+    if (allowIdenticalExisting && existing.id === artifact.id && existing.integrity.digest === artifact.integrity.digest) {
+      return { artifact: existing, path };
+    }
+    throw new Error(`gate decision artifact collision: ${artifact.id}`);
+  }
+  atomicWrite(path, JSON.stringify(artifact, null, 2));
+  return { artifact, path };
+}
+function cloneGateDecisionArtifact(artifact) {
+  return {
+    ...artifactWithoutIntegrity(artifact),
+    integrity: { ...artifact.integrity }
+  };
+}
+function pendingRecordPayload(record) {
+  if (record.kind === "output") {
+    return {
+      contract: "clio.gateDecision.pending",
+      version: record.version,
+      kind: record.kind,
+      id: record.id,
+      group: record.group,
+      topology: record.topology,
+      cycle: record.cycle,
+      subjects: record.subjects.map((subject) => ({ runId: subject.runId, digest: subject.digest })),
+      deciderRunId: record.deciderRunId,
+      finalOutput: record.finalOutput,
+      ...record.terminalCycle !== void 0 ? { terminalCycle: record.terminalCycle } : {},
+      ...record.resourceRoot !== void 0 ? { resourceRoot: record.resourceRoot } : {},
+      createdAt: record.createdAt
+    };
+  }
+  const decisionWithoutIntegrity = artifactWithoutIntegrity(record.decision);
+  return {
+    contract: "clio.gateDecision.pending",
+    version: record.version,
+    kind: record.kind,
+    id: record.id,
+    decision: {
+      ...decisionPayload(decisionWithoutIntegrity),
+      integrity: { ...record.decision.integrity }
+    },
+    ...record.finalOutput !== void 0 ? { finalOutput: record.finalOutput } : {},
+    ...record.resourceRoot !== void 0 ? { resourceRoot: record.resourceRoot } : {},
+    createdAt: record.createdAt
+  };
+}
+function pendingRecordDigest(record) {
+  return createHash("sha256").update(JSON.stringify(pendingRecordPayload(record)), "utf8").digest("hex");
+}
+function pendingRecordWithoutIntegrity(record) {
+  if (record.kind === "output") {
+    return {
+      version: record.version,
+      kind: record.kind,
+      id: record.id,
+      group: record.group,
+      topology: record.topology,
+      cycle: record.cycle,
+      subjects: record.subjects.map((subject) => ({ ...subject })),
+      deciderRunId: record.deciderRunId,
+      finalOutput: record.finalOutput,
+      ...record.terminalCycle !== void 0 ? { terminalCycle: record.terminalCycle } : {},
+      ...record.resourceRoot !== void 0 ? { resourceRoot: record.resourceRoot } : {},
+      createdAt: record.createdAt
+    };
+  }
+  return {
+    version: record.version,
+    kind: record.kind,
+    id: record.id,
+    decision: cloneGateDecisionArtifact(record.decision),
+    ...record.finalOutput !== void 0 ? { finalOutput: record.finalOutput } : {},
+    ...record.resourceRoot !== void 0 ? { resourceRoot: record.resourceRoot } : {},
+    createdAt: record.createdAt
+  };
+}
+function pendingSemanticError(value) {
+  if (!isRecord(value)) return "pending gate decision is not an object";
+  if (value.version !== 1) return "unsupported pending gate decision version";
+  if (!isSafeDecisionId(value.id)) return "pending gate decision id invalid";
+  if (typeof value.createdAt !== "string" || !Number.isFinite(Date.parse(value.createdAt))) {
+    return "pending gate decision timestamp invalid";
+  }
+  if (!isRecord(value.integrity) || value.integrity.algorithm !== "sha256" || typeof value.integrity.digest !== "string" || !/^[0-9a-f]{64}$/.test(value.integrity.digest)) {
+    return "pending gate decision integrity invalid";
+  }
+  if (value.kind === "output") {
+    if (typeof value.group !== "string" || value.group.trim().length === 0) {
+      return "pending gate output group invalid";
+    }
+    if (value.topology !== "review" && value.topology !== "compete") {
+      return "pending gate output topology invalid";
+    }
+    if (typeof value.cycle !== "number" || !Number.isInteger(value.cycle) || value.cycle < 1) {
+      return "pending gate output cycle invalid";
+    }
+    if (!Array.isArray(value.subjects) || value.subjects.length === 0 || !value.subjects.every(isSubjectRef)) {
+      return "pending gate output subjects invalid";
+    }
+    if (typeof value.deciderRunId !== "string" || value.deciderRunId.trim().length === 0) {
+      return "pending gate output decider run id invalid";
+    }
+    if (typeof value.finalOutput !== "string") return "pending gate output text invalid";
+    if (value.terminalCycle !== void 0 && typeof value.terminalCycle !== "boolean") {
+      return "pending gate output terminal-cycle marker invalid";
+    }
+    if (value.resourceRoot !== void 0 && (typeof value.resourceRoot !== "string" || value.resourceRoot.length === 0)) {
+      return "pending gate output resource root invalid";
+    }
+    return null;
+  }
+  if (value.kind !== "decision") return "pending gate decision kind invalid";
+  if (!isRecord(value.decision)) return "pending gate decision artifact invalid";
+  const verification = verifyGateDecisionArtifact(value.decision);
+  if (!verification.ok) return `pending gate decision artifact invalid: ${verification.reason}`;
+  if (value.decision.id !== value.id) return "pending gate decision artifact id mismatch";
+  if (value.decision.createdAt !== value.createdAt) return "pending gate decision artifact timestamp mismatch";
+  if (value.finalOutput !== void 0 && typeof value.finalOutput !== "string") {
+    return "pending gate decision output invalid";
+  }
+  if (value.resourceRoot !== void 0 && (typeof value.resourceRoot !== "string" || value.resourceRoot.length === 0)) {
+    return "pending gate decision resource root invalid";
+  }
+  return null;
+}
+function verifyPendingGateDecisionRecord(record) {
+  const invalid = pendingSemanticError(record);
+  if (invalid !== null) return { ok: false, reason: invalid };
+  return pendingRecordDigest(pendingRecordWithoutIntegrity(record)) === record.integrity.digest ? { ok: true } : { ok: false, reason: "pending gate decision integrity mismatch" };
+}
+function clonePendingGateDecisionRecord(record) {
+  const without = pendingRecordWithoutIntegrity(record);
+  return {
+    ...without,
+    integrity: { ...record.integrity }
+  };
+}
+function parsePendingGateDecisionRecord(value) {
+  const invalid = pendingSemanticError(value);
+  if (invalid !== null) throw new Error(invalid);
+  const record = clonePendingGateDecisionRecord(value);
+  const verification = verifyPendingGateDecisionRecord(record);
+  if (!verification.ok) throw new Error(verification.reason);
+  return record;
+}
+function assertPendingHandlePath(handle) {
+  const expected = pendingDecisionPath(handle.record.id, handle.stateDir);
+  if (resolve(handle.path) !== resolve(expected)) {
+    throw new Error(`pending gate decision path does not match id ${handle.record.id}`);
+  }
+}
+function pendingHandle(record, stateDir) {
+  return {
+    record: clonePendingGateDecisionRecord(record),
+    path: pendingDecisionPath(record.id, stateDir),
+    stateDir
+  };
+}
+function persistPendingGateDecision(record, stateDir, allowReplace) {
+  const verification = verifyPendingGateDecisionRecord(record);
+  if (!verification.ok) throw new Error(verification.reason);
+  const path = pendingDecisionPath(record.id, stateDir);
+  mkdirSync(dirname(path), { recursive: true });
+  if (!allowReplace && existsSync(path)) throw new Error(`pending gate decision collision: ${record.id}`);
+  atomicWrite(path, JSON.stringify(record, null, 2));
+  return pendingHandle(record, stateDir);
+}
+function loadPendingGateDecision(handle) {
+  assertPendingHandlePath(handle);
+  if (!existsSync(handle.path)) return null;
+  const record = parsePendingGateDecisionRecord(JSON.parse(readFileSync(handle.path, "utf8")));
+  if (record.id !== handle.record.id) throw new Error("pending gate decision changed identity on disk");
+  return pendingHandle(record, handle.stateDir);
+}
+function fsyncDirectoryBestEffort(path) {
+  let fd = null;
+  try {
+    fd = openSync(path, "r");
+    fsyncSync(fd);
+  } catch {
+  } finally {
+    if (fd !== null) closeSync(fd);
+  }
+}
+function clearPendingGateDecision(handle) {
+  assertPendingHandlePath(handle);
+  rmSync(handle.path, { force: true });
+  fsyncDirectoryBestEffort(dirname(handle.path));
+}
+function sameSubjectRefs(left, right) {
+  return left.length === right.length && left.every((subject, index) => {
+    const other = right[index];
+    return other !== void 0 && subject.runId === other.runId && subject.digest === other.digest;
+  });
+}
+function stagePendingGateOutput(draft, stateDir = clioStateDir()) {
+  const id = newDecisionId(draft.group);
+  const withoutIntegrity = {
+    version: 1,
+    kind: "output",
+    id,
+    group: draft.group,
+    topology: draft.topology,
+    cycle: draft.cycle,
+    subjects: draft.subjects.map((subject) => ({ ...subject })),
+    deciderRunId: draft.deciderRunId,
+    finalOutput: draft.finalOutput,
+    ...draft.terminalCycle !== void 0 ? { terminalCycle: draft.terminalCycle } : {},
+    ...draft.resourceRoot !== void 0 ? { resourceRoot: draft.resourceRoot } : {},
+    createdAt: draft.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const record = {
+    ...withoutIntegrity,
+    integrity: { algorithm: "sha256", digest: pendingRecordDigest(withoutIntegrity) }
+  };
+  if (existsSync(decisionArtifactPath(id, stateDir))) throw new Error(`gate decision artifact collision: ${id}`);
+  return persistPendingGateDecision(record, stateDir, false);
+}
+function stagePendingGateDecision(draft, options = {}) {
+  const stateDir = options.stateDir ?? clioStateDir();
+  const id = newDecisionId(draft.group);
+  const createdAt = draft.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const decision = buildGateDecisionArtifact(draft, id, createdAt);
+  const withoutIntegrity = {
+    version: 1,
+    kind: "decision",
+    id,
+    decision,
+    ...options.finalOutput !== void 0 ? { finalOutput: options.finalOutput } : {},
+    ...options.resourceRoot !== void 0 ? { resourceRoot: options.resourceRoot } : {},
+    createdAt
+  };
+  const record = {
+    ...withoutIntegrity,
+    integrity: { algorithm: "sha256", digest: pendingRecordDigest(withoutIntegrity) }
+  };
+  if (existsSync(decisionArtifactPath(id, stateDir))) throw new Error(`gate decision artifact collision: ${id}`);
+  return persistPendingGateDecision(record, stateDir, false);
+}
+function resolvePendingGateDecision(handle, draft) {
+  const loaded = loadPendingGateDecision(handle);
+  if (loaded === null) throw new Error(`pending gate decision is missing: ${handle.record.id}`);
+  if (loaded.record.kind === "decision") {
+    const expected = buildGateDecisionArtifact(draft, loaded.record.id, loaded.record.createdAt);
+    if (expected.integrity.digest !== loaded.record.decision.integrity.digest) {
+      throw new Error("pending gate decision was already resolved to a different artifact");
+    }
+    return loaded;
+  }
+  const pending = loaded.record;
+  if (draft.group !== pending.group || draft.topology !== pending.topology || draft.cycle !== pending.cycle || !sameSubjectRefs(draft.subjects, pending.subjects)) {
+    throw new Error("resolved gate decision does not match staged output context");
+  }
+  if (draft.decider === void 0 || draft.decider.runId !== pending.deciderRunId) {
+    throw new Error("resolved gate decision does not match staged decider run");
+  }
+  if (draft.createdAt !== void 0 && draft.createdAt !== pending.createdAt) {
+    throw new Error("resolved gate decision cannot change the staged timestamp");
+  }
+  const decision = buildGateDecisionArtifact(draft, pending.id, pending.createdAt);
+  const withoutIntegrity = {
+    version: 1,
+    kind: "decision",
+    id: pending.id,
+    decision,
+    finalOutput: pending.finalOutput,
+    ...pending.resourceRoot !== void 0 ? { resourceRoot: pending.resourceRoot } : {},
+    createdAt: pending.createdAt
+  };
+  const resolvedRecord = {
+    ...withoutIntegrity,
+    integrity: { algorithm: "sha256", digest: pendingRecordDigest(withoutIntegrity) }
+  };
+  return persistPendingGateDecision(resolvedRecord, loaded.stateDir, true);
+}
+function materializePendingGateDecision(handle) {
+  const loaded = loadPendingGateDecision(handle);
+  if (loaded === null) {
+    if (handle.record.kind !== "decision") {
+      throw new Error(`pending gate output is missing before resolution: ${handle.record.id}`);
+    }
+    const path = decisionArtifactPath(handle.record.decision.id, handle.stateDir);
+    if (!existsSync(path)) throw new Error(`pending gate decision and artifact are both missing: ${handle.record.id}`);
+    const artifact = readVerifiedArtifact(path);
+    if (artifact.integrity.digest !== handle.record.decision.integrity.digest) {
+      throw new Error(`gate decision artifact conflicts with completed pending record: ${handle.record.id}`);
+    }
+    return { artifact, path };
+  }
+  if (loaded.record.kind !== "decision") {
+    throw new Error(`pending gate output requires receipt resolution: ${loaded.record.id}`);
+  }
+  const written = persistGateDecisionArtifact(loaded.record.decision, loaded.stateDir, true);
+  const persisted = readVerifiedArtifact(written.path);
+  if (persisted.integrity.digest !== loaded.record.decision.integrity.digest) {
+    throw new Error(`materialized gate decision does not match pending record: ${loaded.record.id}`);
+  }
+  clearPendingGateDecision(loaded);
+  return { artifact: persisted, path: written.path };
+}
+function finalizePendingGateDecision(handle, draft) {
+  return materializePendingGateDecision(resolvePendingGateDecision(handle, draft));
+}
+function readPendingGateDecisions(stateDir = clioStateDir()) {
+  const directory = pendingDecisionsDirectory(stateDir);
+  if (!existsSync(directory)) return { records: [], errors: [] };
+  const records = [];
+  const errors = [];
+  for (const name of readdirSync(directory).filter((entry) => entry.endsWith(".json")).sort()) {
+    const path = join(directory, name);
+    try {
+      const record = parsePendingGateDecisionRecord(JSON.parse(readFileSync(path, "utf8")));
+      if (name !== `${record.id}.json`) throw new Error("pending gate decision filename does not match its id");
+      records.push({ record, path, stateDir });
+    } catch (error) {
+      errors.push({ path, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { records, errors };
+}
+function preflightPendingGateDecisionMaterialization(handles) {
+  for (const handle of handles) {
+    if (handle.record.kind !== "decision") continue;
+    const path = decisionArtifactPath(handle.record.decision.id, handle.stateDir);
+    if (!existsSync(path)) continue;
+    const existing = readVerifiedArtifact(path);
+    if (existing.integrity.digest !== handle.record.decision.integrity.digest) {
+      throw new Error(`gate decision artifact conflicts with pending record: ${handle.record.id}`);
+    }
+  }
+}
+function preparePendingGateDecisionRecovery(stateDir = clioStateDir()) {
+  const pending = readPendingGateDecisions(stateDir);
+  if (pending.errors.length > 0) {
+    throw new Error(
+      `pending gate decision journal is untrustworthy: ${pending.errors.map((entry) => `${entry.path}: ${entry.message}`).join("; ")}`
+    );
+  }
+  const ready = pending.records.filter((handle) => handle.record.kind === "decision");
+  preflightPendingGateDecisionMaterialization(ready);
+  return {
+    ready,
+    unresolved: pending.records.filter((handle) => handle.record.kind === "output")
+  };
+}
+function readGateDecisionArtifacts(group, stateDir = clioStateDir()) {
+  const directory = decisionsDirectory(stateDir);
+  if (!existsSync(directory)) return [];
+  const out = [];
+  for (const name of readdirSync(directory).filter((entry) => entry.endsWith(".json")).sort()) {
+    const path = join(directory, name);
+    try {
+      const artifact = JSON.parse(readFileSync(path, "utf8"));
+      if (group !== void 0 && artifact.group !== group) continue;
+      if (!verifyGateDecisionArtifact(artifact).ok) continue;
+      out.push({ artifact, path });
+    } catch {
+    }
+  }
+  return out;
+}
+function readGateDecisionArtifactsForRunIds(runIds, stateDir = clioStateDir()) {
+  if (runIds.size === 0) return [];
+  return readGateDecisionArtifacts(void 0, stateDir).filter(({ artifact }) => {
+    if (artifact.subjects.some((subject) => runIds.has(subject.runId))) return true;
+    if (artifact.decider !== void 0 && runIds.has(artifact.decider.runId)) return true;
+    return artifact.winner !== void 0 && runIds.has(artifact.winner.subject.runId);
+  });
+}
+
+export {
+  decideReviewGate,
+  parseCompeteGateResult,
+  gateDecisionsDirectory,
+  verifyGateDecisionArtifact,
+  stagePendingGateOutput,
+  stagePendingGateDecision,
+  resolvePendingGateDecision,
+  materializePendingGateDecision,
+  finalizePendingGateDecision,
+  readPendingGateDecisions,
+  preflightPendingGateDecisionMaterialization,
+  preparePendingGateDecisionRecovery,
+  readGateDecisionArtifacts,
+  readGateDecisionArtifactsForRunIds
+};
+//# sourceMappingURL=chunk-X75E3D2N.js.map