@graphrefly/ts 0.0.1 → 0.0.3

package/dist/chunk-MCOFHMUU.js

@@ -0,0 +1,4131 @@
+import {
+  requestToolProviderAdapterRun,
+  runRequestIdentityIssues
+} from "./chunk-7GOTIIQ7.js";
+import {
+  boundPublicText,
+  canonicalPublicSourceRefs,
+  cloneGraphVisibleMaterial,
+  dataIssue,
+  forEachDepBatch,
+  isRecord,
+  maxPublicReasonChars,
+  projectRuntimeFact,
+  publicMaterialForbiddenKeys,
+  ref,
+  sanitizeAdapterInputIssue,
+  sanitizeAdapterInputSourceRefs,
+  sanitizeGraphVisibleRecord,
+  sanitizeProviderGraphVisibleRecord,
+  stableJsonStringify,
+  uniqueSourceRefs
+} from "./chunk-TQPCAIQI.js";
+import {
+  timeout
+} from "./chunk-PUSRRALM.js";
+import {
+  nextRetryDelayMs,
+  retryPolicy,
+  shouldRetry
+} from "./chunk-OOEN33FB.js";
+import {
+  depBatch
+} from "./chunk-WQIA3GFB.js";
+
+// src/orchestration/agent-runtime-effect-completion.ts
+function effectRunCompletionProjector(graph, opts) {
+  const name = opts.name ?? "effectRunCompletion";
+  const decisions = opts.decisions ?? [];
+  const requestStatuses = opts.requestStatuses ?? [];
+  const requestFacts = opts.requestFacts ?? [];
+  const resultCandidates = opts.resultCandidates ?? [];
+  const deps = [
+    opts.effectRuns,
+    ...decisions,
+    ...requestStatuses,
+    ...requestFacts,
+    ...resultCandidates
+  ];
+  const decisionStart = 1;
+  const requestStatusStart = decisionStart + decisions.length;
+  const requestFactStart = requestStatusStart + requestStatuses.length;
+  const resultCandidateStart = requestFactStart + requestFacts.length;
+  const now = opts.now ?? Date.now;
+  const runtime = graph.node(
+    deps,
+    (ctx) => {
+      const state = ctx.state.get() ?? emptyEffectRunCompletionState();
+      const touchedEffectRunIds = /* @__PURE__ */ new Set();
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const run = raw;
+        state.runs.set(run.effectRunId, run);
+        touchedEffectRunIds.add(run.effectRunId);
+      }
+      forEachDepBatch(ctx, requestFactStart, requestFacts.length, (raw) => {
+        const fact = raw;
+        if (fact.kind === "issued") {
+          state.requests.set(fact.requestId, fact);
+          touchedEffectRunIds.add(fact.effectRunId);
+          const existingStatus = state.statusByRequest.get(fact.requestId);
+          if (existingStatus !== void 0 && !statusMatchesRequest(existingStatus, fact)) {
+            emitEffectRunIssue(
+              ctx,
+              state,
+              "stale-request-status",
+              `AgentRequest status for '${fact.requestId}' did not match its issued effectRun/operation identity`,
+              fact.effectRunId,
+              [ref("agent-request", fact.requestId)]
+            );
+          }
+          const result = state.resultsByEffectRun.get(fact.effectRunId);
+          if (result !== void 0 && fact.required) {
+            state.issueSeq += 1;
+            const issue = dataIssue(
+              "late-required-request-after-effect-run-result",
+              `Required request '${fact.requestId}' arrived after EffectRun '${fact.effectRunId}' already had a terminal result`,
+              {
+                subjectId: fact.effectRunId,
+                refs: [
+                  ref("agent-request", fact.requestId),
+                  ref("effect-run-result", result.resultId)
+                ]
+              }
+            );
+            ctx.down([
+              ["DATA", { kind: "issue", issue }],
+              [
+                "DATA",
+                {
+                  kind: "audit",
+                  audit: {
+                    id: `${fact.effectRunId}:late-required-request:${state.issueSeq}`,
+                    kind: "late-required-request-after-effect-run-result",
+                    subjectId: fact.effectRunId,
+                    issueCode: issue.code,
+                    sourceRefs: [
+                      ref("agent-request", fact.requestId),
+                      ref("effect-run-result", result.resultId)
+                    ]
+                  }
+                }
+              ]
+            ]);
+          }
+        } else if (fact.kind === "status") {
+          acceptRequestStatus(ctx, state, fact);
+          touchedEffectRunIds.add(fact.effectRunId);
+        }
+      });
+      forEachDepBatch(ctx, requestStatusStart, requestStatuses.length, (raw) => {
+        const status = raw;
+        acceptRequestStatus(ctx, state, status);
+        touchedEffectRunIds.add(status.effectRunId);
+      });
+      forEachDepBatch(ctx, resultCandidateStart, resultCandidates.length, (raw) => {
+        acceptEffectRunResultCandidate(ctx, state, raw);
+      });
+      forEachDepBatch(ctx, decisionStart, decisions.length, (raw) => {
+        const decision = raw;
+        state.decisions.set(decision.decisionId, decision);
+        touchedEffectRunIds.add(decision.effectRunId);
+      });
+      for (const decision of state.decisions.values()) {
+        if (state.resultsByEffectRun.has(decision.effectRunId)) continue;
+        const candidate = candidateFromDecision(decision, state, now());
+        if (candidate === void 0) continue;
+        acceptEffectRunResultCandidate(ctx, state, candidate);
+      }
+      for (const effectRunId of touchedEffectRunIds) {
+        if (!state.resultsByEffectRun.has(effectRunId)) {
+          emitEffectRunStatus(
+            ctx,
+            effectRunId,
+            "pending",
+            requiredPendingRequests(effectRunId, state),
+            requiredTerminalRequests(effectRunId, state)
+          );
+        }
+      }
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "effectRunCompletionProjector" }
+  );
+  return {
+    results: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/results`,
+      "effectRunCompletionResults",
+      (fact) => fact.kind === "result" ? fact.result : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "effectRunCompletionStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "effectRunCompletionIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "effectRunCompletionAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    )
+  };
+}
+function acceptEffectRunResultCandidate(ctx, state, candidate) {
+  if (!state.runs.has(candidate.effectRunId)) {
+    emitEffectRunIssue(
+      ctx,
+      state,
+      "unknown-effect-run-result-candidate",
+      `EffectRunResult candidate '${candidate.resultId}' references unknown EffectRun '${candidate.effectRunId}'`,
+      candidate.effectRunId,
+      candidate.sourceRefs
+    );
+    return;
+  }
+  const existing = state.resultsByEffectRun.get(candidate.effectRunId);
+  if (existing !== void 0) {
+    state.issueSeq += 1;
+    const duplicate = sameTerminalResult(existing, candidate);
+    const code = duplicate ? "duplicate-effect-run-result" : "conflicting-effect-run-result";
+    const issue = dataIssue(
+      code,
+      `EffectRun '${candidate.effectRunId}' already has a terminal result`,
+      {
+        subjectId: candidate.effectRunId,
+        refs: candidate.sourceRefs
+      }
+    );
+    ctx.down([
+      ["DATA", { kind: "issue", issue }],
+      [
+        "DATA",
+        {
+          kind: "audit",
+          audit: {
+            id: `${candidate.effectRunId}:${code}:${state.issueSeq}`,
+            kind: duplicate ? "effect-run-result-duplicate" : "effect-run-result-conflict",
+            subjectId: candidate.effectRunId,
+            issueCode: issue.code,
+            sourceRefs: candidate.sourceRefs
+          }
+        }
+      ]
+    ]);
+    return;
+  }
+  state.resultsByEffectRun.set(candidate.effectRunId, candidate);
+  ctx.down([
+    ["DATA", { kind: "result", result: candidate }],
+    [
+      "DATA",
+      {
+        kind: "status",
+        status: {
+          effectRunId: candidate.effectRunId,
+          state: candidate.status,
+          requiredPending: [],
+          requiredTerminal: requiredTerminalRequests(candidate.effectRunId, state),
+          sourceRefs: candidate.sourceRefs
+        }
+      }
+    ],
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: {
+          id: `${candidate.effectRunId}:terminal-result`,
+          kind: "effect-run-terminal-result",
+          subjectId: candidate.effectRunId,
+          sourceRefs: candidate.sourceRefs,
+          metadata: { status: candidate.status }
+        }
+      }
+    ]
+  ]);
+}
+function emitEffectRunStatus(ctx, effectRunId, state, requiredPending, requiredTerminal) {
+  ctx.down([
+    [
+      "DATA",
+      {
+        kind: "status",
+        status: { effectRunId, state, requiredPending, requiredTerminal }
+      }
+    ]
+  ]);
+}
+function requiredPendingRequests(effectRunId, state) {
+  const pending = [];
+  for (const request of state.requests.values()) {
+    if (request.effectRunId !== effectRunId || !request.required) continue;
+    const statusFact = matchingStatusForRequest(state, request);
+    const status = statusFact?.status;
+    if (status === void 0 || !isTerminalRequestStatus(status)) pending.push(request.requestId);
+  }
+  return pending;
+}
+function requiredTerminalRequests(effectRunId, state) {
+  const terminal = [];
+  for (const request of state.requests.values()) {
+    if (request.effectRunId !== effectRunId || !request.required) continue;
+    const statusFact = matchingStatusForRequest(state, request);
+    const status = statusFact?.status;
+    if (status !== void 0 && isTerminalRequestStatus(status)) terminal.push(request.requestId);
+  }
+  return terminal;
+}
+function isTerminalRequestStatus(status) {
+  return status === "completed" || status === "failed" || status === "blocked" || status === "canceled" || status === "timeout" || status === "waived" || status === "retry-exhausted";
+}
+function decisionSourceRequestTerminal(decision, state) {
+  const request = state.requests.get(decision.source.requestId);
+  if (request === void 0) return false;
+  if (request.effectRunId !== decision.effectRunId || request.operationId !== decision.source.operationId) {
+    return false;
+  }
+  const status = matchingStatusForRequest(state, request)?.status;
+  return status !== void 0 && isTerminalRequestStatus(status);
+}
+function acceptRequestStatus(ctx, state, status) {
+  const request = state.requests.get(status.requestId);
+  if (request !== void 0 && !statusMatchesRequest(status, request)) {
+    emitEffectRunIssue(
+      ctx,
+      state,
+      "stale-request-status",
+      `AgentRequest status for '${status.requestId}' did not match its issued effectRun/operation identity`,
+      request.effectRunId,
+      [ref("agent-request", status.requestId)]
+    );
+    return;
+  }
+  state.statusByRequest.set(status.requestId, status);
+}
+function matchingStatusForRequest(state, request) {
+  const status = state.statusByRequest.get(request.requestId);
+  if (status === void 0) return void 0;
+  return statusMatchesRequest(status, request) ? status : void 0;
+}
+function statusMatchesRequest(status, request) {
+  return status.effectRunId === request.effectRunId && (status.operationId === void 0 || status.operationId === request.operationId);
+}
+function emitEffectRunIssue(ctx, state, code, message, subjectId, sourceRefs) {
+  state.issueSeq += 1;
+  const issue = dataIssue(code, message, { subjectId, refs: sourceRefs });
+  ctx.down([
+    ["DATA", { kind: "issue", issue }],
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: {
+          id: `${subjectId ?? "effect-run"}:${code}:${state.issueSeq}`,
+          kind: "effect-run-issue",
+          subjectId,
+          issueCode: code,
+          message,
+          sourceRefs
+        }
+      }
+    ]
+  ]);
+}
+function sameTerminalResult(a, b) {
+  return a.status === b.status && a.resultId === b.resultId && JSON.stringify(a) === JSON.stringify(b);
+}
+function emptyEffectRunCompletionState() {
+  return {
+    runs: /* @__PURE__ */ new Map(),
+    requests: /* @__PURE__ */ new Map(),
+    statusByRequest: /* @__PURE__ */ new Map(),
+    decisions: /* @__PURE__ */ new Map(),
+    resultsByEffectRun: /* @__PURE__ */ new Map(),
+    issueSeq: 0
+  };
+}
+
+// src/orchestration/agent-runtime-decision-interpreter.ts
+function structuredAgentDecisionInterpreter(graph, outcomes, opts = {}) {
+  const name = opts.name ?? "structuredAgentDecisionInterpreter";
+  const requestFacts = opts.requestFacts ?? [];
+  const runtime = graph.node(
+    [outcomes, ...requestFacts],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        requests: /* @__PURE__ */ new Map(),
+        issueSeq: 0
+      };
+      forEachDepBatch(ctx, 1, requestFacts.length, (raw) => {
+        const fact = raw;
+        if (fact.kind === "issued") state.requests.set(fact.requestId, fact);
+      });
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const outcome = raw;
+        if (outcome.kind !== "result") {
+          state.issueSeq += 1;
+          emitInterpreterIssue(
+            ctx,
+            state.issueSeq,
+            outcome,
+            "non-result-outcome",
+            "Only result outcomes can carry AgentDecision envelopes"
+          );
+          continue;
+        }
+        const value = outcome.result.value;
+        if (!isRecord(value)) {
+          state.issueSeq += 1;
+          emitInterpreterIssue(
+            ctx,
+            state.issueSeq,
+            outcome,
+            "malformed-agent-decision",
+            "ExecutorOutcome result must carry a structured agent-decision envelope"
+          );
+          continue;
+        }
+        const envelope = value;
+        if (envelope.kind !== "agent-decision" || !isRecord(envelope.decision)) {
+          state.issueSeq += 1;
+          emitInterpreterIssue(
+            ctx,
+            state.issueSeq,
+            outcome,
+            "malformed-agent-decision",
+            "Structured agent-decision envelope is missing kind or decision"
+          );
+          continue;
+        }
+        if (typeof envelope.schemaRef !== "string" || envelope.schemaRef.length === 0) {
+          state.issueSeq += 1;
+          emitInterpreterIssue(
+            ctx,
+            state.issueSeq,
+            outcome,
+            "missing-agent-decision-schema",
+            "Structured agent-decision envelope must carry schemaRef evidence"
+          );
+          continue;
+        }
+        if (opts.schemaRef !== void 0 && envelope.schemaRef !== opts.schemaRef) {
+          state.issueSeq += 1;
+          emitInterpreterIssue(
+            ctx,
+            state.issueSeq,
+            outcome,
+            "agent-decision-schema-mismatch",
+            "Structured agent-decision envelope schemaRef did not match"
+          );
+          continue;
+        }
+        const decision = validateAgentDecision(envelope.decision, outcome);
+        if (typeof decision === "string") {
+          state.issueSeq += 1;
+          emitInterpreterIssue(ctx, state.issueSeq, outcome, "malformed-agent-decision", decision);
+          continue;
+        }
+        const request = state.requests.get(decision.source.requestId);
+        if (request === void 0) {
+          state.issueSeq += 1;
+          emitInterpreterIssue(
+            ctx,
+            state.issueSeq,
+            outcome,
+            "missing-agent-decision-request",
+            "AgentDecision source request must be present in the request ledger"
+          );
+          continue;
+        }
+        if (request.effectRunId !== decision.effectRunId || request.operationId !== decision.source.operationId) {
+          state.issueSeq += 1;
+          emitInterpreterIssue(
+            ctx,
+            state.issueSeq,
+            outcome,
+            "stale-agent-decision-source",
+            "AgentDecision source request/effectRun/operation identity did not match the request ledger"
+          );
+          continue;
+        }
+        ctx.down([
+          ["DATA", { kind: "decision", decision }],
+          [
+            "DATA",
+            {
+              kind: "audit",
+              audit: {
+                id: `${outcome.outcomeId}:agent-decision-interpreted`,
+                kind: "agent-decision-interpreted",
+                subjectId: decision.effectRunId,
+                sourceRefs: [ref("executor-outcome", outcome.outcomeId)]
+              }
+            }
+          ]
+        ]);
+      }
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "structuredAgentDecisionInterpreter" }
+  );
+  return {
+    decisions: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/decisions`,
+      "structuredAgentDecisions",
+      (fact) => fact.kind === "decision" ? fact.decision : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "structuredAgentDecisionIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "structuredAgentDecisionAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    )
+  };
+}
+function emitInterpreterIssue(ctx, seq, outcome, code, message) {
+  const issue = dataIssue(code, message, {
+    subjectId: outcome.requestId,
+    refs: [ref("executor-outcome", outcome.outcomeId)]
+  });
+  ctx.down([
+    ["DATA", { kind: "issue", issue }],
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: {
+          id: `${outcome.outcomeId}:agent-decision-issue:${seq}`,
+          kind: "agent-decision-issue",
+          subjectId: outcome.requestId,
+          issueCode: code,
+          message,
+          sourceRefs: [ref("executor-outcome", outcome.outcomeId)]
+        }
+      }
+    ]
+  ]);
+}
+function validateAgentDecision(raw, outcome) {
+  if (!isRecord(raw)) return "AgentDecision must be an object";
+  const kind = raw.kind;
+  if (kind !== "continue" && kind !== "final" && kind !== "blocked") {
+    return "AgentDecision kind must be continue, final, or blocked";
+  }
+  if (typeof raw.decisionId !== "string" || raw.decisionId.length === 0)
+    return "AgentDecision decisionId must be a non-empty string";
+  if (raw.effectRunId === void 0 || typeof raw.effectRunId !== "string" || raw.effectRunId.length === 0)
+    return "AgentDecision effectRunId must be a non-empty string";
+  if (typeof raw.agentRunId !== "string" || raw.agentRunId.length === 0)
+    return "AgentDecision agentRunId must be a non-empty string";
+  const source = raw.source;
+  if (!isRecord(source) || source.requestId !== outcome.requestId || source.operationId !== outcome.operationId || source.outcomeId !== outcome.outcomeId) {
+    return "AgentDecision source must match the ExecutorOutcome requestId, operationId, and outcomeId";
+  }
+  if (kind === "continue") {
+    if (!Array.isArray(raw.next)) return "AgentDecision.continue next must be an array";
+    for (const proposal of raw.next) {
+      if (!isAgentRequestProposalLike(proposal, raw.effectRunId)) {
+        return "AgentDecision.continue next entries must be AgentRequestProposal-like objects";
+      }
+    }
+    return raw;
+  }
+  if (kind === "final") {
+    if (!isRecord(raw.output) || typeof raw.output.kind !== "string")
+      return "AgentDecision.final output must be an envelope with kind";
+    return raw;
+  }
+  if (!Array.isArray(raw.needs)) return "AgentDecision.blocked needs must be an array";
+  for (const need of raw.needs) {
+    if (!isAgentNeedLike(need))
+      return "AgentDecision.blocked needs entries must be AgentNeed-like objects";
+  }
+  return raw;
+}
+function isAgentRequestProposalLike(value, effectRunId) {
+  if (!isRecord(value)) return false;
+  if (value.kind !== "proposal") return false;
+  if (typeof value.proposalId !== "string" || value.proposalId.length === 0) return false;
+  if (value.effectRunId !== effectRunId) return false;
+  return value.requestKind === "context" || value.requestKind === "prompt" || value.requestKind === "executor";
+}
+function isAgentNeedLike(value) {
+  return isRecord(value) && typeof value.kind === "string" && value.kind.length > 0;
+}
+function candidateFromDecision(decision, state, completedAtMs) {
+  const run = state.runs.get(decision.effectRunId);
+  if (run === void 0) return void 0;
+  if (!decisionSourceRequestTerminal(decision, state)) return void 0;
+  const requiredPending = requiredPendingRequests(decision.effectRunId, state);
+  if (decision.kind === "final") {
+    if (requiredPending.length > 0) {
+      return void 0;
+    }
+    return {
+      kind: "effect-run-result",
+      resultId: `${decision.effectRunId}:result`,
+      status: "completed",
+      effectRunId: decision.effectRunId,
+      subjectRefs: run.subjectRefs,
+      operationId: decision.source.operationId,
+      sourceRefs: [
+        ref("agent-decision", decision.decisionId),
+        ref("executor-outcome", decision.source.outcomeId)
+      ],
+      completedAtMs,
+      output: decision.output
+    };
+  }
+  if (decision.kind === "blocked" && requiredPending.length === 0) {
+    return {
+      kind: "effect-run-result",
+      resultId: `${decision.effectRunId}:result`,
+      status: "blocked",
+      effectRunId: decision.effectRunId,
+      subjectRefs: run.subjectRefs,
+      operationId: decision.source.operationId,
+      sourceRefs: [
+        ref("agent-decision", decision.decisionId),
+        ref("executor-outcome", decision.source.outcomeId)
+      ],
+      completedAtMs,
+      needs: decision.needs
+    };
+  }
+  return void 0;
+}
+
+// src/orchestration/agent-runtime-fakes.ts
+function fakeExecutorResult(opts) {
+  return { kind: "result", ...opts };
+}
+function fakeExecutorFailure(opts) {
+  return { kind: "failure", ...opts };
+}
+function fakeExecutorBlocked(opts) {
+  return { kind: "blocked", ...opts };
+}
+function fakeExecutorTimeout(opts) {
+  return { kind: "timeout", ...opts };
+}
+function fakeExecutorCanceled(opts) {
+  return { kind: "canceled", ...opts };
+}
+
+// src/orchestration/agent-runtime-request-ledger.ts
+function agentRequestProposalFromDecision(decision, proposal) {
+  return {
+    kind: "proposal",
+    ...proposal,
+    effectRunId: decision.effectRunId,
+    agentRunId: decision.agentRunId,
+    sourceDecisionId: decision.decisionId,
+    evidenceRefs: proposal.evidenceRefs ?? decision.evidenceRefs
+  };
+}
+function admitAgentRequestProposal(proposal, opts) {
+  const sourceRefs = opts.sourceRefs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(opts.sourceRefs);
+  const metadata = sanitizeProviderGraphVisibleRecord(opts.metadata);
+  return {
+    kind: "admitted",
+    proposalId: proposal.proposalId,
+    requestId: opts.requestId,
+    operationId: opts.operationId,
+    effectRunId: proposal.effectRunId,
+    agentRunId: proposal.agentRunId,
+    admittedAtMs: opts.admittedAtMs,
+    ...opts.reason === void 0 ? {} : { reason: boundPublicText(opts.reason, maxPublicReasonChars()).text },
+    ...sourceRefs === void 0 || sourceRefs.length === 0 ? {} : { sourceRefs },
+    ...metadata === void 0 ? {} : { metadata }
+  };
+}
+function issueAgentRequest(proposal, admission, opts = {}) {
+  const input = sanitizeAgentRequestInput(proposal.input);
+  const payload = sanitizeAgentRequestMaterial(proposal.payload);
+  const sourceRefs = sanitizeAdapterInputSourceRefs(opts.sourceRefs ?? admission.sourceRefs ?? []);
+  const metadata = sanitizeProviderGraphVisibleRecord(proposal.metadata);
+  return {
+    kind: "issued",
+    requestId: admission.requestId,
+    operationId: admission.operationId,
+    effectRunId: admission.effectRunId,
+    agentRunId: admission.agentRunId,
+    proposalId: proposal.proposalId,
+    parentRequestId: proposal.parentRequestId,
+    requestKind: proposal.requestKind,
+    required: proposal.required ?? true,
+    ...input === void 0 ? {} : { input },
+    ...payload === void 0 ? {} : { payload },
+    issuedAtMs: opts.issuedAtMs,
+    ...sourceRefs.length === 0 ? {} : { sourceRefs },
+    ...metadata === void 0 ? {} : { metadata }
+  };
+}
+function sanitizeAgentRequestInput(input) {
+  if (input === void 0) return void 0;
+  const {
+    value: rawValue,
+    subjectRefs: rawSubjectRefs,
+    metadata: rawMetadata,
+    ...inputFields
+  } = input;
+  const value = sanitizeAgentRequestMaterial(rawValue);
+  const subjectRefs = rawSubjectRefs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(rawSubjectRefs);
+  const metadata = sanitizeProviderGraphVisibleRecord(rawMetadata);
+  return Object.freeze({
+    ...inputFields,
+    ...value === void 0 ? {} : { value },
+    ...subjectRefs === void 0 || subjectRefs.length === 0 ? {} : { subjectRefs },
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function sanitizeAgentRequestMaterial(value) {
+  if (value === void 0) return void 0;
+  if (publicMaterialForbiddenKeys(value, "provider").length > 0) return void 0;
+  return cloneGraphVisibleMaterial(value);
+}
+function sanitizeAgentRequestIssued(request) {
+  const input = sanitizeAgentRequestInput(request.input);
+  const payload = sanitizeAgentRequestMaterial(request.payload);
+  const sourceRefs = request.sourceRefs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(request.sourceRefs);
+  const metadata = sanitizeProviderGraphVisibleRecord(request.metadata);
+  return Object.freeze({
+    kind: "issued",
+    requestId: request.requestId,
+    operationId: request.operationId,
+    effectRunId: request.effectRunId,
+    ...request.agentRunId === void 0 ? {} : { agentRunId: request.agentRunId },
+    ...request.proposalId === void 0 ? {} : { proposalId: request.proposalId },
+    ...request.parentRequestId === void 0 ? {} : { parentRequestId: request.parentRequestId },
+    requestKind: request.requestKind,
+    required: request.required,
+    ...input === void 0 ? {} : { input },
+    ...payload === void 0 ? {} : { payload },
+    ...request.issuedAtMs === void 0 ? {} : { issuedAtMs: request.issuedAtMs },
+    ...sourceRefs === void 0 || sourceRefs.length === 0 ? {} : { sourceRefs },
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function agentRequestLedgerViews(graph, facts, opts = {}) {
+  const name = opts.name ?? "agentRequests";
+  const views = graph.node(
+    [facts],
+    (ctx) => {
+      const prev = ctx.state.get() ?? emptyAgentRequestViewsState();
+      const next = cloneAgentRequestViewsState(prev);
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const fact = raw;
+        reduceAgentRequestViews(next, fact);
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", freezeAgentRequestViews(next)]]);
+    },
+    { name: `${name}/views`, factory: "agentRequestLedgerViews" }
+  );
+  const issues = graph.node(
+    [facts],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const fact = raw;
+        if (fact.kind === "rejected") ctx.down([["DATA", sanitizeAdapterInputIssue(fact.issue)]]);
+        if (fact.kind === "status") {
+          for (const issue of fact.issues ?? []) {
+            ctx.down([["DATA", sanitizeAdapterInputIssue(issue)]]);
+          }
+        }
+      }
+    },
+    { name: `${name}/issues`, factory: "agentRequestLedgerIssues" }
+  );
+  const audit = graph.node(
+    [facts],
+    (ctx) => {
+      let seq = ctx.state.get() ?? 0;
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        seq += 1;
+        const fact = raw;
+        ctx.down([
+          [
+            "DATA",
+            {
+              id: `${name}:ledger:${seq}`,
+              kind: `agent-request-${fact.kind}`,
+              subjectId: "requestId" in fact ? fact.requestId : fact.proposalId
+            }
+          ]
+        ]);
+      }
+      ctx.state.set(seq);
+    },
+    { name: `${name}/audit`, factory: "agentRequestLedgerAudit" }
+  );
+  return { views, issues, audit };
+}
+function emptyAgentRequestViewsState() {
+  return {
+    requestsById: /* @__PURE__ */ new Map(),
+    requestsByEffectRun: /* @__PURE__ */ new Map(),
+    statusByRequest: /* @__PURE__ */ new Map(),
+    issues: [],
+    audit: [],
+    auditSeq: 0
+  };
+}
+function cloneAgentRequestViewsState(state) {
+  return {
+    requestsById: new Map(state.requestsById),
+    requestsByEffectRun: new Map(Array.from(state.requestsByEffectRun, ([k, v]) => [k, [...v]])),
+    statusByRequest: new Map(state.statusByRequest),
+    issues: [...state.issues],
+    audit: [...state.audit],
+    auditSeq: state.auditSeq
+  };
+}
+function reduceAgentRequestViews(state, fact) {
+  state.auditSeq += 1;
+  if (fact.kind === "issued") {
+    const request = sanitizeAgentRequestIssued(fact);
+    state.requestsById.set(request.requestId, request);
+    const requestIds = state.requestsByEffectRun.get(request.effectRunId) ?? [];
+    if (!requestIds.includes(request.requestId)) requestIds.push(request.requestId);
+    state.requestsByEffectRun.set(request.effectRunId, requestIds);
+    state.statusByRequest.set(request.requestId, {
+      kind: "status",
+      requestId: request.requestId,
+      operationId: request.operationId,
+      effectRunId: request.effectRunId,
+      status: "issued",
+      sourceRefs: [ref("agent-request", request.requestId)]
+    });
+  } else if (fact.kind === "status") {
+    const status = sanitizeAgentRequestStatusChanged(fact);
+    state.statusByRequest.set(status.requestId, status);
+    if (status.issues !== void 0) state.issues.push(...status.issues);
+  } else if (fact.kind === "rejected") {
+    state.issues.push(sanitizeAdapterInputIssue(fact.issue));
+  }
+  state.audit.push({
+    id: `agent-request-ledger:${state.auditSeq}`,
+    kind: `agent-request-${fact.kind}`,
+    subjectId: "requestId" in fact ? fact.requestId : fact.proposalId
+  });
+}
+function sanitizeAgentRequestStatusChanged(status) {
+  const sourceRefs = status.sourceRefs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(status.sourceRefs);
+  const issues = status.issues === void 0 ? void 0 : Object.freeze(status.issues.map((issue) => sanitizeAdapterInputIssue(issue)));
+  const metadata = sanitizeProviderGraphVisibleRecord(status.metadata);
+  return Object.freeze({
+    kind: "status",
+    requestId: status.requestId,
+    ...status.operationId === void 0 ? {} : { operationId: status.operationId },
+    effectRunId: status.effectRunId,
+    status: status.status,
+    ...sourceRefs === void 0 || sourceRefs.length === 0 ? {} : { sourceRefs },
+    ...issues === void 0 || issues.length === 0 ? {} : { issues },
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function freezeAgentRequestViews(state) {
+  const pending = Array.from(state.requestsById.values()).filter((request) => {
+    const status = state.statusByRequest.get(request.requestId)?.status;
+    return status === void 0 || !isTerminalRequestStatus(status);
+  });
+  const awaitingProvider = pending.filter(
+    (request) => state.statusByRequest.get(request.requestId)?.status === "awaiting-provider"
+  );
+  return {
+    requestsById: new Map(state.requestsById),
+    requestsByEffectRun: new Map(
+      Array.from(state.requestsByEffectRun, ([key, value]) => [key, Object.freeze([...value])])
+    ),
+    statusByRequest: new Map(state.statusByRequest),
+    pending: Object.freeze(pending),
+    awaitingProvider: Object.freeze(awaitingProvider),
+    issues: Object.freeze([...state.issues]),
+    audit: Object.freeze([...state.audit])
+  };
+}
+
+// src/orchestration/agent-runtime-request-satisfaction.ts
+function requestSatisfactionProjector(graph, opts) {
+  const name = opts.name ?? "requestSatisfaction";
+  const profileDeps = opts.executorProfiles ?? [];
+  const routeDeps = opts.executorRoutes ?? [];
+  const outcomeDeps = opts.executorOutcomes ?? [];
+  const contextDeps = opts.contextContributions ?? [];
+  const promptDeps = opts.promptBundles ?? [];
+  const deps = [
+    opts.requestFacts,
+    ...profileDeps,
+    ...routeDeps,
+    ...outcomeDeps,
+    ...contextDeps,
+    ...promptDeps
+  ];
+  const profileStart = 1;
+  const routeStart = profileStart + profileDeps.length;
+  const outcomeStart = routeStart + routeDeps.length;
+  const contextStart = outcomeStart + outcomeDeps.length;
+  const promptStart = contextStart + contextDeps.length;
+  const runtime = graph.node(
+    deps,
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        requests: /* @__PURE__ */ new Map(),
+        profiles: /* @__PURE__ */ new Map(),
+        routes: /* @__PURE__ */ new Map(),
+        outcomes: /* @__PURE__ */ new Map(),
+        contexts: /* @__PURE__ */ new Map(),
+        prompts: /* @__PURE__ */ new Map(),
+        compatibleRoutesByRouteId: /* @__PURE__ */ new Map(),
+        terminalRequests: /* @__PURE__ */ new Set(),
+        acceptedTerminalFactIds: /* @__PURE__ */ new Set(),
+        issueKeys: /* @__PURE__ */ new Set(),
+        statusKeys: /* @__PURE__ */ new Set(),
+        issueSeq: 0,
+        auditSeq: 0
+      };
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        if (fact.kind === "issued") {
+          const request = fact;
+          state.requests.set(request.requestId, request);
+          emitStatus(ctx, state, request, initialRequestStatus(request), [
+            ref("agent-request", request.requestId)
+          ]);
+        }
+      }
+      forEachDepBatch(ctx, profileStart, profileDeps.length, (raw) => {
+        const profile = raw;
+        state.profiles.set(profile.profileId, profile);
+      });
+      forEachDepBatch(ctx, routeStart, routeDeps.length, (raw) => {
+        const route = raw;
+        state.routes.set(route.routeId, route);
+      });
+      forEachDepBatch(ctx, outcomeStart, outcomeDeps.length, (raw) => {
+        const outcome = raw;
+        state.outcomes.set(outcome.outcomeId, outcome);
+      });
+      forEachDepBatch(ctx, contextStart, contextDeps.length, (raw) => {
+        const contribution = raw;
+        state.contexts.set(contribution.contributionId, contribution);
+      });
+      forEachDepBatch(ctx, promptStart, promptDeps.length, (raw) => {
+        const prompt = raw;
+        state.prompts.set(prompt.promptId, prompt);
+      });
+      evaluateRequestSatisfaction(ctx, state);
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "requestSatisfactionProjector" }
+  );
+  const status = graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        if (typed.kind === "status") ctx.down([["DATA", typed.status]]);
+      }
+    },
+    { name: `${name}/status`, factory: "requestSatisfactionStatus" }
+  );
+  const issues = graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        if (typed.kind === "issue") ctx.down([["DATA", typed.issue]]);
+      }
+    },
+    { name: `${name}/issues`, factory: "requestSatisfactionIssues" }
+  );
+  const audit = graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        if (typed.kind === "audit") ctx.down([["DATA", typed.audit]]);
+      }
+    },
+    { name: `${name}/audit`, factory: "requestSatisfactionAudit" }
+  );
+  return { status, issues, audit };
+}
+function initialRequestStatus(request) {
+  if (request.requestKind === "context") return "awaiting-context";
+  if (request.requestKind === "prompt") return "awaiting-prompt";
+  return "awaiting-route";
+}
+function evaluateRequestSatisfaction(ctx, state) {
+  for (const route of state.routes.values()) handleRoute(ctx, state, route);
+  for (const contribution of state.contexts.values())
+    handleContextContribution(ctx, state, contribution);
+  for (const prompt of state.prompts.values()) handlePromptBundle(ctx, state, prompt);
+  for (const outcome of state.outcomes.values()) handleExecutorOutcome(ctx, state, outcome);
+}
+function handleRoute(ctx, state, route) {
+  const request = state.requests.get(route.requestId);
+  if (request === void 0) {
+    return;
+  }
+  if (state.terminalRequests.has(request.requestId)) {
+    if (state.compatibleRoutesByRouteId.get(route.routeId)?.requestId !== request.requestId) {
+      emitIssueOnce(
+        ctx,
+        state,
+        `late-route:${route.routeId}`,
+        "late-route-after-terminal",
+        `ExecutorRoute '${route.routeId}' arrived after request '${request.requestId}' was already terminal`,
+        request.requestId,
+        [ref("executor-route", route.routeId), ref("agent-request", request.requestId)]
+      );
+    }
+    return;
+  }
+  if (request.operationId !== route.operationId) {
+    emitIssueOnce(
+      ctx,
+      state,
+      `stale-route:${route.routeId}`,
+      "stale-route-operation",
+      `ExecutorRoute '${route.routeId}' operationId does not match request '${request.requestId}'`,
+      request.requestId,
+      [ref("executor-route", route.routeId), ref("agent-request", request.requestId)]
+    );
+    return;
+  }
+  const profile = state.profiles.get(route.profileId);
+  if (profile === void 0) {
+    return;
+  }
+  const compatibilityIssue = routeCompatibilityIssue(request, route, profile);
+  if (compatibilityIssue !== void 0) {
+    emitIssueOnce(
+      ctx,
+      state,
+      `route-incompatible:${route.routeId}:${compatibilityIssue}`,
+      compatibilityIssue,
+      `ExecutorRoute '${route.routeId}' is incompatible with request '${request.requestId}'`,
+      request.requestId,
+      [
+        ref("executor-route", route.routeId),
+        ref("executor-profile", profile.profileId),
+        ref("agent-request", request.requestId)
+      ]
+    );
+    return;
+  }
+  state.compatibleRoutesByRouteId.set(route.routeId, route);
+  emitStatusOnce(
+    ctx,
+    state,
+    `route:${route.routeId}:awaiting-provider`,
+    request,
+    "awaiting-provider",
+    [
+      ref("executor-route", route.routeId),
+      ref("executor-profile", profile.profileId),
+      ref("agent-request", request.requestId)
+    ]
+  );
+}
+function handleExecutorOutcome(ctx, state, outcome) {
+  const request = state.requests.get(outcome.requestId);
+  if (request === void 0) {
+    return;
+  }
+  if (request.operationId !== outcome.operationId) {
+    emitIssueOnce(
+      ctx,
+      state,
+      `stale-outcome:${outcome.outcomeId}`,
+      "stale-outcome-operation",
+      `ExecutorOutcome '${outcome.outcomeId}' operationId does not match request '${request.requestId}'`,
+      request.requestId,
+      [ref("executor-outcome", outcome.outcomeId), ref("agent-request", request.requestId)]
+    );
+    return;
+  }
+  const route = state.compatibleRoutesByRouteId.get(outcome.routeId);
+  if (route === void 0 || route.requestId !== request.requestId) {
+    emitIssueOnce(
+      ctx,
+      state,
+      `missing-route:${outcome.outcomeId}`,
+      "missing-compatible-route",
+      `ExecutorOutcome '${outcome.outcomeId}' has no compatible route for request '${request.requestId}'`,
+      request.requestId,
+      [ref("executor-outcome", outcome.outcomeId), ref("agent-request", request.requestId)]
+    );
+    return;
+  }
+  const outcomeIssue = outcomeCompatibilityIssue(request, route, outcome);
+  if (outcomeIssue !== void 0) {
+    emitIssueOnce(
+      ctx,
+      state,
+      `outcome-incompatible:${outcome.outcomeId}:${outcomeIssue}`,
+      outcomeIssue,
+      `ExecutorOutcome '${outcome.outcomeId}' is incompatible with route '${route.routeId}' for request '${request.requestId}'`,
+      request.requestId,
+      [
+        ref("executor-outcome", outcome.outcomeId),
+        ref("executor-route", route.routeId),
+        ref("agent-request", request.requestId)
+      ]
+    );
+    return;
+  }
+  if (state.terminalRequests.has(request.requestId)) {
+    if (state.acceptedTerminalFactIds.has(`outcome:${outcome.outcomeId}`)) return;
+    emitIssueOnce(
+      ctx,
+      state,
+      `duplicate-outcome:${outcome.outcomeId}`,
+      "duplicate-terminal-outcome",
+      `ExecutorOutcome '${outcome.outcomeId}' arrived after request '${request.requestId}' was already terminal`,
+      request.requestId,
+      [ref("executor-outcome", outcome.outcomeId), ref("agent-request", request.requestId)]
+    );
+    return;
+  }
+  state.terminalRequests.add(request.requestId);
+  state.acceptedTerminalFactIds.add(`outcome:${outcome.outcomeId}`);
+  const status = outcomeStatus(outcome);
+  emitStatus(ctx, state, request, status, [
+    ref("executor-outcome", outcome.outcomeId),
+    ref("executor-route", route.routeId),
+    ref("agent-request", request.requestId)
+  ]);
+}
+function handleContextContribution(ctx, state, contribution) {
+  const request = state.requests.get(contribution.requestId);
+  if (request === void 0) return;
+  if (request.operationId !== contribution.operationId) {
+    emitIssueOnce(
+      ctx,
+      state,
+      `stale-context:${contribution.contributionId}`,
+      "stale-context-operation",
+      `ContextContribution '${contribution.contributionId}' operationId does not match request '${request.requestId}'`,
+      request.requestId,
+      [ref("context-contribution", contribution.contributionId)]
+    );
+    return;
+  }
+  if (request.requestKind !== "context") {
+    emitIssueOnce(
+      ctx,
+      state,
+      `wrong-context-kind:${contribution.contributionId}`,
+      "wrong-kind-context-satisfaction",
+      `ContextContribution '${contribution.contributionId}' cannot satisfy ${request.requestKind} request '${request.requestId}'`,
+      request.requestId,
+      [ref("context-contribution", contribution.contributionId)]
+    );
+    return;
+  }
+  if (state.terminalRequests.has(request.requestId)) {
+    if (state.acceptedTerminalFactIds.has(`context:${contribution.contributionId}`) || state.statusKeys.has(`context:${contribution.contributionId}:awaiting-context`)) {
+      return;
+    }
+    emitIssueOnce(
+      ctx,
+      state,
+      `duplicate-context:${contribution.contributionId}`,
+      "duplicate-terminal-context",
+      `ContextContribution '${contribution.contributionId}' arrived after request '${request.requestId}' was already terminal`,
+      request.requestId,
+      [
+        ref("context-contribution", contribution.contributionId),
+        ref("agent-request", request.requestId)
+      ]
+    );
+    return;
+  }
+  if (contribution.status === "pending")
+    emitStatusOnce(
+      ctx,
+      state,
+      `context:${contribution.contributionId}:awaiting-context`,
+      request,
+      "awaiting-context",
+      [ref("context-contribution", contribution.contributionId)]
+    );
+  else {
+    state.terminalRequests.add(request.requestId);
+    state.acceptedTerminalFactIds.add(`context:${contribution.contributionId}`);
+    emitStatus(
+      ctx,
+      state,
+      request,
+      contribution.status === "ready" ? "completed" : "failed",
+      [ref("context-contribution", contribution.contributionId)],
+      contribution.issues
+    );
+  }
+}
+function handlePromptBundle(ctx, state, prompt) {
+  const request = state.requests.get(prompt.requestId);
+  if (request === void 0) return;
+  if (request.operationId !== prompt.operationId) {
+    emitIssueOnce(
+      ctx,
+      state,
+      `stale-prompt:${prompt.promptId}`,
+      "stale-prompt-operation",
+      `PromptBundle '${prompt.promptId}' operationId does not match request '${request.requestId}'`,
+      request.requestId,
+      [ref("prompt-bundle", prompt.promptId)]
+    );
+    return;
+  }
+  if (request.requestKind !== "prompt") {
+    emitIssueOnce(
+      ctx,
+      state,
+      `wrong-prompt-kind:${prompt.promptId}`,
+      "wrong-kind-prompt-satisfaction",
+      `PromptBundle '${prompt.promptId}' cannot satisfy ${request.requestKind} request '${request.requestId}'`,
+      request.requestId,
+      [ref("prompt-bundle", prompt.promptId)]
+    );
+    return;
+  }
+  if (state.terminalRequests.has(request.requestId)) {
+    if (state.acceptedTerminalFactIds.has(`prompt:${prompt.promptId}`) || state.statusKeys.has(`prompt:${prompt.promptId}:awaiting-prompt`)) {
+      return;
+    }
+    emitIssueOnce(
+      ctx,
+      state,
+      `duplicate-prompt:${prompt.promptId}`,
+      "duplicate-terminal-prompt",
+      `PromptBundle '${prompt.promptId}' arrived after request '${request.requestId}' was already terminal`,
+      request.requestId,
+      [ref("prompt-bundle", prompt.promptId), ref("agent-request", request.requestId)]
+    );
+    return;
+  }
+  if (prompt.status === "ready") {
+    state.terminalRequests.add(request.requestId);
+    state.acceptedTerminalFactIds.add(`prompt:${prompt.promptId}`);
+    emitStatus(ctx, state, request, "completed", [ref("prompt-bundle", prompt.promptId)]);
+  } else if (prompt.status === "issue") {
+    state.terminalRequests.add(request.requestId);
+    state.acceptedTerminalFactIds.add(`prompt:${prompt.promptId}`);
+    emitStatus(
+      ctx,
+      state,
+      request,
+      "failed",
+      [ref("prompt-bundle", prompt.promptId)],
+      prompt.issues
+    );
+  } else {
+    emitStatusOnce(
+      ctx,
+      state,
+      `prompt:${prompt.promptId}:awaiting-prompt`,
+      request,
+      "awaiting-prompt",
+      [ref("prompt-bundle", prompt.promptId)],
+      prompt.issues
+    );
+  }
+}
+function routeCompatibilityIssue(request, route, profile) {
+  if (request.requestKind !== "executor") return "route-for-non-executor-request";
+  if (route.executorId !== profile.executorId) return "route-profile-executor-mismatch";
+  if (request.input?.inputId !== void 0 && route.inputId !== void 0 && request.input.inputId !== route.inputId) {
+    return "route-input-mismatch";
+  }
+  if (request.input?.inputKind !== void 0 && route.inputKind !== void 0 && request.input.inputKind !== route.inputKind) {
+    return "route-input-kind-mismatch";
+  }
+  const inputKind = request.input?.inputKind ?? route.inputKind;
+  if (inputKind !== void 0 && !profileKindAcceptsInput(profile.kind, inputKind))
+    return "profile-kind-input-incompatible";
+  if (inputKind !== void 0 && profile.acceptedInputKinds !== void 0 && !profile.acceptedInputKinds.includes(inputKind)) {
+    return "profile-rejects-input-kind";
+  }
+  if (request.input?.schemaRef !== void 0 && profile.acceptedSchemaRefs !== void 0 && !profile.acceptedSchemaRefs.includes(request.input.schemaRef)) {
+    return "profile-rejects-schema";
+  }
+  return void 0;
+}
+function outcomeCompatibilityIssue(request, route, outcome) {
+  if (outcome.executorId !== route.executorId) return "outcome-route-executor-mismatch";
+  if (outcome.profileId !== route.profileId) return "outcome-route-profile-mismatch";
+  if (route.inputId !== void 0 && (outcome.inputId === void 0 || outcome.inputId !== route.inputId)) {
+    return "outcome-route-input-mismatch";
+  }
+  if (request.input?.inputId !== void 0 && outcome.inputId !== void 0 && outcome.inputId !== request.input.inputId) {
+    return "outcome-request-input-mismatch";
+  }
+  if (route.inputKind !== void 0 && (outcome.inputKind === void 0 || outcome.inputKind !== route.inputKind)) {
+    return "outcome-route-input-kind-mismatch";
+  }
+  if (request.input?.inputKind !== void 0 && outcome.inputKind !== void 0 && outcome.inputKind !== request.input.inputKind) {
+    return "outcome-request-input-kind-mismatch";
+  }
+  return void 0;
+}
+function profileKindAcceptsInput(kind, inputKind) {
+  if (kind === "llm") return inputKind === "llm-call";
+  if (kind === "tool") return inputKind === "tool-call";
+  if (kind === "human") return inputKind === "human-task";
+  return inputKind === "agent-task";
+}
+function outcomeStatus(outcome) {
+  if (outcome.kind === "result") return "completed";
+  if (outcome.kind === "failure") return "failed";
+  if (outcome.kind === "timeout") return "timeout";
+  if (outcome.kind === "canceled") return "canceled";
+  return "blocked";
+}
+function emitStatus(ctx, state, request, status, sourceRefs, issues) {
+  const cleanSourceRefs = sourceRefs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(sourceRefs);
+  const cleanIssues = issues === void 0 ? void 0 : Object.freeze(issues.map((issue) => sanitizeAdapterInputIssue(issue)));
+  const fact = {
+    kind: "status",
+    requestId: request.requestId,
+    operationId: request.operationId,
+    effectRunId: request.effectRunId,
+    status,
+    sourceRefs: cleanSourceRefs,
+    issues: cleanIssues
+  };
+  state.auditSeq += 1;
+  ctx.down([
+    ["DATA", { kind: "status", status: fact }],
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: {
+          id: `${request.requestId}:status:${state.auditSeq}`,
+          kind: "agent-request-status",
+          subjectId: request.requestId,
+          sourceRefs: cleanSourceRefs,
+          metadata: { status }
+        }
+      }
+    ]
+  ]);
+}
+function emitStatusOnce(ctx, state, key, request, status, sourceRefs, issues) {
+  if (state.statusKeys.has(key)) return;
+  state.statusKeys.add(key);
+  emitStatus(ctx, state, request, status, sourceRefs, issues);
+}
+function emitIssue(ctx, state, code, message, subjectId, refs) {
+  state.issueSeq += 1;
+  const issue = dataIssue(code, message, { subjectId, refs });
+  state.auditSeq += 1;
+  ctx.down([
+    ["DATA", { kind: "issue", issue }],
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: {
+          id: `${subjectId ?? "request"}:issue:${state.auditSeq}`,
+          kind: "agent-request-issue",
+          subjectId,
+          issueCode: code,
+          message,
+          sourceRefs: refs
+        }
+      }
+    ]
+  ]);
+}
+function emitIssueOnce(ctx, state, key, code, message, subjectId, refs) {
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  emitIssue(ctx, state, code, message, subjectId, refs);
+}
+
+// src/orchestration/agent-runtime-tool-provider-run-admission.ts
+function toolProviderRunAdmissionProjector(graph, opts) {
+  const name = opts.name ?? "toolProviderRunAdmission";
+  const decisionDeps = opts.decisions ?? [];
+  const runtime = graph.node(
+    [opts.inputs, ...opts.runRequests, ...decisionDeps],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        inputs: /* @__PURE__ */ new Map(),
+        proposalsById: /* @__PURE__ */ new Map(),
+        proposalsByRun: /* @__PURE__ */ new Map(),
+        decisionsByProposal: /* @__PURE__ */ new Map(),
+        admissionsByProposal: /* @__PURE__ */ new Map(),
+        admissionsByRun: /* @__PURE__ */ new Map(),
+        proposalKeys: /* @__PURE__ */ new Set(),
+        admissionKeys: /* @__PURE__ */ new Set(),
+        approvedRunKeys: /* @__PURE__ */ new Set(),
+        statusKeys: /* @__PURE__ */ new Set(),
+        issueKeys: /* @__PURE__ */ new Set(),
+        auditSeq: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const input = raw;
+        state.inputs.set(input.adapterInputId, input);
+      }
+      forEachDepBatch(ctx, 1, opts.runRequests.length, (raw) => {
+        const request = raw;
+        const input = state.inputs.get(request.adapterInputId);
+        if (input === void 0) {
+          emitAdmissionIssue(
+            ctx,
+            state,
+            dataIssue(
+              "tool-provider-run-admission-missing-input",
+              "Tool provider run admission request references an unknown adapter input.",
+              {
+                subjectId: request.adapterInputId,
+                refs: sanitizeAdapterInputSourceRefs([
+                  ref("tool-provider-adapter-run", request.runId),
+                  ...request.sourceRefs ?? []
+                ])
+              }
+            )
+          );
+          emitAdmissionStatus(ctx, state, {
+            kind: "tool-provider-run-admission-status",
+            proposalId: `${request.runId}:admission-proposal`,
+            runId: request.runId,
+            adapterInputId: request.adapterInputId,
+            requestId: request.requestId,
+            operationId: request.operationId,
+            state: "issue",
+            sourceRefs: request.sourceRefs
+          });
+          return;
+        }
+        handleRunRequest(ctx, state, input, request, opts.now);
+      });
+      forEachDepBatch(ctx, 1 + opts.runRequests.length, decisionDeps.length, (raw) => {
+        const decision = sanitizeAdmissionDecision(raw);
+        state.decisionsByProposal.set(decision.proposalId, decision);
+        const internal = state.proposalsById.get(decision.proposalId);
+        if (internal !== void 0) applyDecision(ctx, state, internal, decision, opts.now);
+      });
+      ctx.down([["DATA", { kind: "views", views: buildAdmissionViews(state) }]]);
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "toolProviderRunAdmissionProjector", partial: true }
+  );
+  return {
+    proposals: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/proposals`,
+      "toolProviderRunAdmissionProposals",
+      (fact) => fact.kind === "proposal" ? fact.proposal : void 0
+    ),
+    admissions: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/admissions`,
+      "toolProviderRunAdmissions",
+      (fact) => fact.kind === "admission" ? fact.admission : void 0
+    ),
+    approvedRunRequests: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/approvedRunRequests`,
+      "toolProviderRunAdmissionApprovedRunRequests",
+      (fact) => fact.kind === "approved-run-request" ? fact.request : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "toolProviderRunAdmissionStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "toolProviderRunAdmissionIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "toolProviderRunAdmissionAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    ),
+    views: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/views`,
+      "toolProviderRunAdmissionViews",
+      (fact) => fact.kind === "views" ? fact.views : void 0
+    )
+  };
+}
+function handleRunRequest(ctx, state, input, request, now) {
+  const issues = runRequestIdentityIssues(request, input);
+  if (input.status !== "ready") {
+    issues.push(
+      dataIssue(
+        "tool-provider-run-admission-input-not-ready",
+        "Tool provider run admission requires a ready adapter input.",
+        {
+          subjectId: input.requestId,
+          refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+          details: { status: input.status }
+        }
+      )
+    );
+  }
+  if (issues.length > 0) {
+    for (const issue of issues) emitAdmissionIssue(ctx, state, issue);
+    emitAdmissionStatus(ctx, state, {
+      kind: "tool-provider-run-admission-status",
+      proposalId: `${request.runId}:admission-proposal`,
+      runId: request.runId,
+      adapterInputId: request.adapterInputId,
+      requestId: request.requestId,
+      operationId: request.operationId,
+      state: "issue",
+      issues: Object.freeze(issues),
+      sourceRefs: request.sourceRefs
+    });
+    emitAdmissionAudit(ctx, state, "tool-provider-run-admission-request-rejected", request, {
+      issueCodes: issues.map((issue) => issue.code)
+    });
+    return;
+  }
+  const approval = resolveApprovalPolicy(input);
+  const proposal = admissionProposal(input, request, approval);
+  const internal = { proposal, request, input };
+  state.proposalsById.set(proposal.proposalId, internal);
+  pushMapArrayBy(state.proposalsByRun, request.runId, proposal, (entry) => entry.proposalId);
+  emitProposal(ctx, state, proposal);
+  emitAdmissionAudit(ctx, state, "tool-provider-run-admission-proposed", proposal, {
+    approvalMode: proposal.approvalMode
+  });
+  if (proposal.approvalMode === "auto") {
+    admit(ctx, state, internal, void 0, now);
+    return;
+  }
+  if (proposal.approvalMode === "never") {
+    recordAdmission(ctx, state, internal, "blocked", {
+      reason: "blocked by tool provider approval policy",
+      now
+    });
+    return;
+  }
+  const decision = state.decisionsByProposal.get(proposal.proposalId);
+  if (decision === void 0) {
+    emitAdmissionStatus(ctx, state, {
+      kind: "tool-provider-run-admission-status",
+      proposalId: proposal.proposalId,
+      runId: request.runId,
+      adapterInputId: request.adapterInputId,
+      requestId: request.requestId,
+      operationId: request.operationId,
+      state: "waiting",
+      sourceRefs: proposal.sourceRefs
+    });
+    return;
+  }
+  applyDecision(ctx, state, internal, decision, now);
+}
+function applyDecision(ctx, state, internal, decision, now) {
+  const existing = state.admissionsByProposal.get(internal.proposal.proposalId);
+  if (existing !== void 0) {
+    if (existing.decisionId === decision.decisionId) return;
+    const issue = dataIssue(
+      "tool-provider-run-admission-duplicate-decision",
+      "Tool provider run admission proposal already has a terminal admission decision.",
+      {
+        subjectId: internal.input.requestId,
+        refs: admissionSourceRefs(internal, decision),
+        severity: "warning",
+        details: {
+          proposalId: internal.proposal.proposalId,
+          existingDecisionId: existing.decisionId,
+          rejectedDecisionId: decision.decisionId
+        }
+      }
+    );
+    emitAdmissionIssue(ctx, state, issue);
+    emitAdmissionStatus(ctx, state, {
+      kind: "tool-provider-run-admission-status",
+      proposalId: internal.proposal.proposalId,
+      runId: internal.request.runId,
+      adapterInputId: internal.input.adapterInputId,
+      requestId: internal.input.requestId,
+      operationId: internal.input.operationId,
+      state: "issue",
+      issues: Object.freeze([issue]),
+      sourceRefs: admissionSourceRefs(internal, decision)
+    });
+    emitAdmissionAudit(ctx, state, "tool-provider-run-admission-duplicate-decision", decision, {
+      proposalId: internal.proposal.proposalId,
+      existingDecisionId: existing.decisionId
+    });
+    return;
+  }
+  if (decision.outcome === "admit") {
+    admit(ctx, state, internal, decision, now);
+    return;
+  }
+  recordAdmission(ctx, state, internal, admissionStateForOutcome(decision.outcome), {
+    decision,
+    reason: decision.reason,
+    now
+  });
+}
+function admit(ctx, state, internal, decision, now) {
+  const approvedRunId = decision?.approvedRunId ?? (decision === void 0 ? `${internal.request.runId}:admitted` : `${internal.request.runId}:admitted:${decision.decisionId}`);
+  const admission = recordAdmission(ctx, state, internal, "admitted", {
+    decision,
+    approvedRunId,
+    reason: decision?.reason,
+    now
+  });
+  const approvedRequest = requestToolProviderAdapterRun(internal.input, {
+    runId: approvedRunId,
+    attempt: internal.request.attempt,
+    reason: internal.request.reason,
+    retryOfOutcomeId: internal.request.retryOfOutcomeId,
+    policyRefs: internal.request.policyRefs ?? internal.input.policyRefs,
+    sourceRefs: uniqueSourceRefs([
+      ref("tool-provider-adapter-run", internal.request.runId),
+      ref("tool-provider-run-admission-proposal", internal.proposal.proposalId),
+      ref("tool-provider-run-admission", admission.admissionId),
+      ...decision === void 0 ? [] : [ref("tool-provider-run-admission-decision", decision.decisionId)],
+      ...internal.request.sourceRefs ?? []
+    ]),
+    metadata: {
+      ...internal.request.metadata ?? {},
+      approval: "granted",
+      approvalGranted: true,
+      admissionId: admission.admissionId,
+      proposalId: internal.proposal.proposalId,
+      approvedFromRunId: internal.request.runId,
+      ...decision === void 0 ? {} : { decisionId: decision.decisionId }
+    },
+    requestedAtMs: now?.()
+  });
+  emitApprovedRunRequest(ctx, state, approvedRequest);
+  emitAdmissionAudit(
+    ctx,
+    state,
+    "tool-provider-run-admission-approved-run-requested",
+    {
+      proposalId: internal.proposal.proposalId,
+      runId: approvedRequest.runId
+    },
+    {
+      approvedFromRunId: internal.request.runId,
+      decisionId: decision?.decisionId
+    }
+  );
+}
+function recordAdmission(ctx, state, internal, admissionState, opts) {
+  const admissionId = opts.decision?.admissionId ?? `${internal.proposal.proposalId}:admission`;
+  const sourceRefs = admissionSourceRefs(internal, opts.decision);
+  const admission = Object.freeze({
+    kind: "tool-provider-run-admission",
+    admissionId,
+    proposalId: internal.proposal.proposalId,
+    runId: internal.request.runId,
+    adapterInputId: internal.input.adapterInputId,
+    requestId: internal.input.requestId,
+    operationId: internal.input.operationId,
+    state: admissionState,
+    ...opts.decision === void 0 ? {} : { decisionId: opts.decision.decisionId },
+    ...opts.approvedRunId === void 0 ? {} : { approvedRunId: opts.approvedRunId },
+    ...opts.reason === void 0 ? {} : { reason: opts.reason },
+    sourceRefs,
+    metadata: sanitizeProviderGraphVisibleRecord({
+      approvalMode: internal.proposal.approvalMode,
+      occurredAtMs: opts.now?.()
+    })
+  });
+  state.admissionsByProposal.set(admission.proposalId, admission);
+  pushMapArrayBy(state.admissionsByRun, admission.runId, admission, (entry) => entry.admissionId);
+  emitAdmission(ctx, state, admission);
+  if (admissionState === "blocked") {
+    emitAdmissionIssue(
+      ctx,
+      state,
+      dataIssue(
+        "tool-provider-run-admission-blocked",
+        "Tool provider run admission blocked the candidate run request.",
+        {
+          subjectId: internal.input.requestId,
+          refs: sourceRefs,
+          severity: "warning",
+          details: { approvalMode: internal.proposal.approvalMode }
+        }
+      )
+    );
+  }
+  emitAdmissionStatus(ctx, state, {
+    kind: "tool-provider-run-admission-status",
+    proposalId: admission.proposalId,
+    runId: admission.runId,
+    adapterInputId: admission.adapterInputId,
+    requestId: admission.requestId,
+    operationId: admission.operationId,
+    state: admission.state,
+    admissionId: admission.admissionId,
+    ...admission.decisionId === void 0 ? {} : { decisionId: admission.decisionId },
+    ...admission.approvedRunId === void 0 ? {} : { approvedRunId: admission.approvedRunId },
+    sourceRefs
+  });
+  emitAdmissionAudit(ctx, state, `tool-provider-run-admission-${admissionState}`, admission, {
+    decisionId: opts.decision?.decisionId
+  });
+  return admission;
+}
+function admissionProposal(input, request, approval) {
+  const sourceRefs = uniqueSourceRefs([
+    ref("tool-provider-adapter-run", request.runId),
+    ref("tool-provider-adapter-input", input.adapterInputId),
+    ...request.sourceRefs ?? [],
+    ...input.sourceRefs ?? [],
+    ...approval.policy?.approval?.sourceRefs ?? [],
+    ...approval.policy?.sourceRefs ?? []
+  ]);
+  return Object.freeze({
+    kind: "tool-provider-run-admission-proposal",
+    proposalId: `${request.runId}:admission-proposal`,
+    runId: request.runId,
+    adapterInputId: input.adapterInputId,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    routeId: input.routeId,
+    providerId: input.providerId,
+    executorId: input.executorId,
+    profileId: input.profileId,
+    toolName: input.toolName,
+    operation: input.operation,
+    attempt: request.attempt,
+    reason: request.reason,
+    approvalMode: approval.mode,
+    policyRefs: sanitizeAdapterInputSourceRefs([
+      ...request.policyRefs ?? [],
+      ...input.policyRefs ?? [],
+      ...approval.policy === void 0 ? [] : [ref("tool-provider-execution-policy", approval.policy.policyId)]
+    ]),
+    sourceRefs: sanitizeAdapterInputSourceRefs(sourceRefs),
+    needs: approval.mode === "require" || approval.mode === "custom" ? approvalNeeds(approval.policy?.approval) : void 0,
+    metadata: sanitizeProviderGraphVisibleRecord({
+      approvalPolicyId: approval.policy?.policyId,
+      approvalMode: approval.mode
+    })
+  });
+}
+function resolveApprovalPolicy(input) {
+  for (const policy of input.policies ?? []) {
+    const approval = policy.approval;
+    const mode = approval?.mode ?? "auto";
+    if (matchesApprovalSelector(input, approval)) return { mode, policy };
+  }
+  return { mode: "auto" };
+}
+function matchesApprovalSelector(input, approval) {
+  if (approval === void 0) return true;
+  const names = approval.requiredForToolNames;
+  const operations = approval.requiredForOperations;
+  const matchesName = names === void 0 || input.toolName !== void 0 && names.includes(input.toolName);
+  const matchesOperation = operations === void 0 || input.operation !== void 0 && operations.includes(input.operation);
+  return matchesName && matchesOperation;
+}
+function approvalNeeds(approval) {
+  return Object.freeze([
+    {
+      kind: "approval",
+      message: "Tool provider run requires graph-visible admission.",
+      refs: sanitizeAdapterInputSourceRefs(approval?.approverRefs ?? []),
+      metadata: sanitizeProviderGraphVisibleRecord({ approvalMode: approval?.mode ?? "require" })
+    }
+  ]);
+}
+function admissionStateForOutcome(outcome) {
+  if (outcome === "admit") return "admitted";
+  if (outcome === "defer") return "deferred";
+  return "blocked";
+}
+function admissionSourceRefs(internal, decision) {
+  return sanitizeAdapterInputSourceRefs([
+    ref("tool-provider-run-admission-proposal", internal.proposal.proposalId),
+    ref("tool-provider-adapter-run", internal.request.runId),
+    ref("tool-provider-adapter-input", internal.input.adapterInputId),
+    ...decision === void 0 ? [] : [ref("tool-provider-run-admission-decision", decision.decisionId)],
+    ...decision?.sourceRefs ?? []
+  ]);
+}
+function sanitizeAdmissionDecision(decision) {
+  return Object.freeze({
+    kind: "tool-provider-run-admission-decision",
+    decisionId: decision.decisionId,
+    proposalId: decision.proposalId,
+    admissionId: decision.admissionId,
+    outcome: decision.outcome,
+    ...decision.approvedRunId === void 0 ? {} : { approvedRunId: decision.approvedRunId },
+    ...decision.reason === void 0 ? {} : { reason: decision.reason },
+    ...decision.decidedByRef === void 0 ? {} : { decidedByRef: sanitizeAdapterInputSourceRefs([decision.decidedByRef])[0] },
+    ...decision.sourceRefs === void 0 ? {} : { sourceRefs: sanitizeAdapterInputSourceRefs(decision.sourceRefs) },
+    metadata: sanitizeProviderGraphVisibleRecord(decision.metadata)
+  });
+}
+function emitProposal(ctx, state, proposal) {
+  const key = `proposal:${proposal.proposalId}`;
+  if (state.proposalKeys.has(key)) return;
+  state.proposalKeys.add(key);
+  ctx.down([["DATA", { kind: "proposal", proposal }]]);
+}
+function emitAdmission(ctx, state, admission) {
+  const key = `admission:${admission.admissionId}:${admission.state}:${admission.decisionId ?? ""}:${admission.approvedRunId ?? ""}`;
+  if (state.admissionKeys.has(key)) return;
+  state.admissionKeys.add(key);
+  ctx.down([["DATA", { kind: "admission", admission }]]);
+}
+function emitApprovedRunRequest(ctx, state, request) {
+  const key = `approved-run:${request.runId}`;
+  if (state.approvedRunKeys.has(key)) return;
+  state.approvedRunKeys.add(key);
+  ctx.down([["DATA", { kind: "approved-run-request", request }]]);
+}
+function emitAdmissionStatus(ctx, state, status) {
+  const key = `status:${status.proposalId}:${status.state}:${status.admissionId ?? ""}:${status.decisionId ?? ""}:${status.approvedRunId ?? ""}`;
+  if (state.statusKeys.has(key)) return;
+  state.statusKeys.add(key);
+  ctx.down([["DATA", { kind: "status", status }]]);
+}
+function emitAdmissionIssue(ctx, state, issue) {
+  const key = `issue:${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  ctx.down([["DATA", { kind: "issue", issue }]]);
+}
+function emitAdmissionAudit(ctx, state, kind, subject, metadata) {
+  state.auditSeq += 1;
+  ctx.down([
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: Object.freeze({
+          id: `tool-provider-run-admission-audit-${state.auditSeq}`,
+          kind,
+          message: kind,
+          sourceRefs: [],
+          metadata: sanitizeProviderGraphVisibleRecord({
+            ...metadata,
+            subject
+          })
+        })
+      }
+    ]
+  ]);
+}
+function buildAdmissionViews(state) {
+  return Object.freeze({
+    admissionsByProposal: new Map(state.admissionsByProposal),
+    admissionsByRun: new Map(
+      Array.from(state.admissionsByRun.entries()).map(([key, value]) => [
+        key,
+        Object.freeze([...value])
+      ])
+    ),
+    proposalsByRun: new Map(
+      Array.from(state.proposalsByRun.entries()).map(([key, value]) => [
+        key,
+        Object.freeze([...value])
+      ])
+    )
+  });
+}
+function pushMapArrayBy(map, key, value, entryKey) {
+  const existing = map.get(key);
+  if (existing === void 0) {
+    map.set(key, [value]);
+    return;
+  }
+  const valueKey = entryKey(value);
+  if (existing.some((entry) => entryKey(entry) === valueKey)) return;
+  existing.push(value);
+}
+
+// src/orchestration/agent-runtime-tool-provider-run-retry.ts
+function toolProviderRunRetryProjector(graph, opts) {
+  const name = opts.name ?? "toolProviderRunRetry";
+  const policyDeps = opts.policies ?? [];
+  const nowDeps = opts.nowMs === void 0 ? [] : [opts.nowMs];
+  const readinessDeps = opts.readiness ?? [];
+  const outcomeDepIndex = 1 + policyDeps.length;
+  const nowDepIndex = outcomeDepIndex + 1;
+  const readinessDepStart = nowDepIndex + nowDeps.length;
+  const runtime = graph.node(
+    [opts.inputs, ...policyDeps, opts.outcomes, ...nowDeps, ...readinessDeps],
+    (ctx) => {
+      const state = ctx.state.get() ?? initialRetryState();
+      state.usesSharedReadiness = readinessDeps.length > 0;
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const input = raw;
+        state.inputsById.set(input.adapterInputId, input);
+        let inputIds = state.inputIdsByRequest.get(input.requestId);
+        if (inputIds === void 0) {
+          inputIds = /* @__PURE__ */ new Set();
+          state.inputIdsByRequest.set(input.requestId, inputIds);
+        }
+        inputIds.add(input.adapterInputId);
+      }
+      forEachDepBatch(ctx, 1, policyDeps.length, (raw) => {
+        const policy = sanitizeToolProviderRunRetryPolicy(raw);
+        state.policies.set(policy.policyId, policy);
+      });
+      for (const rawNow of depBatch(ctx, nowDepIndex) ?? []) {
+        if (typeof rawNow === "number" && Number.isFinite(rawNow)) state.nowMs = rawNow;
+      }
+      forEachDepBatch(ctx, readinessDepStart, readinessDeps.length, (raw) => {
+        const ready = sanitizeRetryReadinessReady(raw);
+        if (!ready.ok) {
+          emitIssue2(ctx, state, ready.issue);
+          return;
+        }
+        state.readinessBySchedule.set(ready.scheduleId, ready);
+      });
+      for (const raw of depBatch(ctx, outcomeDepIndex) ?? []) {
+        retainOutcome(state, raw);
+      }
+      evaluateOutcomes(ctx, state);
+      processDueRetries(ctx, state);
+      ctx.down([["DATA", { kind: "views", views: buildRetryViews(state) }]]);
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "toolProviderRunRetryProjector", partial: true }
+  );
+  return {
+    proposals: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/proposals`,
+      "toolProviderRunRetryProposals",
+      (fact) => fact.kind === "proposal" ? fact.proposal : void 0
+    ),
+    scheduled: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/scheduled`,
+      "toolProviderRunRetryScheduled",
+      (fact) => fact.kind === "scheduled" ? fact.scheduled : void 0
+    ),
+    readinessSchedules: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/readinessSchedules`,
+      "toolProviderRunRetryReadinessSchedules",
+      (fact) => fact.kind === "readiness-schedule" ? fact.schedule : void 0
+    ),
+    runRequests: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/runRequests`,
+      "toolProviderRunRetryRunRequests",
+      (fact) => fact.kind === "run-request" ? fact.request : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "toolProviderRunRetryStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "toolProviderRunRetryIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "toolProviderRunRetryAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    ),
+    views: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/views`,
+      "toolProviderRunRetryViews",
+      (fact) => fact.kind === "views" ? fact.views : void 0
+    )
+  };
+}
+function initialRetryState() {
+  return {
+    inputIdsByRequest: /* @__PURE__ */ new Map(),
+    inputsById: /* @__PURE__ */ new Map(),
+    policies: /* @__PURE__ */ new Map(),
+    outcomesById: /* @__PURE__ */ new Map(),
+    proposalsByOutcome: /* @__PURE__ */ new Map(),
+    scheduledByOutcome: /* @__PURE__ */ new Map(),
+    readinessSchedulesByOutcome: /* @__PURE__ */ new Map(),
+    readinessBySchedule: /* @__PURE__ */ new Map(),
+    nextRequestsByOutcome: /* @__PURE__ */ new Map(),
+    statusByOutcome: /* @__PURE__ */ new Map(),
+    proposalKeys: /* @__PURE__ */ new Set(),
+    scheduledKeys: /* @__PURE__ */ new Set(),
+    readinessScheduleKeys: /* @__PURE__ */ new Set(),
+    requestKeys: /* @__PURE__ */ new Set(),
+    statusKeys: /* @__PURE__ */ new Set(),
+    issueKeys: /* @__PURE__ */ new Set(),
+    auditSeq: 0,
+    nowMs: void 0,
+    usesSharedReadiness: false
+  };
+}
+function retainOutcome(state, outcome) {
+  if (!state.outcomesById.has(outcome.outcomeId))
+    state.outcomesById.set(outcome.outcomeId, outcome);
+}
+function inputForOutcome(state, outcome) {
+  if (typeof outcome.inputId === "string" && outcome.inputId.length > 0) {
+    const exactInput = state.inputsById.get(outcome.inputId);
+    if (exactInput !== void 0) return { ok: true, input: exactInput };
+    return {
+      ok: false,
+      issue: dataIssue(
+        "tool-provider-run-retry-missing-input",
+        "Tool provider run retry requires the retained adapter input identified by the outcome.",
+        {
+          subjectId: outcome.inputId,
+          refs: [ref("executor-outcome", outcome.outcomeId)]
+        }
+      )
+    };
+  }
+  const inputIds = state.inputIdsByRequest.get(outcome.requestId);
+  if (inputIds === void 0 || inputIds.size === 0) {
+    return {
+      ok: false,
+      issue: dataIssue(
+        "tool-provider-run-retry-missing-input",
+        "Tool provider run retry requires a retained adapter input for the outcome request.",
+        { subjectId: outcome.requestId, refs: [ref("executor-outcome", outcome.outcomeId)] }
+      )
+    };
+  }
+  if (inputIds.size > 1) {
+    return {
+      ok: false,
+      issue: dataIssue(
+        "tool-provider-run-retry-ambiguous-input",
+        "Tool provider run retry requires an exact outcome inputId when multiple adapter inputs share a request.",
+        {
+          subjectId: outcome.requestId,
+          refs: [ref("executor-outcome", outcome.outcomeId)],
+          details: { inputIds: [...inputIds].sort() }
+        }
+      )
+    };
+  }
+  const [inputId] = inputIds;
+  const input = inputId === void 0 ? void 0 : state.inputsById.get(inputId);
+  if (input !== void 0) return { ok: true, input };
+  return {
+    ok: false,
+    issue: dataIssue(
+      "tool-provider-run-retry-missing-input",
+      "Tool provider run retry requires a retained adapter input for the outcome request.",
+      { subjectId: outcome.requestId, refs: [ref("executor-outcome", outcome.outcomeId)] }
+    )
+  };
+}
+function evaluateOutcomes(ctx, state) {
+  for (const outcome of state.outcomesById.values()) evaluateOutcome(ctx, state, outcome);
+}
+function evaluateOutcome(ctx, state, outcome) {
+  const inputResolution = inputForOutcome(state, outcome);
+  if (!inputResolution.ok) {
+    emitIssue2(ctx, state, inputResolution.issue);
+    emitStatus2(ctx, state, statusForMissingInput(outcome, "blocked", [inputResolution.issue]));
+    return;
+  }
+  const input = inputResolution.input;
+  if (input.status !== "ready") {
+    const issue = dataIssue(
+      "tool-provider-run-retry-input-not-ready",
+      "Tool provider run retry requires a ready adapter input.",
+      {
+        subjectId: input.adapterInputId,
+        refs: [
+          ref("executor-outcome", outcome.outcomeId),
+          ref("tool-provider-adapter-input", input.adapterInputId)
+        ],
+        details: { status: input.status }
+      }
+    );
+    emitIssue2(ctx, state, issue);
+    emitStatus2(ctx, state, statusForOutcome(outcome, input, "blocked", { issues: [issue] }));
+    return;
+  }
+  if (!isRetryableOutcome(outcome)) {
+    emitStatus2(ctx, state, statusForOutcome(outcome, input, "not-retryable"));
+    return;
+  }
+  if (state.scheduledByOutcome.has(outcome.outcomeId) || state.nextRequestsByOutcome.has(outcome.outcomeId)) {
+    return;
+  }
+  const choice = chooseRetryPolicy(state, input, outcome);
+  if (choice === void 0) {
+    const issue = dataIssue(
+      "tool-provider-run-retry-policy-missing",
+      "Tool provider run retry requires an explicit retry policy fact.",
+      {
+        subjectId: input.adapterInputId,
+        refs: [
+          ref("executor-outcome", outcome.outcomeId),
+          ref("tool-provider-adapter-input", input.adapterInputId)
+        ]
+      }
+    );
+    emitIssue2(ctx, state, issue);
+    emitStatus2(ctx, state, statusForOutcome(outcome, input, "not-retryable", { issues: [issue] }));
+    return;
+  }
+  if (!shouldRetry(choice.policy.retryPolicy, outcome.attempt)) {
+    const issue = dataIssue(
+      "tool-provider-run-retry-exhausted",
+      "Tool provider run retry policy exhausted available attempts.",
+      {
+        subjectId: input.adapterInputId,
+        refs: retrySourceRefs(input, outcome, choice.policy),
+        severity: "warning",
+        details: {
+          attempt: outcome.attempt,
+          maxAttempts: choice.policy.retryPolicy.maxAttempts
+        }
+      }
+    );
+    emitIssue2(ctx, state, issue);
+    emitStatus2(
+      ctx,
+      state,
+      statusForOutcome(outcome, input, "exhausted", { choice, issues: [issue] })
+    );
+    return;
+  }
+  const nextAttempt = outcome.attempt + 1;
+  const delayMs = nextRetryDelayMs(choice.policy.retryPolicy, nextAttempt);
+  if (delayMs === void 0) {
+    const issue = dataIssue(
+      "tool-provider-run-retry-delay-unavailable",
+      "Tool provider run retry could not compute a delay for the next attempt.",
+      {
+        subjectId: input.adapterInputId,
+        refs: retrySourceRefs(input, outcome, choice.policy)
+      }
+    );
+    emitIssue2(ctx, state, issue);
+    emitStatus2(
+      ctx,
+      state,
+      statusForOutcome(outcome, input, "blocked", { choice, issues: [issue] })
+    );
+    return;
+  }
+  const proposal = retryProposal(input, outcome, choice, delayMs);
+  state.proposalsByOutcome.set(outcome.outcomeId, proposal);
+  emitProposal2(ctx, state, proposal);
+  if (delayMs <= 0) {
+    emitRunRequest(ctx, state, input, proposal, "immediate");
+    return;
+  }
+  if (state.nowMs === void 0) {
+    const issue = dataIssue(
+      "tool-provider-run-retry-now-missing",
+      "Tool provider delayed retry requires a graph-visible nowMs input.",
+      {
+        subjectId: input.adapterInputId,
+        refs: retrySourceRefs(input, outcome, choice.policy)
+      }
+    );
+    emitIssue2(ctx, state, issue);
+    emitStatus2(
+      ctx,
+      state,
+      statusForOutcome(outcome, input, "blocked", { choice, proposal, issues: [issue], delayMs })
+    );
+    return;
+  }
+  const scheduled = retryScheduled(input, outcome, proposal, state.nowMs + delayMs, delayMs);
+  state.scheduledByOutcome.set(outcome.outcomeId, scheduled);
+  emitScheduled(ctx, state, scheduled);
+  const readinessSchedule = retryReadinessSchedule(input, outcome, proposal, scheduled);
+  state.readinessSchedulesByOutcome.set(outcome.outcomeId, readinessSchedule);
+  emitReadinessSchedule(ctx, state, readinessSchedule);
+  emitStatus2(
+    ctx,
+    state,
+    statusForOutcome(outcome, input, "scheduled", {
+      choice,
+      proposal,
+      delayMs,
+      retryAtMs: scheduled.retryAtMs
+    })
+  );
+}
+function processDueRetries(ctx, state) {
+  for (const [outcomeId, scheduled] of state.scheduledByOutcome) {
+    const readiness = state.readinessBySchedule.get(
+      scheduled.readinessScheduleId ?? scheduled.scheduleId
+    );
+    const readinessSchedule = state.readinessSchedulesByOutcome.get(outcomeId);
+    const readyByReadiness = readiness !== void 0 && readiness.readyAtMs === scheduled.retryAtMs && readiness.nowMs >= scheduled.retryAtMs && readinessSchedule !== void 0 && readinessMatchesSchedule(readiness, readinessSchedule);
+    if (readiness !== void 0 && !readyByReadiness) {
+      emitIssue2(
+        ctx,
+        state,
+        dataIssue(
+          "tool-provider-run-retry-readiness-mismatch",
+          "Tool provider delayed retry readiness fact does not match the scheduled retry eligibility.",
+          {
+            subjectId: scheduled.scheduleId,
+            refs: sanitizeAdapterInputSourceRefs([
+              ref("tool-provider-run-retry-scheduled", scheduled.scheduleId),
+              ref("scheduled-readiness-ready", readiness.scheduleId)
+            ]),
+            details: {
+              retryAtMs: scheduled.retryAtMs,
+              readyAtMs: readiness.readyAtMs,
+              nowMs: readiness.nowMs
+            }
+          }
+        )
+      );
+    }
+    const readyByClock = !state.usesSharedReadiness && state.nowMs !== void 0 && scheduled.retryAtMs <= state.nowMs;
+    if (!readyByReadiness && !readyByClock) continue;
+    if (state.nextRequestsByOutcome.has(outcomeId)) continue;
+    const proposal = state.proposalsByOutcome.get(outcomeId);
+    if (proposal === void 0) continue;
+    const input = state.inputsById.get(proposal.adapterInputId);
+    if (input === void 0) continue;
+    emitRunRequest(ctx, state, input, proposal, "scheduled", readiness);
+  }
+}
+function sanitizeRetryReadinessReady(raw) {
+  if (!isRecord(raw) || raw.kind !== "scheduled-readiness-ready" || typeof raw.scheduleId !== "string" || raw.scheduleId.length === 0 || typeof raw.readyAtMs !== "number" || !Number.isFinite(raw.readyAtMs) || typeof raw.nowMs !== "number" || !Number.isFinite(raw.nowMs) || !Array.isArray(raw.subjectRefs) || raw.sourceRefs !== void 0 && !Array.isArray(raw.sourceRefs)) {
+    return {
+      ok: false,
+      issue: dataIssue(
+        "tool-provider-run-retry-readiness-malformed",
+        "Tool provider delayed retry readiness fact must be graph-visible scheduled readiness material.",
+        {
+          subjectId: isRecord(raw) && typeof raw.scheduleId === "string" ? raw.scheduleId : "unknown-scheduled-readiness"
+        }
+      )
+    };
+  }
+  return Object.freeze({
+    ok: true,
+    kind: "scheduled-readiness-ready",
+    scheduleId: raw.scheduleId,
+    subjectRefs: sanitizeAdapterInputSourceRefs(
+      raw.subjectRefs.flatMap((entry) => {
+        const sourceRef = sourceRefOrUndefined(entry);
+        return sourceRef === void 0 ? [] : [sourceRef];
+      })
+    ),
+    readyAtMs: raw.readyAtMs,
+    ...typeof raw.deadlineMs === "number" && Number.isFinite(raw.deadlineMs) ? { deadlineMs: raw.deadlineMs } : {},
+    nowMs: raw.nowMs,
+    ...raw.sourceRefs === void 0 ? {} : {
+      sourceRefs: sanitizeAdapterInputSourceRefs(
+        raw.sourceRefs.flatMap((entry) => {
+          const sourceRef = sourceRefOrUndefined(entry);
+          return sourceRef === void 0 ? [] : [sourceRef];
+        })
+      )
+    },
+    ...isRecord(raw.metadata) ? { metadata: sanitizeProviderGraphVisibleRecord(raw.metadata) } : {}
+  });
+}
+function readinessMatchesSchedule(readiness, schedule) {
+  const subjectRefs = sanitizeAdapterInputSourceRefs(schedule.subjectRefs);
+  const readySubjectRefs = sanitizeAdapterInputSourceRefs(readiness.subjectRefs);
+  if (!sourceRefsContainAll(readySubjectRefs, subjectRefs)) return false;
+  return sourceRefsContainAll(sanitizeAdapterInputSourceRefs(readiness.sourceRefs ?? []), [
+    ref("scheduled-readiness", schedule.scheduleId),
+    ...schedule.sourceRefs ?? []
+  ]);
+}
+function sourceRefsContainAll(actual, expected) {
+  const actualKeys = new Set(actual.map(sourceRefKey));
+  return expected.every((sourceRef) => actualKeys.has(sourceRefKey(sourceRef)));
+}
+function sourceRefKey(sourceRef) {
+  return `${sourceRef.kind}:${sourceRef.id}`;
+}
+function sourceRefOrUndefined(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.kind !== "string" || value.kind.length === 0) return void 0;
+  if (typeof value.id !== "string" || value.id.length === 0) return void 0;
+  return isRecord(value.metadata) ? { kind: value.kind, id: value.id, metadata: value.metadata } : { kind: value.kind, id: value.id };
+}
+function sanitizeToolProviderRunRetryPolicy(raw) {
+  const metadata = sanitizeProviderGraphVisibleRecord(raw.metadata);
+  return Object.freeze({
+    kind: "tool-provider-run-retry-policy",
+    policyId: raw.policyId,
+    retryPolicy: sanitizeRetryPolicy(raw.retryPolicy),
+    ...raw.runId === void 0 ? {} : { runId: raw.runId },
+    ...raw.requestId === void 0 ? {} : { requestId: raw.requestId },
+    ...raw.adapterInputId === void 0 ? {} : { adapterInputId: raw.adapterInputId },
+    sourceRefs: sanitizeAdapterInputSourceRefs(raw.sourceRefs ?? []),
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function sanitizeRetryPolicy(policy) {
+  if (!Number.isInteger(policy.maxAttempts) || policy.maxAttempts <= 0) {
+    return Object.freeze({ maxAttempts: 1, backoff: { kind: "none" } });
+  }
+  return Object.freeze(policy);
+}
+function chooseRetryPolicy(state, input, outcome) {
+  let best;
+  for (const policy of state.policies.values()) {
+    const score = retryPolicyScore(policy, input, outcome);
+    if (score === void 0) continue;
+    if (best === void 0 || score > best.score) best = { policy, score };
+  }
+  return best;
+}
+function retryPolicyScore(policy, input, outcome) {
+  let score = 0;
+  if (policy.adapterInputId !== void 0) {
+    if (policy.adapterInputId !== input.adapterInputId) return void 0;
+    score += 8;
+  }
+  if (policy.requestId !== void 0) {
+    if (policy.requestId !== outcome.requestId) return void 0;
+    score += 4;
+  }
+  if (policy.runId !== void 0) {
+    if (policy.runId !== outcomeRunId(outcome)) return void 0;
+    score += 2;
+  }
+  return score;
+}
+function retryProposal(input, outcome, choice, delayMs) {
+  const fromRunId = outcomeRunId(outcome);
+  const nextAttempt = outcome.attempt + 1;
+  const policyRefs = retryPolicyRefs(input, choice.policy);
+  const sourceRefs = retrySourceRefs(input, outcome, choice.policy);
+  return Object.freeze({
+    kind: "tool-provider-run-retry-proposal",
+    proposalId: `${outcome.outcomeId}:retry-proposal`,
+    outcomeId: outcome.outcomeId,
+    fromRunId,
+    fromRequestId: outcome.requestId,
+    fromAttempt: outcome.attempt,
+    nextAttempt,
+    nextRunId: `${fromRunId}:retry-${nextAttempt}`,
+    adapterInputId: input.adapterInputId,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    policyId: choice.policy.policyId,
+    policyRefs,
+    maxAttempts: choice.policy.retryPolicy.maxAttempts,
+    nextDelayMs: delayMs,
+    sourceRefs,
+    metadata: sanitizeProviderGraphVisibleRecord({ policyScore: choice.score })
+  });
+}
+function retryScheduled(input, outcome, proposal, retryAtMs, delayMs) {
+  return Object.freeze({
+    kind: "tool-provider-run-retry-scheduled",
+    scheduleId: `${proposal.proposalId}:scheduled`,
+    readinessScheduleId: `${proposal.proposalId}:scheduled-readiness`,
+    outcomeId: outcome.outcomeId,
+    proposalId: proposal.proposalId,
+    fromRunId: proposal.fromRunId,
+    nextRunId: proposal.nextRunId,
+    nextAttempt: proposal.nextAttempt,
+    retryAtMs,
+    retryAfterMs: delayMs,
+    sourceRefs: sanitizeAdapterInputSourceRefs([
+      ref("executor-outcome", outcome.outcomeId),
+      ref("tool-provider-run-retry-proposal", proposal.proposalId),
+      ref("tool-provider-adapter-input", input.adapterInputId)
+    ])
+  });
+}
+function retryReadinessSchedule(input, outcome, proposal, scheduled) {
+  return Object.freeze({
+    kind: "scheduled-readiness-requested",
+    scheduleId: scheduled.readinessScheduleId ?? scheduled.scheduleId,
+    subjectRefs: sanitizeAdapterInputSourceRefs([
+      ref("tool-provider-run-retry-proposal", proposal.proposalId),
+      ref("tool-provider-run-retry-scheduled", scheduled.scheduleId),
+      ref("tool-provider-adapter-input", input.adapterInputId)
+    ]),
+    readyAtMs: scheduled.retryAtMs,
+    reason: "tool-provider-retry",
+    policyRefs: proposal.policyRefs,
+    sourceRefs: sanitizeAdapterInputSourceRefs([
+      ref("executor-outcome", outcome.outcomeId),
+      ref("tool-provider-run-retry-proposal", proposal.proposalId),
+      ref("tool-provider-run-retry-scheduled", scheduled.scheduleId),
+      ...scheduled.sourceRefs ?? []
+    ]),
+    metadata: sanitizeProviderGraphVisibleRecord({
+      outcomeId: outcome.outcomeId,
+      nextRunId: proposal.nextRunId,
+      nextAttempt: proposal.nextAttempt,
+      retryAfterMs: scheduled.retryAfterMs
+    })
+  });
+}
+function emitRunRequest(ctx, state, input, proposal, mode, readiness) {
+  const key = `request:${proposal.outcomeId}:${proposal.nextRunId}`;
+  if (state.requestKeys.has(key)) return;
+  state.requestKeys.add(key);
+  const request = requestToolProviderAdapterRun(input, {
+    runId: proposal.nextRunId,
+    attempt: proposal.nextAttempt,
+    reason: "retry",
+    retryOfOutcomeId: proposal.outcomeId,
+    policyRefs: proposal.policyRefs,
+    sourceRefs: uniqueSourceRefs([
+      ...proposal.sourceRefs ?? [],
+      ref("tool-provider-run-retry-proposal", proposal.proposalId),
+      ...mode === "scheduled" ? [ref("tool-provider-run-retry-scheduled", `${proposal.proposalId}:scheduled`)] : [],
+      ...readiness === void 0 ? [] : [
+        ref("scheduled-readiness-ready", readiness.scheduleId),
+        ...readiness.sourceRefs ?? []
+      ]
+    ]),
+    metadata: {
+      retryMode: mode,
+      retryProposalId: proposal.proposalId,
+      retryOfOutcomeId: proposal.outcomeId,
+      ...readiness === void 0 ? {} : { readinessScheduleId: readiness.scheduleId }
+    }
+  });
+  state.nextRequestsByOutcome.set(proposal.outcomeId, request);
+  emitStatus2(ctx, state, statusForProposal(input, proposal, "ready"));
+  emitAudit(ctx, state, "tool-provider-run-retry-run-requested", {
+    subjectId: request.requestId,
+    sourceRefs: request.sourceRefs,
+    metadata: {
+      runId: request.runId,
+      adapterInputId: request.adapterInputId,
+      attempt: request.attempt,
+      retryOfOutcomeId: request.retryOfOutcomeId,
+      retryMode: mode
+    }
+  });
+  ctx.down([["DATA", { kind: "run-request", request }]]);
+}
+function emitProposal2(ctx, state, proposal) {
+  const key = `proposal:${proposal.proposalId}`;
+  if (state.proposalKeys.has(key)) return;
+  state.proposalKeys.add(key);
+  emitAudit(ctx, state, "tool-provider-run-retry-proposed", {
+    subjectId: proposal.requestId,
+    sourceRefs: proposal.sourceRefs,
+    metadata: {
+      proposalId: proposal.proposalId,
+      outcomeId: proposal.outcomeId,
+      nextAttempt: proposal.nextAttempt,
+      nextDelayMs: proposal.nextDelayMs
+    }
+  });
+  ctx.down([["DATA", { kind: "proposal", proposal }]]);
+}
+function emitScheduled(ctx, state, scheduled) {
+  const key = `scheduled:${scheduled.scheduleId}`;
+  if (state.scheduledKeys.has(key)) return;
+  state.scheduledKeys.add(key);
+  emitAudit(ctx, state, "tool-provider-run-retry-scheduled", {
+    sourceRefs: scheduled.sourceRefs,
+    metadata: {
+      scheduleId: scheduled.scheduleId,
+      outcomeId: scheduled.outcomeId,
+      nextAttempt: scheduled.nextAttempt,
+      retryAtMs: scheduled.retryAtMs
+    }
+  });
+  ctx.down([["DATA", { kind: "scheduled", scheduled }]]);
+}
+function emitReadinessSchedule(ctx, state, schedule) {
+  const key = `readiness-schedule:${schedule.scheduleId}`;
+  if (state.readinessScheduleKeys.has(key)) return;
+  state.readinessScheduleKeys.add(key);
+  emitAudit(ctx, state, "tool-provider-run-retry-readiness-scheduled", {
+    sourceRefs: schedule.sourceRefs,
+    metadata: {
+      scheduleId: schedule.scheduleId,
+      readyAtMs: schedule.readyAtMs
+    }
+  });
+  ctx.down([["DATA", { kind: "readiness-schedule", schedule }]]);
+}
+function emitStatus2(ctx, state, status) {
+  const key = `${status.outcomeId}:${status.state}:${status.nextAttempt ?? ""}:${status.nextRetryAtMs ?? ""}:${(status.issueCodes ?? []).join(",")}`;
+  if (state.statusKeys.has(key)) return;
+  state.statusKeys.add(key);
+  state.statusByOutcome.set(status.outcomeId, status);
+  ctx.down([["DATA", { kind: "status", status }]]);
+}
+function emitIssue2(ctx, state, issue) {
+  const sanitized = sanitizeAdapterInputIssue(issue);
+  const key = `${sanitized.code}:${sanitized.subjectId ?? ""}:${JSON.stringify(sanitized.details ?? {})}`;
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  ctx.down([["DATA", { kind: "issue", issue: sanitized }]]);
+}
+function emitAudit(ctx, state, kind, opts = {}) {
+  state.auditSeq += 1;
+  const metadata = sanitizeProviderGraphVisibleRecord(opts.metadata);
+  ctx.down([
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: Object.freeze({
+          id: `tool-provider-run-retry-audit-${state.auditSeq}`,
+          kind,
+          ...opts.subjectId === void 0 ? {} : { subjectId: opts.subjectId },
+          ...opts.sourceRefs === void 0 ? {} : { sourceRefs: sanitizeAdapterInputSourceRefs(opts.sourceRefs) },
+          ...metadata === void 0 ? {} : { metadata }
+        })
+      }
+    ]
+  ]);
+}
+function statusForOutcome(outcome, input, state, opts = {}) {
+  const proposal = opts.proposal;
+  const nextAttempt = proposal?.nextAttempt ?? (opts.choice === void 0 ? void 0 : outcome.attempt + 1);
+  return Object.freeze({
+    kind: "tool-provider-run-retry-status",
+    statusId: `${outcome.outcomeId}:retry-status:${state}`,
+    outcomeId: outcome.outcomeId,
+    proposalId: proposal?.proposalId ?? `${outcome.outcomeId}:retry-proposal`,
+    fromRunId: outcomeRunId(outcome),
+    adapterInputId: input.adapterInputId,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    ...proposal?.nextRunId === void 0 ? {} : { nextRunId: proposal.nextRunId },
+    ...nextAttempt === void 0 ? {} : { nextAttempt },
+    ...opts.retryAtMs === void 0 ? {} : { nextRetryAtMs: opts.retryAtMs },
+    state,
+    sourceRefs: retrySourceRefs(input, outcome, opts.choice?.policy),
+    ...opts.issues === void 0 || opts.issues.length === 0 ? {} : { issueCodes: Object.freeze(opts.issues.map((issue) => issue.code)) },
+    ...optionalMetadata({
+      ...opts.delayMs === void 0 ? {} : { delayMs: opts.delayMs },
+      ...opts.choice === void 0 ? {} : { maxAttempts: opts.choice.policy.retryPolicy.maxAttempts }
+    })
+  });
+}
+function statusForProposal(input, proposal, state) {
+  return Object.freeze({
+    kind: "tool-provider-run-retry-status",
+    statusId: `${proposal.outcomeId}:retry-status:${state}`,
+    outcomeId: proposal.outcomeId,
+    proposalId: proposal.proposalId,
+    fromRunId: proposal.fromRunId,
+    adapterInputId: input.adapterInputId,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    nextRunId: proposal.nextRunId,
+    nextAttempt: proposal.nextAttempt,
+    state,
+    sourceRefs: proposal.sourceRefs,
+    ...optionalMetadata({ maxAttempts: proposal.maxAttempts })
+  });
+}
+function statusForMissingInput(outcome, state, issues) {
+  return Object.freeze({
+    kind: "tool-provider-run-retry-status",
+    statusId: `${outcome.outcomeId}:retry-status:${state}`,
+    outcomeId: outcome.outcomeId,
+    proposalId: `${outcome.outcomeId}:retry-proposal`,
+    fromRunId: outcomeRunId(outcome),
+    adapterInputId: outcome.inputId ?? outcome.requestId,
+    requestId: outcome.requestId,
+    operationId: outcome.operationId,
+    state,
+    sourceRefs: [ref("executor-outcome", outcome.outcomeId)],
+    issueCodes: Object.freeze(issues.map((issue) => issue.code))
+  });
+}
+function isRetryableOutcome(outcome) {
+  return (outcome.kind === "failure" || outcome.kind === "timeout") && outcome.retryable === true;
+}
+function retryPolicyRefs(input, policy) {
+  return sanitizeAdapterInputSourceRefs([
+    ref("tool-provider-run-retry-policy", policy.policyId),
+    ...policy.sourceRefs ?? [],
+    ...input.policyRefs ?? []
+  ]);
+}
+function retrySourceRefs(input, outcome, policy) {
+  return sanitizeAdapterInputSourceRefs([
+    ref("executor-outcome", outcome.outcomeId),
+    ref("tool-provider-adapter-input", input.adapterInputId),
+    ...outcome.evidenceRefs ?? [],
+    ...input.sourceRefs ?? [],
+    ...policy === void 0 ? [] : retryPolicyRefs(input, policy)
+  ]);
+}
+function outcomeRunId(outcome) {
+  const runId = isRecord(outcome.metadata) ? outcome.metadata.runId : void 0;
+  if (typeof runId === "string" && runId.length > 0) return runId;
+  return `${outcome.requestId}:attempt-${outcome.attempt}`;
+}
+function optionalMetadata(value) {
+  const metadata = sanitizeProviderGraphVisibleRecord(value);
+  return metadata === void 0 ? {} : { metadata };
+}
+function buildRetryViews(state) {
+  return Object.freeze({
+    proposalsByOutcome: new Map(state.proposalsByOutcome),
+    scheduledByOutcome: new Map(state.scheduledByOutcome),
+    readinessSchedulesByOutcome: new Map(state.readinessSchedulesByOutcome),
+    readinessBySchedule: new Map(state.readinessBySchedule),
+    nextRunRequestsByOutcome: new Map(state.nextRequestsByOutcome),
+    statusByOutcome: new Map(state.statusByOutcome)
+  });
+}
+
+// src/orchestration/agent-runtime-types-core.ts
+function effectRun(opts) {
+  return {
+    kind: "effect-run",
+    effectRunId: opts.effectRunId,
+    agentRunId: opts.agentRunId,
+    subjectRefs: opts.subjectRefs,
+    goal: opts.goal,
+    sourceRefs: opts.sourceRefs,
+    policyRefs: opts.policyRefs,
+    limits: opts.limits,
+    createdBy: opts.createdBy,
+    createdAtMs: opts.createdAtMs,
+    metadata: opts.metadata
+  };
+}
+
+// src/orchestration/process-utils.ts
+function cloneProcessState(state) {
+  if (typeof state !== "object" || state === null) return { ok: true, value: state };
+  try {
+    if (typeof globalThis.structuredClone === "function") {
+      return { ok: true, value: globalThis.structuredClone(state) };
+    }
+    return { ok: true, value: JSON.parse(JSON.stringify(state)) };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `processBundle: state must be cloneable before reducer execution (${errorMessage(error)})`
+    };
+  }
+}
+function readTimestampMs(now) {
+  try {
+    const timestampMs = now();
+    if (!Number.isFinite(timestampMs)) return "processBundle: now() must return a finite number";
+    return timestampMs;
+  } catch (error) {
+    return errorMessage(error);
+  }
+}
+function rethrowGraphRuntimeInvariant(error) {
+  const message = errorMessage(error);
+  if (message.includes("R-reentrancy") || message.includes("R-rewire") || message.includes("R-graph-domain") || message.includes("D37") || message.includes("D22") || message.includes("different graph") || message.includes("cross-graph") || message.includes("wire bridge") || message.includes("mid-fn topology mutation") || message.includes("reentrant dep mutation") || message.includes("feedback cycle")) {
+    throw error;
+  }
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/orchestration/process.ts
+var processCommandSources = /* @__PURE__ */ new WeakMap();
+function processBundle(graph, opts) {
+  if (typeof opts.reduce !== "function") {
+    throw new TypeError("processBundle: reduce must be a function");
+  }
+  if (opts.initialState === void 0) {
+    throw new TypeError("processBundle: initialState must not be undefined");
+  }
+  const name = opts.name ?? "process";
+  const now = opts.now ?? Date.now;
+  const topology = graph.topologyGroup({ name: `${name}.process` });
+  const command = topology.node([], null, {
+    name: `${name}/command`,
+    factory: "processCommand",
+    completeWhenDepsComplete: false,
+    errorWhenDepsError: false
+  });
+  const runtime = topology.node(
+    [command],
+    (ctx) => {
+      let state2 = ctx.state.get() ?? {
+        eventSeq: 0,
+        effectSeq: 0,
+        commandCount: 0,
+        errorCount: 0,
+        auditSeq: 0,
+        seenEventIds: [],
+        seenEffectIds: [],
+        state: opts.initialState
+      };
+      ctx.state.persist(true);
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        state2 = reduceProcessCommandFact(
+          raw,
+          state2,
+          opts.reduce,
+          now,
+          (fact) => ctx.down([["DATA", fact]])
+        );
+        ctx.state.set(state2);
+      }
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "processRuntime",
+      meta: { process: "facts-plus-reducer", d: "D136" },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const events = processProjection(
+    topology,
+    runtime,
+    `${name}/events`,
+    "processEvents",
+    (fact) => fact.kind === "event" ? fact.event : void 0
+  );
+  const state = processProjection(
+    topology,
+    runtime,
+    `${name}/state`,
+    "processState",
+    (fact) => fact.kind === "state" ? fact.state : void 0
+  );
+  const audit = processProjection(
+    topology,
+    runtime,
+    `${name}/audit`,
+    "processAudit",
+    (fact) => fact.kind === "audit" ? fact.audit : void 0
+  );
+  const effectRequests = processProjection(
+    topology,
+    runtime,
+    `${name}/effectRequests`,
+    "processEffectRequests",
+    (fact) => fact.kind === "effect-request" ? fact.effect : void 0
+  );
+  const status = processProjection(
+    topology,
+    runtime,
+    `${name}/status`,
+    "processStatus",
+    (fact) => fact.kind === "status" ? fact.status : void 0
+  );
+  const errors = processProjection(
+    topology,
+    runtime,
+    `${name}/errors`,
+    "processErrors",
+    (fact) => fact.kind === "error" ? fact.error : void 0
+  );
+  const cursor = processProjection(
+    topology,
+    runtime,
+    `${name}/cursor`,
+    "processCursor",
+    (fact) => fact.kind === "cursor" ? fact.cursor : void 0
+  );
+  const retainProcessNodes = () => [
+    graph.retain(runtime, { reason: `${name}.process.runtime` }),
+    graph.retain(events, { reason: `${name}.process.events` }),
+    graph.retain(state, { reason: `${name}.process.state` }),
+    graph.retain(audit, { reason: `${name}.process.audit` }),
+    graph.retain(effectRequests, { reason: `${name}.process.effectRequests` }),
+    graph.retain(status, { reason: `${name}.process.status` }),
+    graph.retain(errors, { reason: `${name}.process.errors` }),
+    graph.retain(cursor, { reason: `${name}.process.cursor` })
+  ];
+  let releaseRetains = retainProcessNodes();
+  let released = false;
+  const bundle = {
+    command,
+    events,
+    state,
+    audit,
+    effectRequests,
+    status,
+    errors,
+    cursor,
+    dispatch(next) {
+      command.down([["DATA", next]]);
+      return next;
+    },
+    release() {
+      if (released) return;
+      const activeRetains = releaseRetains;
+      releaseRetains = [];
+      for (const releaseRetain of activeRetains) releaseRetain();
+      try {
+        topology.release({ reason: `${name}.process.release` });
+        released = true;
+        processCommandSources.delete(
+          bundle
+        );
+      } catch (error) {
+        releaseRetains = retainProcessNodes();
+        throw error;
+      }
+    }
+  };
+  processCommandSources.set(
+    bundle,
+    { sources: [] }
+  );
+  return bundle;
+}
+function processEffectRunner(graph, process, opts) {
+  if (opts.outcomes.length === 0) {
+    throw new RangeError("processEffectRunner: outcomes must contain at least one node");
+  }
+  const name = opts.name ?? "processEffectRunner";
+  const topology = graph.topologyGroup({ name: `${name}.effectRunner` });
+  const requests = topology.node(
+    [process.effectRequests],
+    (ctx) => {
+      for (const request of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", request]]);
+      }
+    },
+    {
+      name: `${name}/requests`,
+      factory: "processEffectRunnerRequests",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const runtime = topology.node(
+    [...opts.outcomes],
+    (ctx) => {
+      for (let i = 0; i < opts.outcomes.length; i += 1) {
+        for (const raw of depBatch(ctx, i) ?? []) {
+          const parsed = parseProcessEffectOutcome(raw);
+          if (typeof parsed === "string") {
+            const error = {
+              code: "malformed-outcome",
+              message: parsed,
+              outcome: raw
+            };
+            ctx.down([["DATA", { kind: "error", error }]]);
+            continue;
+          }
+          const outcome = parsed;
+          const command = processEffectOutcomeCommand(outcome);
+          ctx.down([["DATA", { kind: "outcome", outcome }]]);
+          ctx.down([["DATA", { kind: "command", command }]]);
+        }
+      }
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "processEffectRunner",
+      meta: { process: "effect-runner", d: "D156" },
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const outcomes = processEffectRunnerProjection(
+    topology,
+    runtime,
+    `${name}/outcomes`,
+    "processEffectRunnerOutcomes",
+    (fact) => fact.kind === "outcome" ? fact.outcome : void 0
+  );
+  const commands = processEffectRunnerProjection(
+    topology,
+    runtime,
+    `${name}/commands`,
+    "processEffectRunnerCommands",
+    (fact) => fact.kind === "command" ? fact.command : void 0
+  );
+  const errors = processEffectRunnerProjection(
+    topology,
+    runtime,
+    `${name}/errors`,
+    "processEffectRunnerErrors",
+    (fact) => fact.kind === "error" ? fact.error : void 0
+  );
+  const status = topology.node(
+    [requests, runtime],
+    (ctx) => {
+      let state = ctx.state.get() ?? { requested: 0, commanded: 0, rejected: 0 };
+      for (const request of depBatch(ctx, 0) ?? []) {
+        state = { ...state, requested: state.requested + 1 };
+        const typedRequest = request;
+        ctx.down([
+          [
+            "DATA",
+            {
+              state: "requested",
+              effectId: typedRequest.id,
+              effectType: typedRequest.type,
+              requested: state.requested,
+              commanded: state.commanded,
+              rejected: state.rejected
+            }
+          ]
+        ]);
+      }
+      for (const fact of depBatch(ctx, 1) ?? []) {
+        const typedFact = fact;
+        if (typedFact.kind === "command") {
+          state = { ...state, commanded: state.commanded + 1 };
+          ctx.down([
+            [
+              "DATA",
+              {
+                state: "commanded",
+                effectId: typedFact.command.payload.effectId,
+                effectType: typedFact.command.payload.effectType,
+                commandId: typedFact.command.id,
+                commandType: typedFact.command.type,
+                requested: state.requested,
+                commanded: state.commanded,
+                rejected: state.rejected
+              }
+            ]
+          ]);
+        }
+        if (typedFact.kind === "error") {
+          state = { ...state, rejected: state.rejected + 1 };
+          ctx.down([
+            [
+              "DATA",
+              {
+                state: "rejected",
+                effectId: typedFact.error.effectId,
+                effectType: typedFact.error.effectType,
+                requested: state.requested,
+                commanded: state.commanded,
+                rejected: state.rejected
+              }
+            ]
+          ]);
+        }
+      }
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/status`,
+      factory: "processEffectRunnerStatus",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const retainRunnerNodes = () => [
+    graph.retain(requests, { reason: `${name}.effectRunner.requests` }),
+    graph.retain(outcomes, { reason: `${name}.effectRunner.outcomes` }),
+    graph.retain(commands, { reason: `${name}.effectRunner.commands` }),
+    graph.retain(status, { reason: `${name}.effectRunner.status` }),
+    graph.retain(errors, { reason: `${name}.effectRunner.errors` })
+  ];
+  let releaseRetains = retainRunnerNodes();
+  try {
+    attachProcessCommandSource(process, commands);
+  } catch (error) {
+    for (const releaseRetain of releaseRetains) releaseRetain();
+    releaseRetains = [];
+    topology.release({ reason: `${name}.effectRunner.failedAttach` });
+    throw error;
+  }
+  let released = false;
+  return {
+    requests,
+    outcomes,
+    commands,
+    status,
+    errors,
+    release() {
+      if (released) return;
+      const activeRetains = releaseRetains;
+      releaseRetains = [];
+      for (const releaseRetain of activeRetains) releaseRetain();
+      detachProcessCommandSource(process, commands);
+      try {
+        topology.release({ reason: `${name}.effectRunner.release` });
+        released = true;
+      } catch (error) {
+        attachProcessCommandSource(process, commands);
+        releaseRetains = retainRunnerNodes();
+        throw error;
+      }
+    }
+  };
+}
+function processEffectRunnerProjection(topology, runtime, name, factory, pick) {
+  return topology.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const value = pick(fact);
+        if (value !== void 0) ctx.down([["DATA", value]]);
+      }
+    },
+    {
+      name,
+      factory,
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function parseProcessEffectOutcome(raw) {
+  if (!isObjectRecord(raw)) return "processEffectRunner: outcome must be an object";
+  if (typeof raw.kind !== "string") {
+    return "processEffectRunner: outcome kind must be a string";
+  }
+  if (raw.kind !== "result" && raw.kind !== "failure" && raw.kind !== "cancel" && raw.kind !== "timeout") {
+    return "processEffectRunner: outcome kind must be result, failure, cancel, or timeout";
+  }
+  if (typeof raw.effectId !== "string" || raw.effectId.length === 0) {
+    return "processEffectRunner: outcome effectId must be a non-empty string";
+  }
+  if (typeof raw.effectType !== "string" || raw.effectType.length === 0) {
+    return "processEffectRunner: outcome effectType must be a non-empty string";
+  }
+  if ("commandId" in raw && raw.commandId !== void 0) {
+    if (typeof raw.commandId !== "string" || raw.commandId.length === 0) {
+      return "processEffectRunner: outcome commandId must be a non-empty string";
+    }
+  }
+  for (const key of ["processId", "correlationId", "causationId"]) {
+    if (key in raw && raw[key] !== void 0 && typeof raw[key] !== "string") {
+      return `processEffectRunner: outcome ${key} must be a string`;
+    }
+  }
+  if ("metadata" in raw && raw.metadata !== void 0 && !isObjectRecord(raw.metadata)) {
+    return "processEffectRunner: outcome metadata must be a plain object";
+  }
+  if (raw.kind === "result" && !("value" in raw)) {
+    return "processEffectRunner: result outcome must carry value";
+  }
+  if ((raw.kind === "failure" || raw.kind === "timeout") && !("error" in raw)) {
+    return `processEffectRunner: ${raw.kind} outcome must carry error`;
+  }
+  if (raw.kind === "cancel" && "reason" in raw && raw.reason !== void 0 && typeof raw.reason !== "string") {
+    return "processEffectRunner: cancel outcome reason must be a string";
+  }
+  return raw;
+}
+function processEffectOutcomeCommand(outcome) {
+  const commandType = processEffectCommandType(outcome.kind);
+  return {
+    id: outcome.commandId ?? `${outcome.effectId}:${commandType}`,
+    type: commandType,
+    payload: processEffectCommandPayload(outcome),
+    processId: outcome.processId,
+    correlationId: outcome.correlationId,
+    causationId: outcome.causationId,
+    metadata: outcome.metadata
+  };
+}
+function processEffectCommandType(kind) {
+  switch (kind) {
+    case "result":
+      return "effect.result";
+    case "failure":
+      return "effect.failure";
+    case "cancel":
+      return "effect.cancel";
+    case "timeout":
+      return "effect.timeout";
+  }
+}
+function processEffectCommandPayload(outcome) {
+  const base = {
+    effectId: outcome.effectId,
+    effectType: outcome.effectType,
+    processId: outcome.processId,
+    correlationId: outcome.correlationId,
+    causationId: outcome.causationId,
+    metadata: outcome.metadata
+  };
+  switch (outcome.kind) {
+    case "result":
+      return { ...base, kind: "result", value: outcome.value };
+    case "failure":
+      return { ...base, kind: "failure", error: outcome.error };
+    case "cancel":
+      return { ...base, kind: "cancel", reason: outcome.reason };
+    case "timeout":
+      return { ...base, kind: "timeout", error: outcome.error };
+  }
+}
+function attachProcessCommandSource(process, source) {
+  const attached = processCommandSources.get(process);
+  if (attached === void 0) {
+    throw new Error("processEffectRunner: process command source registry missing");
+  }
+  const sources = attached.sources;
+  const previousSources = [...sources];
+  if (!sources.includes(source)) sources.push(source);
+  try {
+    process.command.replaceDeps([...sources], processCommandSourceFn(sources.length));
+  } catch (error) {
+    sources.splice(0, sources.length, ...previousSources);
+    process.command.replaceDeps(
+      [...previousSources],
+      processCommandSourceFn(previousSources.length)
+    );
+    throw error;
+  }
+}
+function detachProcessCommandSource(process, source) {
+  const attached = processCommandSources.get(process);
+  if (attached === void 0) {
+    throw new Error("processEffectRunner: process command source registry missing");
+  }
+  const sources = attached.sources;
+  if (!sources.includes(source)) return;
+  const previousSources = [...sources];
+  const nextSources = sources.filter((candidate) => candidate !== source);
+  sources.splice(0, sources.length, ...nextSources);
+  try {
+    process.command.replaceDeps([...nextSources], processCommandSourceFn(nextSources.length));
+  } catch (error) {
+    sources.splice(0, sources.length, ...previousSources);
+    process.command.replaceDeps(
+      [...previousSources],
+      processCommandSourceFn(previousSources.length)
+    );
+    throw error;
+  }
+}
+function processCommandSourceFn(sourceCount) {
+  return (ctx) => {
+    for (let i = 0; i < sourceCount; i += 1) {
+      for (const command of depBatch(ctx, i) ?? []) {
+        ctx.down([["DATA", command]]);
+      }
+    }
+  };
+}
+function processRuntimeDraft(state) {
+  return {
+    eventSeq: state.eventSeq,
+    effectSeq: state.effectSeq,
+    commandCount: state.commandCount,
+    errorCount: state.errorCount,
+    auditSeq: state.auditSeq,
+    seenEventIds: [...state.seenEventIds],
+    seenEffectIds: [...state.seenEffectIds],
+    state: state.state
+  };
+}
+function reduceProcessCommandFact(raw, state, reduce, now, emit) {
+  const draft = processRuntimeDraft(state);
+  draft.commandCount += 1;
+  const parsed = parseProcessCommand(raw);
+  if (typeof parsed === "string") {
+    emitProcessFailure(draft, emit, raw, void 0, "malformed-command", parsed);
+    return draft;
+  }
+  const command = parsed;
+  let reduction;
+  const reducerState = cloneProcessState(state.state);
+  if (!reducerState.ok) {
+    emitProcessFailure(draft, emit, command, command, "malformed-state", reducerState.message);
+    return draft;
+  }
+  try {
+    reduction = reduce(command, reducerState.value);
+  } catch (error) {
+    rethrowGraphRuntimeInvariant(error);
+    emitProcessFailure(draft, emit, command, command, "reducer-threw", errorMessage(error));
+    return draft;
+  }
+  if (!isObjectRecord(reduction) || !("state" in reduction)) {
+    emitProcessFailure(
+      draft,
+      emit,
+      command,
+      command,
+      "malformed-state",
+      "processBundle: reducer must return { state, events?, effects? }"
+    );
+    return draft;
+  }
+  if (reduction.state === void 0) {
+    emitProcessFailure(
+      draft,
+      emit,
+      command,
+      command,
+      "malformed-state",
+      "processBundle: reducer state must not be undefined"
+    );
+    return draft;
+  }
+  const privateState = cloneProcessState(reduction.state);
+  if (!privateState.ok) {
+    emitProcessFailure(draft, emit, command, command, "malformed-state", privateState.message);
+    return draft;
+  }
+  const visibleState = cloneProcessState(privateState.value);
+  if (!visibleState.ok) {
+    emitProcessFailure(draft, emit, command, command, "malformed-state", visibleState.message);
+    return draft;
+  }
+  const preparedEvents = prepareProcessEvents(command, draft, reduction.events ?? []);
+  if (typeof preparedEvents === "string") {
+    emitProcessFailure(draft, emit, command, command, "malformed-event", preparedEvents);
+    return draft;
+  }
+  const preparedEffects = prepareProcessEffects(command, draft, reduction.effects ?? []);
+  if (typeof preparedEffects === "string") {
+    emitProcessFailure(draft, emit, command, command, "malformed-effect", preparedEffects);
+    return draft;
+  }
+  const timestampMs = readTimestampMs(now);
+  if (typeof timestampMs === "string") {
+    emitProcessFailure(draft, emit, command, command, "clock-threw", timestampMs);
+    return draft;
+  }
+  draft.state = privateState.value;
+  emit({ kind: "state", state: visibleState.value, cursor: processCursorOf(draft) });
+  const events = [];
+  for (const eventDraft of preparedEvents) {
+    draft.eventSeq += 1;
+    draft.seenEventIds.push(eventDraft.id);
+    const event = {
+      id: eventDraft.id,
+      type: eventDraft.type,
+      seq: draft.eventSeq,
+      cursor: draft.eventSeq,
+      commandId: command.id,
+      commandType: command.type,
+      payload: eventDraft.payload,
+      timestampMs,
+      ...eventDraft.processId === void 0 ? {} : { processId: eventDraft.processId },
+      ...eventDraft.correlationId === void 0 ? {} : { correlationId: eventDraft.correlationId },
+      ...eventDraft.causationId === void 0 ? {} : { causationId: eventDraft.causationId },
+      ...eventDraft.metadata === void 0 ? {} : { metadata: eventDraft.metadata }
+    };
+    events.push(event);
+    emit({ kind: "event", event });
+  }
+  const effects = [];
+  for (const effectDraft of preparedEffects) {
+    draft.effectSeq += 1;
+    draft.seenEffectIds.push(effectDraft.id);
+    const effect = {
+      id: effectDraft.id,
+      type: effectDraft.type,
+      seq: draft.effectSeq,
+      cursor: draft.effectSeq,
+      commandId: command.id,
+      commandType: command.type,
+      payload: effectDraft.payload,
+      timestampMs,
+      ...effectDraft.processId === void 0 ? {} : { processId: effectDraft.processId },
+      ...effectDraft.correlationId === void 0 ? {} : { correlationId: effectDraft.correlationId },
+      ...effectDraft.causationId === void 0 ? {} : { causationId: effectDraft.causationId },
+      ...effectDraft.metadata === void 0 ? {} : { metadata: effectDraft.metadata }
+    };
+    effects.push(effect);
+    emit({ kind: "effect-request", effect });
+  }
+  emitProcessStatus(draft, emit, command, "accepted", events.length, effects.length);
+  emitProcessAudit(draft, emit, command, "success", events, effects, void 0, void 0);
+  emit({ kind: "cursor", cursor: processCursorOf(draft) });
+  return draft;
+}
+function processProjection(graph, runtime, name, factory, select) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const selected = select(raw);
+        if (selected !== void 0) ctx.down([["DATA", selected]]);
+      }
+    },
+    { name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false }
+  );
+}
+function parseProcessCommand(value) {
+  if (!isObjectRecord(value)) return "processBundle: command fact must be an object";
+  if (typeof value.id !== "string" || value.id.length === 0) {
+    return "processBundle: command id must be a non-empty string";
+  }
+  if (typeof value.type !== "string" || value.type.length === 0) {
+    return "processBundle: command type must be a non-empty string";
+  }
+  return {
+    id: value.id,
+    type: value.type,
+    payload: value.payload,
+    ...typeof value.processId === "string" ? { processId: value.processId } : {},
+    ...typeof value.correlationId === "string" ? { correlationId: value.correlationId } : {},
+    ...typeof value.causationId === "string" ? { causationId: value.causationId } : {},
+    ...isObjectRecord(value.metadata) ? { metadata: value.metadata } : {}
+  };
+}
+function prepareProcessEvents(command, state, drafts) {
+  if (!Array.isArray(drafts)) return "processBundle: events must be an array";
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i < drafts.length; i += 1) {
+    const draft = drafts[i];
+    if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+      return "processBundle: event draft must have a non-empty type";
+    }
+    const id = typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:event:${state.eventSeq + i + 1}`;
+    if (seen.has(id)) return `processBundle: duplicate event '${id}'`;
+    if (state.seenEventIds.includes(id)) return `processBundle: duplicate event '${id}'`;
+    seen.add(id);
+    out.push({
+      id,
+      type: draft.type,
+      payload: draft.payload,
+      ...typeof draft.processId === "string" ? { processId: draft.processId } : {},
+      ...typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {},
+      ...typeof draft.causationId === "string" ? { causationId: draft.causationId } : {},
+      ...isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}
+    });
+  }
+  return out;
+}
+function prepareProcessEffects(command, state, drafts) {
+  if (!Array.isArray(drafts)) return "processBundle: effects must be an array";
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i < drafts.length; i += 1) {
+    const draft = drafts[i];
+    if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+      return "processBundle: effect draft must have a non-empty type";
+    }
+    const id = typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:effect:${state.effectSeq + i + 1}`;
+    if (seen.has(id)) return `processBundle: duplicate effect '${id}'`;
+    if (state.seenEffectIds.includes(id)) return `processBundle: duplicate effect '${id}'`;
+    seen.add(id);
+    out.push({
+      id,
+      type: draft.type,
+      payload: draft.payload,
+      ...typeof draft.processId === "string" ? { processId: draft.processId } : {},
+      ...typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {},
+      ...typeof draft.causationId === "string" ? { causationId: draft.causationId } : {},
+      ...isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}
+    });
+  }
+  return out;
+}
+function emitProcessFailure(state, emit, raw, command, code, message) {
+  state.errorCount += 1;
+  const cursor = processCursorOf(state);
+  const error = {
+    code,
+    message,
+    command: raw,
+    ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+    cursor
+  };
+  emit({ kind: "error", error });
+  emitProcessStatus(state, emit, command, "rejected", 0, 0, code);
+  emitProcessAudit(state, emit, command, "failure", [], [], code, message);
+  emit({ kind: "cursor", cursor: processCursorOf(state) });
+}
+function emitProcessStatus(state, emit, command, statusState, eventCount, effectCount, errorCode) {
+  emit({
+    kind: "status",
+    status: {
+      state: statusState,
+      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+      eventCount,
+      effectCount,
+      ...errorCode === void 0 ? {} : { errorCode },
+      cursor: processCursorOf(state)
+    }
+  });
+}
+function emitProcessAudit(state, emit, command, outcome, events, effects, errorCode, errorMessage2) {
+  state.auditSeq += 1;
+  emit({
+    kind: "audit",
+    audit: {
+      seq: state.auditSeq,
+      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+      outcome,
+      eventIds: events.map((event) => event.id),
+      eventTypes: events.map((event) => event.type),
+      effectIds: effects.map((effect) => effect.id),
+      effectTypes: effects.map((effect) => effect.type),
+      ...errorCode === void 0 ? {} : { errorCode },
+      ...errorMessage2 === void 0 ? {} : { errorMessage: errorMessage2 },
+      cursor: processCursorOf(state)
+    }
+  });
+}
+function processCursorOf(state) {
+  return {
+    eventSeq: state.eventSeq,
+    effectSeq: state.effectSeq,
+    commandCount: state.commandCount,
+    errorCount: state.errorCount,
+    auditSeq: state.auditSeq
+  };
+}
+
+// src/orchestration/resilience-bundles.ts
+function retryStatusBundle(graph, events, opts = {}) {
+  const policy = opts.policy ?? retryPolicy();
+  const name = opts.name ?? "retry";
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      let next = ctx.state.get() ?? { state: "idle", attempt: 0, maxAttempts: policy.maxAttempts };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "attempt") {
+          next = { state: "running", attempt: event.attempt, maxAttempts: policy.maxAttempts };
+        } else if (event.kind === "retry") {
+          next = {
+            state: "waiting",
+            attempt: event.attempt,
+            maxAttempts: policy.maxAttempts,
+            delayMs: event.delayMs
+          };
+        } else if (event.kind === "success") {
+          next = {
+            state: "succeeded",
+            attempt: event.attempt ?? next.attempt,
+            maxAttempts: policy.maxAttempts
+          };
+        } else if (event.kind === "failure") {
+          const attempt = event.attempt ?? next.attempt;
+          next = {
+            state: shouldRetry(policy, attempt) ? "failed" : "exhausted",
+            attempt,
+            maxAttempts: policy.maxAttempts,
+            delayMs: shouldRetry(policy, attempt) ? nextRetryDelayMs(policy, attempt + 1) : void 0
+          };
+        } else {
+          next = {
+            state: "exhausted",
+            attempt: event.attempt,
+            maxAttempts: policy.maxAttempts
+          };
+        }
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", next]]);
+    },
+    { name: `${name}/status`, factory: "retryStatus" }
+  );
+  const errors = graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if ("error" in event) ctx.down([["DATA", event.error]]);
+      }
+    },
+    { name: `${name}/errors`, factory: "retryErrors" }
+  );
+  return { status, errors };
+}
+function breakerBundle(graph, events, opts) {
+  if (!Number.isInteger(opts.failureThreshold) || opts.failureThreshold <= 0) {
+    throw new RangeError("breakerBundle: failureThreshold must be a positive integer");
+  }
+  const name = opts.name ?? "breaker";
+  const now = opts.now ?? Date.now;
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      let next = ctx.state.get() ?? { state: "closed", failures: 0 };
+      if (next.state === "open" && opts.resetAfterMs !== void 0 && next.openedAtMs !== void 0 && now() - next.openedAtMs >= opts.resetAfterMs) {
+        next = { ...next, state: "half-open" };
+      }
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "success") {
+          next = { state: "closed", failures: 0 };
+        } else if (event.kind === "failure" || event.kind === "exhausted") {
+          const failures = next.failures + 1;
+          next = failures >= opts.failureThreshold ? { state: "open", failures, openedAtMs: now() } : { ...next, failures };
+        }
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", next]]);
+    },
+    { name: `${name}/status`, factory: "breakerStatus" }
+  );
+  const allowed = graph.node(
+    [status],
+    (ctx) => {
+      const statusBatch = depBatch(ctx, 0) ?? [];
+      for (const value of statusBatch) {
+        ctx.down([["DATA", value.state !== "open"]]);
+      }
+    },
+    { name: `${name}/allowed`, factory: "breakerAllowed" }
+  );
+  return { status, allowed };
+}
+function rateLimitBundle(graph, source, opts) {
+  if (!Number.isInteger(opts.max) || opts.max <= 0) {
+    throw new RangeError("rateLimitBundle: max must be a positive integer");
+  }
+  if (!Number.isFinite(opts.windowMs) || opts.windowMs <= 0) {
+    throw new RangeError("rateLimitBundle: windowMs must be positive");
+  }
+  const now = opts.now ?? Date.now;
+  const name = opts.name ?? "rateLimit";
+  const events = graph.node(
+    [source],
+    (ctx) => {
+      const current = now();
+      let state = ctx.state.get() ?? { count: 0, resetAtMs: current + opts.windowMs, allowed: 0, dropped: 0 };
+      if (current >= state.resetAtMs) {
+        state = { ...state, count: 0, resetAtMs: current + opts.windowMs };
+      }
+      for (const value of depBatch(ctx, 0) ?? []) {
+        const allowed2 = state.count < opts.max;
+        state = allowed2 ? { ...state, count: state.count + 1, allowed: state.allowed + 1 } : { ...state, dropped: state.dropped + 1 };
+        const status2 = {
+          allowed: state.allowed,
+          dropped: state.dropped,
+          remaining: Math.max(0, opts.max - state.count),
+          resetAtMs: state.resetAtMs
+        };
+        ctx.down([
+          [
+            "DATA",
+            allowed2 ? { kind: "allowed", value, status: status2 } : { kind: "dropped", value, status: status2 }
+          ]
+        ]);
+      }
+      ctx.state.set(state);
+    },
+    { name: `${name}/events`, factory: "rateLimitEvents" }
+  );
+  const allowed = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind === "allowed") ctx.down([["DATA", typed.value]]);
+      }
+    },
+    { name: `${name}/allowed`, factory: "rateLimitAllowed" }
+  );
+  const dropped = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind === "dropped") ctx.down([["DATA", typed.value]]);
+      }
+    },
+    { name: `${name}/dropped`, factory: "rateLimitDropped" }
+  );
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", event.status]]);
+      }
+    },
+    { name: `${name}/status`, factory: "rateLimitStatus" }
+  );
+  return { allowed, dropped, status };
+}
+function timeoutBundle(graph, source, ms, opts = {}) {
+  const name = opts.name ?? "timeout";
+  const node = timeout(source, ms);
+  const status = graph.node(
+    [node],
+    (ctx) => {
+      const terminal = ctx.terminal[0];
+      if (terminal === true) ctx.down([["DATA", "completed"]]);
+      else if (terminal !== false && terminal !== void 0) ctx.down([["DATA", "errored"]]);
+      else if ((depBatch(ctx, 0) ?? []).length > 0) ctx.down([["DATA", "running"]]);
+    },
+    { name: `${name}/status`, factory: "timeoutStatus" }
+  );
+  const errors = graph.node(
+    [node],
+    (ctx) => {
+      const terminal = ctx.terminal[0];
+      if (terminal !== true && terminal !== false && terminal !== void 0) {
+        ctx.down([["DATA", terminal]]);
+      }
+    },
+    { name: `${name}/errors`, factory: "timeoutErrors" }
+  );
+  return { node, status, errors };
+}
+function constantBackoff(delayMs) {
+  return { kind: "constant", delayMs };
+}
+
+// src/orchestration/scheduled-readiness.ts
+function scheduledReadinessProjector(graph, opts) {
+  const name = opts.name ?? "scheduledReadiness";
+  const clockDeps = opts.clocks ?? [];
+  const runtime = graph.node(
+    [...opts.schedules, ...clockDeps],
+    (ctx) => {
+      const state = ctx.state.get() ?? initialState();
+      forEachDepBatch(ctx, 0, opts.schedules.length, (raw) => {
+        const retained = sanitizeSchedule(raw);
+        if (retained.ok) {
+          const existing = state.schedules.get(retained.schedule.scheduleId);
+          if (existing === void 0) {
+            state.schedules.set(retained.schedule.scheduleId, retained.schedule);
+          } else if (scheduleIdentity(existing) !== scheduleIdentity(retained.schedule)) {
+            const issue = dataIssue(
+              "scheduled-readiness-schedule-conflict",
+              "Scheduled readiness scheduleId was replayed with conflicting schedule material; the first valid schedule was retained.",
+              {
+                subjectId: retained.schedule.scheduleId,
+                refs: scheduleSourceRefs(retained.schedule, state.clockSourceRefs),
+                details: {
+                  existingReadyAtMs: readinessMs(existing),
+                  incomingReadyAtMs: readinessMs(retained.schedule),
+                  existingDeadlineMs: existing.deadlineMs,
+                  incomingDeadlineMs: retained.schedule.deadlineMs
+                }
+              }
+            );
+            emitIssue3(ctx, state, issue);
+            emitStatus3(ctx, state, {
+              kind: "scheduled-readiness-status",
+              statusId: `${retained.schedule.scheduleId}:scheduled-readiness-status:issue`,
+              scheduleId: retained.schedule.scheduleId,
+              state: "issue",
+              subjectRefs: scheduleSubjectRefs(existing),
+              readyAtMs: readinessMs(existing),
+              ...existing.deadlineMs === void 0 ? {} : { deadlineMs: existing.deadlineMs },
+              nowMs: state.nowMs,
+              sourceRefs: scheduleSourceRefs(existing, state.clockSourceRefs),
+              issueCodes: [issue.code]
+            });
+          }
+        } else {
+          emitIssue3(ctx, state, retained.issue);
+          emitStatus3(ctx, state, {
+            kind: "scheduled-readiness-status",
+            statusId: `${retained.scheduleId}:scheduled-readiness-status:issue`,
+            scheduleId: retained.scheduleId,
+            state: "issue",
+            sourceRefs: retained.sourceRefs,
+            issueCodes: [retained.issue.code]
+          });
+        }
+      });
+      forEachDepBatch(ctx, opts.schedules.length, clockDeps.length, (raw) => {
+        const clock = sanitizeClock(raw);
+        if (clock.ok) {
+          if (state.nowMs !== void 0 && clock.clock.nowMs < state.nowMs) {
+            emitIssue3(
+              ctx,
+              state,
+              dataIssue(
+                "scheduled-readiness-clock-rollback",
+                "Scheduled readiness clock facts must be monotonic; rollback was ignored.",
+                {
+                  subjectId: clock.clock.clockId,
+                  refs: clock.clock.sourceRefs,
+                  severity: "warning",
+                  details: { nowMs: clock.clock.nowMs, previousNowMs: state.nowMs }
+                }
+              )
+            );
+            return;
+          }
+          state.nowMs = clock.clock.nowMs;
+          state.clockSourceRefs = clock.clock.sourceRefs;
+        } else {
+          emitIssue3(ctx, state, clock.issue);
+        }
+      });
+      evaluateSchedules(ctx, state);
+      ctx.down([["DATA", { kind: "views", views: buildViews(state) }]]);
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "scheduledReadinessProjector", partial: true }
+  );
+  return {
+    pending: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/pending`,
+      "scheduledReadinessPending",
+      (fact) => fact.kind === "pending" ? fact.pending : void 0
+    ),
+    ready: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/ready`,
+      "scheduledReadinessReady",
+      (fact) => fact.kind === "ready" ? fact.ready : void 0
+    ),
+    overdue: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/overdue`,
+      "scheduledReadinessOverdue",
+      (fact) => fact.kind === "overdue" ? fact.overdue : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "scheduledReadinessStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "scheduledReadinessIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "scheduledReadinessAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    ),
+    views: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/views`,
+      "scheduledReadinessViews",
+      (fact) => fact.kind === "views" ? fact.views : void 0
+    )
+  };
+}
+function initialState() {
+  return {
+    schedules: /* @__PURE__ */ new Map(),
+    pendingById: /* @__PURE__ */ new Map(),
+    readyById: /* @__PURE__ */ new Map(),
+    overdueById: /* @__PURE__ */ new Map(),
+    statusById: /* @__PURE__ */ new Map(),
+    emittedKeys: /* @__PURE__ */ new Set(),
+    issueKeys: /* @__PURE__ */ new Set(),
+    auditSeq: 0,
+    nowMs: void 0,
+    clockSourceRefs: void 0
+  };
+}
+function evaluateSchedules(ctx, state) {
+  for (const schedule of state.schedules.values()) {
+    const readyAtMs = readinessMs(schedule);
+    const subjectRefs = scheduleSubjectRefs(schedule);
+    const sourceRefs = scheduleSourceRefs(schedule, state.clockSourceRefs);
+    const baseMetadata = sanitizeScheduledReadinessMetadata({
+      ...schedule.reason === void 0 ? {} : { reason: schedule.reason },
+      ...schedule.metadata ?? {}
+    });
+    if (state.nowMs === void 0 || state.nowMs < readyAtMs) {
+      const pending = Object.freeze({
+        kind: "scheduled-readiness-pending",
+        scheduleId: schedule.scheduleId,
+        subjectRefs,
+        readyAtMs,
+        ...schedule.deadlineMs === void 0 ? {} : { deadlineMs: schedule.deadlineMs },
+        ...state.nowMs === void 0 ? {} : { nowMs: state.nowMs },
+        sourceRefs,
+        ...baseMetadata === void 0 ? {} : { metadata: baseMetadata }
+      });
+      emitPending(ctx, state, pending);
+      emitStatus3(
+        ctx,
+        state,
+        statusFor(schedule, "pending", {
+          subjectRefs,
+          readyAtMs,
+          sourceRefs,
+          nowMs: state.nowMs
+        })
+      );
+      continue;
+    }
+    const ready = Object.freeze({
+      kind: "scheduled-readiness-ready",
+      scheduleId: schedule.scheduleId,
+      subjectRefs,
+      readyAtMs,
+      ...schedule.deadlineMs === void 0 ? {} : { deadlineMs: schedule.deadlineMs },
+      nowMs: state.nowMs,
+      sourceRefs,
+      ...baseMetadata === void 0 ? {} : { metadata: baseMetadata }
+    });
+    emitReady(ctx, state, ready);
+    emitStatus3(
+      ctx,
+      state,
+      statusFor(schedule, "ready", {
+        subjectRefs,
+        readyAtMs,
+        sourceRefs,
+        nowMs: state.nowMs
+      })
+    );
+    if (schedule.deadlineMs !== void 0 && state.nowMs > schedule.deadlineMs) {
+      const overdue = Object.freeze({
+        kind: "scheduled-readiness-overdue",
+        scheduleId: schedule.scheduleId,
+        subjectRefs,
+        readyAtMs,
+        deadlineMs: schedule.deadlineMs,
+        nowMs: state.nowMs,
+        sourceRefs,
+        ...baseMetadata === void 0 ? {} : { metadata: baseMetadata }
+      });
+      emitOverdue(ctx, state, overdue);
+      emitStatus3(
+        ctx,
+        state,
+        statusFor(schedule, "overdue", {
+          subjectRefs,
+          readyAtMs,
+          sourceRefs,
+          nowMs: state.nowMs
+        })
+      );
+    }
+  }
+}
+function sanitizeSchedule(raw) {
+  if (!isPlainRecord(raw)) {
+    return {
+      ok: false,
+      scheduleId: "unknown-scheduled-readiness",
+      sourceRefs: [],
+      issue: dataIssue(
+        "scheduled-readiness-malformed-schedule",
+        "Scheduled readiness requires a stable scheduleId, subjectRefs array, and finite readyAtMs.",
+        { subjectId: "unknown-scheduled-readiness", refs: [] }
+      )
+    };
+  }
+  const scheduleId = typeof raw.scheduleId === "string" && raw.scheduleId.length > 0 ? raw.scheduleId : "unknown-scheduled-readiness";
+  const refs = sourceRefArray(raw.sourceRefs);
+  const hasDeadlineMs = Object.hasOwn(raw, "deadlineMs");
+  const readyAtMs = finiteNumberOrUndefined(raw.readyAtMs);
+  const deadlineMs = finiteNumberOrUndefined(raw.deadlineMs);
+  if (raw.kind !== "scheduled-readiness-requested" || typeof raw.scheduleId !== "string" || raw.scheduleId.length === 0 || readyAtMs === void 0 || hasDeadlineMs && deadlineMs === void 0 || raw.subjectRef !== void 0 || !Array.isArray(raw.subjectRefs) || raw.notBeforeMs !== void 0 || raw.policyRefs !== void 0 && !Array.isArray(raw.policyRefs) || raw.sourceRefs !== void 0 && !Array.isArray(raw.sourceRefs)) {
+    return {
+      ok: false,
+      scheduleId,
+      sourceRefs: refs,
+      issue: dataIssue(
+        "scheduled-readiness-malformed-schedule",
+        "Scheduled readiness requires a stable scheduleId, subjectRefs array, and finite readyAtMs.",
+        { subjectId: scheduleId, refs }
+      )
+    };
+  }
+  const subjectRefs = sourceRefArray(raw.subjectRefs);
+  const policyRefs = sourceRefArray(raw.policyRefs);
+  const metadata = sanitizeScheduledReadinessMetadata(
+    isPlainRecord(raw.metadata) ? raw.metadata : void 0
+  );
+  return {
+    ok: true,
+    schedule: Object.freeze({
+      kind: "scheduled-readiness-requested",
+      scheduleId: raw.scheduleId,
+      subjectRefs,
+      readyAtMs,
+      ...deadlineMs === void 0 ? {} : { deadlineMs },
+      ...typeof raw.reason === "string" ? { reason: raw.reason } : {},
+      ...policyRefs.length === 0 ? {} : { policyRefs },
+      sourceRefs: refs,
+      ...metadata === void 0 ? {} : { metadata }
+    })
+  };
+}
+function sanitizeClock(raw) {
+  if (!isPlainRecord(raw)) {
+    return {
+      ok: false,
+      issue: dataIssue(
+        "scheduled-readiness-malformed-clock",
+        "Scheduled readiness clock facts require a stable clockId and finite nowMs.",
+        { subjectId: "unknown-scheduled-readiness-clock", refs: [] }
+      )
+    };
+  }
+  const refs = sourceRefArray(raw.sourceRefs);
+  const nowMs = finiteNumberOrUndefined(raw.nowMs);
+  if (raw.kind !== "scheduled-readiness-clock" || typeof raw.clockId !== "string" || raw.clockId.length === 0 || nowMs === void 0 || raw.sourceRefs !== void 0 && !Array.isArray(raw.sourceRefs)) {
+    const clockSubjectId = typeof raw.clockId === "string" && raw.clockId.length > 0 ? raw.clockId : "unknown-scheduled-readiness-clock";
+    return {
+      ok: false,
+      issue: dataIssue(
+        "scheduled-readiness-malformed-clock",
+        "Scheduled readiness clock facts require a stable clockId and finite nowMs.",
+        { subjectId: clockSubjectId, refs }
+      )
+    };
+  }
+  const metadata = sanitizeScheduledReadinessMetadata(
+    isPlainRecord(raw.metadata) ? raw.metadata : void 0
+  );
+  return {
+    ok: true,
+    clock: Object.freeze({
+      kind: "scheduled-readiness-clock",
+      clockId: raw.clockId,
+      nowMs,
+      sourceRefs: refs,
+      ...metadata === void 0 ? {} : { metadata }
+    })
+  };
+}
+function emitPending(ctx, state, pending) {
+  state.pendingById.set(pending.scheduleId, pending);
+  const key = `pending:${pending.scheduleId}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  ctx.down([["DATA", { kind: "pending", pending }]]);
+}
+function emitReady(ctx, state, ready) {
+  const key = `ready:${ready.scheduleId}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  state.readyById.set(ready.scheduleId, ready);
+  state.pendingById.delete(ready.scheduleId);
+  emitAudit2(ctx, state, "scheduled-readiness-ready", {
+    subjectId: ready.scheduleId,
+    sourceRefs: ready.sourceRefs,
+    metadata: { nowMs: ready.nowMs, readyAtMs: ready.readyAtMs }
+  });
+  ctx.down([["DATA", { kind: "ready", ready }]]);
+}
+function emitOverdue(ctx, state, overdue) {
+  const key = `overdue:${overdue.scheduleId}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  state.overdueById.set(overdue.scheduleId, overdue);
+  emitAudit2(ctx, state, "scheduled-readiness-overdue", {
+    subjectId: overdue.scheduleId,
+    sourceRefs: overdue.sourceRefs,
+    metadata: {
+      nowMs: overdue.nowMs,
+      readyAtMs: overdue.readyAtMs,
+      deadlineMs: overdue.deadlineMs
+    }
+  });
+  ctx.down([["DATA", { kind: "overdue", overdue }]]);
+}
+function emitStatus3(ctx, state, status) {
+  state.statusById.set(status.scheduleId, status);
+  const key = `status:${stableJsonStringify(status)}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  ctx.down([["DATA", { kind: "status", status }]]);
+}
+function emitIssue3(ctx, state, issue) {
+  const key = `${issue.code}:${issue.subjectId ?? ""}:${JSON.stringify(issue.details ?? {})}`;
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  ctx.down([["DATA", { kind: "issue", issue }]]);
+}
+function emitAudit2(ctx, state, kind, opts = {}) {
+  state.auditSeq += 1;
+  const metadata = sanitizeGraphVisibleRecord(opts.metadata);
+  ctx.down([
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: Object.freeze({
+          id: `scheduled-readiness-audit-${state.auditSeq}`,
+          kind,
+          ...opts.subjectId === void 0 ? {} : { subjectId: opts.subjectId },
+          ...opts.sourceRefs === void 0 ? {} : { sourceRefs: canonicalPublicSourceRefs(opts.sourceRefs) },
+          ...metadata === void 0 ? {} : { metadata }
+        })
+      }
+    ]
+  ]);
+}
+function statusFor(schedule, state, opts) {
+  const metadata = sanitizeGraphVisibleRecord({
+    ...schedule.reason === void 0 ? {} : { reason: schedule.reason }
+  });
+  return Object.freeze({
+    kind: "scheduled-readiness-status",
+    statusId: `${schedule.scheduleId}:scheduled-readiness-status:${state}`,
+    scheduleId: schedule.scheduleId,
+    state,
+    subjectRefs: opts.subjectRefs,
+    readyAtMs: opts.readyAtMs,
+    ...schedule.deadlineMs === void 0 ? {} : { deadlineMs: schedule.deadlineMs },
+    ...opts.nowMs === void 0 ? {} : { nowMs: opts.nowMs },
+    sourceRefs: opts.sourceRefs,
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function readinessMs(schedule) {
+  return schedule.readyAtMs;
+}
+function scheduleIdentity(schedule) {
+  return stableJsonStringify({
+    scheduleId: schedule.scheduleId,
+    subjectRefs: schedule.subjectRefs,
+    readyAtMs: schedule.readyAtMs,
+    deadlineMs: schedule.deadlineMs,
+    reason: schedule.reason,
+    policyRefs: schedule.policyRefs,
+    sourceRefs: schedule.sourceRefs,
+    metadata: schedule.metadata
+  });
+}
+function scheduleSubjectRefs(schedule) {
+  return canonicalPublicSourceRefs(uniqueSourceRefs(schedule.subjectRefs));
+}
+function scheduleSourceRefs(schedule, clockSourceRefs) {
+  return canonicalPublicSourceRefs(
+    uniqueSourceRefs([
+      ref("scheduled-readiness", schedule.scheduleId),
+      ...schedule.sourceRefs ?? [],
+      ...schedule.policyRefs ?? [],
+      ...clockSourceRefs ?? []
+    ])
+  );
+}
+function sanitizeScheduledReadinessMetadata(value) {
+  const filtered = omitRuntimeMetadata(value);
+  return sanitizeGraphVisibleRecord(filtered);
+}
+function omitRuntimeMetadata(value) {
+  if (!isPlainRecord(value)) return void 0;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (isRuntimeMetadataKey(key)) continue;
+    const filteredChild = Array.isArray(child) ? child.map((entry) => isPlainRecord(entry) ? omitRuntimeMetadata(entry) : entry) : isPlainRecord(child) ? omitRuntimeMetadata(child) : child;
+    if (filteredChild !== void 0) out[key] = filteredChild;
+  }
+  return Object.keys(out).length === 0 ? void 0 : out;
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function finiteNumberOrUndefined(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function sourceRefArray(value) {
+  if (!Array.isArray(value)) return [];
+  return canonicalPublicSourceRefs(
+    value.flatMap((entry) => {
+      const sourceRef = sourceRefOrUndefined2(entry);
+      return sourceRef === void 0 ? [] : [sourceRef];
+    })
+  );
+}
+function sourceRefOrUndefined2(value) {
+  if (!isPlainRecord(value)) return void 0;
+  if (typeof value.kind !== "string" || value.kind.length === 0) return void 0;
+  if (typeof value.id !== "string" || value.id.length === 0) return void 0;
+  return isPlainRecord(value.metadata) ? { kind: value.kind, id: value.id, metadata: value.metadata } : { kind: value.kind, id: value.id };
+}
+function isRuntimeMetadataKey(key) {
+  return /^(apiKey|api_key|secret|client|transport|subprocess|sdk|oauth|credential|credentials|accessToken|access_token|refreshToken|refresh_token|idToken|id_token|token|password|passphrase|authorization|authHeader|auth_header|bearer|privateKey|private_key|sessionCookie|session_cookie|cookie|stdout|stderr|stack|stackTrace|stack_trace|providerRaw|provider_raw|rawResponse|raw_response|rawResponseBody|raw_response_body|diff|patch|fileContents|file_contents|binary|media)$/i.test(
+    key
+  );
+}
+function buildViews(state) {
+  return Object.freeze({
+    schedulesById: new Map(state.schedules),
+    pendingById: new Map(state.pendingById),
+    readyById: new Map(state.readyById),
+    overdueById: new Map(state.overdueById),
+    statusById: new Map(state.statusById),
+    ...state.nowMs === void 0 ? {} : { nowMs: state.nowMs }
+  });
+}
+
+export {
+  effectRunCompletionProjector,
+  structuredAgentDecisionInterpreter,
+  fakeExecutorResult,
+  fakeExecutorFailure,
+  fakeExecutorBlocked,
+  fakeExecutorTimeout,
+  fakeExecutorCanceled,
+  agentRequestProposalFromDecision,
+  admitAgentRequestProposal,
+  issueAgentRequest,
+  agentRequestLedgerViews,
+  requestSatisfactionProjector,
+  toolProviderRunAdmissionProjector,
+  toolProviderRunRetryProjector,
+  effectRun,
+  processBundle,
+  processEffectRunner,
+  retryStatusBundle,
+  breakerBundle,
+  rateLimitBundle,
+  timeoutBundle,
+  constantBackoff,
+  scheduledReadinessProjector
+};
+//# sourceMappingURL=chunk-MCOFHMUU.js.map