@graphrefly/ts 0.0.1 → 0.0.3

package/dist/chunk-PC3BTTBE.js

@@ -1,3217 +0,0 @@
-import {
-  depBatch
-} from "./chunk-WQIA3GFB.js";
-
-// src/orchestration/agent-runtime.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
-  };
-}
-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) {
-  return {
-    kind: "admitted",
-    proposalId: proposal.proposalId,
-    requestId: opts.requestId,
-    operationId: opts.operationId,
-    effectRunId: proposal.effectRunId,
-    agentRunId: proposal.agentRunId,
-    admittedAtMs: opts.admittedAtMs,
-    reason: opts.reason,
-    sourceRefs: opts.sourceRefs,
-    metadata: opts.metadata
-  };
-}
-function issueAgentRequest(proposal, admission, opts = {}) {
-  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: proposal.input,
-    payload: proposal.payload,
-    issuedAtMs: opts.issuedAtMs,
-    sourceRefs: opts.sourceRefs ?? admission.sourceRefs,
-    metadata: proposal.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", fact.issue]]);
-        if (fact.kind === "status") {
-          for (const issue of fact.issues ?? []) ctx.down([["DATA", 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 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 localBuiltinToolProviderCatalog(opts = {}) {
-  const providerId = opts.providerId ?? "local-builtin";
-  const executorId = opts.executorId ?? `${providerId}:tool-executor`;
-  const profileId = opts.profileId ?? `${providerId}:tool-profile`;
-  const tools = opts.tools ?? [
-    { toolName: "document/read-doc", operation: "read" },
-    { toolName: "file.read", operation: "read" },
-    { toolName: "file.edit/apply-patch", operation: "edit" },
-    { toolName: "bash.run", operation: "run" },
-    { toolName: "url.fetch", operation: "fetch" },
-    { toolName: "date.now", operation: "read" },
-    { toolName: "weather.fetch", operation: "fetch" },
-    { toolName: "calculator/eval", operation: "eval" }
-  ];
-  const toolEntries = tools.map(
-    (tool) => Object.freeze({
-      kind: "tool-catalog-entry",
-      providerId,
-      inputKind: "tool-call",
-      profileId,
-      executorId,
-      ...tool
-    })
-  );
-  return Object.freeze({
-    kind: "tool-provider-catalog",
-    providerId,
-    providerKind: "local-builtin",
-    status: "ready",
-    profiles: Object.freeze([
-      Object.freeze({
-        profileId,
-        executorId,
-        kind: "tool",
-        acceptedInputKinds: Object.freeze(["tool-call"]),
-        acceptedResultKinds: Object.freeze(
-          Array.from(new Set(toolEntries.flatMap((tool) => tool.resultKinds ?? [])))
-        ),
-        capabilities: Object.freeze({
-          toolNames: Object.freeze(toolEntries.map((tool) => tool.toolName)),
-          ...opts.capabilities ?? {}
-        }),
-        limits: opts.limits,
-        metadata: opts.metadata
-      })
-    ]),
-    tools: Object.freeze(toolEntries),
-    metadata: opts.metadata
-  });
-}
-function executorOutcomeViewProjector(graph, opts) {
-  const name = opts.name ?? "executorOutcomeViews";
-  const policy = {
-    audience: opts.policy?.audience ?? "agent-observation",
-    maxSummaryChars: opts.policy?.maxSummaryChars ?? 512,
-    includeIssues: opts.policy?.includeIssues ?? true,
-    includeUsage: opts.policy?.includeUsage ?? false,
-    includeMetadata: opts.policy?.includeMetadata ?? false
-  };
-  const runtime = graph.node(
-    [opts.outcomes],
-    (ctx) => {
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const outcome = raw;
-        const projection = executorOutcomeViewProjectionFromOutcome(outcome, policy);
-        ctx.down([
-          ["DATA", { kind: "view", view: projection.view }],
-          [
-            "DATA",
-            {
-              kind: "audit",
-              audit: {
-                id: `${outcome.outcomeId}:outcome-view:${policy.audience}`,
-                kind: "executor-outcome-view-projected",
-                subjectId: outcome.requestId,
-                sourceRefs: [ref("executor-outcome", outcome.outcomeId)],
-                metadata: { audience: policy.audience, status: outcome.kind }
-              }
-            }
-          ]
-        ]);
-        for (const issue of projection.issues) {
-          ctx.down([["DATA", { kind: "issue", issue }]]);
-        }
-      }
-    },
-    { name: `${name}/runtime`, factory: "executorOutcomeViewProjector" }
-  );
-  return {
-    views: projectRuntimeFact(
-      graph,
-      runtime,
-      `${name}/views`,
-      "executorOutcomeViews",
-      (fact) => fact.kind === "view" ? fact.view : void 0
-    ),
-    issues: projectRuntimeFact(
-      graph,
-      runtime,
-      `${name}/issues`,
-      "executorOutcomeViewIssues",
-      (fact) => fact.kind === "issue" ? fact.issue : void 0
-    ),
-    audit: projectRuntimeFact(
-      graph,
-      runtime,
-      `${name}/audit`,
-      "executorOutcomeViewAudit",
-      (fact) => fact.kind === "audit" ? fact.audit : void 0
-    )
-  };
-}
-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 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 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 };
-}
-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 executorOutcomeViewProjectionFromOutcome(outcome, policy) {
-  const sourceRefs = uniqueSourceRefs([
-    ref("executor-outcome", outcome.outcomeId),
-    ...outcome.evidenceRefs ?? []
-  ]);
-  const summary = projectOutcomeSummary(outcome, policy.maxSummaryChars);
-  const issues = Object.freeze([
-    ...outcomeIssues(outcome),
-    ...summary.truncated ? [outcomeSummaryTruncationIssue(outcome, summary, policy)] : []
-  ]);
-  const view = Object.freeze({
-    kind: "executor-outcome-view",
-    viewId: `${outcome.outcomeId}:${policy.audience}`,
-    audience: policy.audience,
-    outcomeId: outcome.outcomeId,
-    requestId: outcome.requestId,
-    operationId: outcome.operationId,
-    routeId: outcome.routeId,
-    executorId: outcome.executorId,
-    profileId: outcome.profileId,
-    status: outcome.kind,
-    summary: summary.summary,
-    summaryTruncated: summary.truncated,
-    summaryChars: summary.originalChars,
-    summaryLimitChars: summary.limitChars,
-    errorKind: outcomeErrorKind(outcome),
-    retryable: outcomeRetryable(outcome),
-    nextActions: outcomeNextActions(outcome),
-    sourceRefs,
-    materialRefs: outcomeMaterialRefs(outcome),
-    issues: policy.includeIssues && issues.length > 0 ? issues : void 0,
-    usage: policy.includeUsage ? outcome.usage : void 0,
-    metadata: policy.includeMetadata ? outcome.metadata : void 0
-  });
-  return Object.freeze({ view, issues });
-}
-function projectOutcomeSummary(outcome, maxChars) {
-  const summary = outcomeSummary(outcome);
-  const limitChars = Math.max(0, maxChars);
-  if (summary.length <= limitChars) {
-    return Object.freeze({
-      summary,
-      truncated: false,
-      originalChars: summary.length,
-      limitChars
-    });
-  }
-  const bounded = limitChars <= 1 ? summary.slice(0, limitChars) : limitChars <= 3 ? summary.slice(0, limitChars) : `${summary.slice(0, limitChars - 3)}...`;
-  return Object.freeze({
-    summary: bounded,
-    truncated: true,
-    originalChars: summary.length,
-    limitChars
-  });
-}
-function outcomeSummaryTruncationIssue(outcome, summary, policy) {
-  return dataIssue(
-    "executor-outcome-view-summary-truncated",
-    "ExecutorOutcome view summary was truncated; inspect material refs or the source outcome for full detail",
-    {
-      subjectId: outcome.requestId,
-      refs: [ref("executor-outcome", outcome.outcomeId)],
-      severity: "warning",
-      details: {
-        audience: policy.audience,
-        outcomeId: outcome.outcomeId,
-        originalChars: summary.originalChars,
-        limitChars: summary.limitChars
-      }
-    }
-  );
-}
-function outcomeSummary(outcome) {
-  if (outcome.kind === "result") {
-    if (outcome.result.summary !== void 0 && outcome.result.summary.length > 0)
-      return outcome.result.summary;
-    return `Executor result '${outcome.result.kind}' is available via source refs`;
-  }
-  if (outcome.kind === "failure") return outcome.error.message;
-  if (outcome.kind === "blocked") {
-    const needKinds = outcome.needs.map((need) => need.kind).join(", ");
-    return needKinds.length > 0 ? `Executor blocked: ${needKinds}` : "Executor blocked";
-  }
-  if (outcome.kind === "timeout") {
-    return outcome.timeoutMs === void 0 ? "Executor timed out" : `Executor timed out after ${outcome.timeoutMs}ms`;
-  }
-  return outcome.reason ?? "Executor canceled";
-}
-function outcomeErrorKind(outcome) {
-  if (outcome.kind === "failure") return outcome.error.code;
-  if (outcome.kind === "timeout") return "timeout";
-  if (outcome.kind === "blocked") return outcome.needs[0]?.kind ?? "blocked";
-  if (outcome.kind === "canceled") return "canceled";
-  return void 0;
-}
-function outcomeRetryable(outcome) {
-  if (outcome.kind === "failure" || outcome.kind === "timeout") return outcome.retryable;
-  return void 0;
-}
-function outcomeIssues(outcome) {
-  if (outcome.kind === "failure") return Object.freeze([outcome.error, ...outcome.issues ?? []]);
-  return outcome.issues ?? [];
-}
-function outcomeNextActions(outcome) {
-  if (outcome.kind === "blocked") return Object.freeze(outcome.needs.map((need) => need.kind));
-  if ((outcome.kind === "failure" || outcome.kind === "timeout") && outcome.retryable === true) {
-    return Object.freeze(["retry-or-route"]);
-  }
-  return void 0;
-}
-function outcomeMaterialRefs(outcome) {
-  const refs = outcome.kind === "result" ? [...outcome.result.refs ?? []] : outcome.kind === "blocked" ? outcome.needs.flatMap((need) => [...need.refs ?? []]) : [];
-  return refs.length === 0 ? void 0 : uniqueSourceRefs(refs);
-}
-function uniqueSourceRefs(sourceRefs) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const sourceRef of sourceRefs) {
-    const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push(sourceRef);
-  }
-  return Object.freeze(unique);
-}
-function emitStatus(ctx, state, request, status, sourceRefs, issues) {
-  const fact = {
-    kind: "status",
-    requestId: request.requestId,
-    operationId: request.operationId,
-    effectRunId: request.effectRunId,
-    status,
-    sourceRefs,
-    issues
-  };
-  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,
-          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);
-}
-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;
-}
-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
-  };
-}
-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") {
-    state.requestsById.set(fact.requestId, fact);
-    const requestIds = state.requestsByEffectRun.get(fact.effectRunId) ?? [];
-    if (!requestIds.includes(fact.requestId)) requestIds.push(fact.requestId);
-    state.requestsByEffectRun.set(fact.effectRunId, requestIds);
-    state.statusByRequest.set(fact.requestId, {
-      kind: "status",
-      requestId: fact.requestId,
-      operationId: fact.operationId,
-      effectRunId: fact.effectRunId,
-      status: "issued",
-      sourceRefs: [ref("agent-request", fact.requestId)]
-    });
-  } else if (fact.kind === "status") {
-    state.statusByRequest.set(fact.requestId, fact);
-    if (fact.issues !== void 0) state.issues.push(...fact.issues);
-  } else if (fact.kind === "rejected") {
-    state.issues.push(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 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])
-  };
-}
-function projectRuntimeFact(graph, runtime, name, factory, pick) {
-  return graph.node(
-    [runtime],
-    (ctx) => {
-      for (const fact of depBatch(ctx, 0) ?? []) {
-        const typed = fact;
-        const value = pick(typed);
-        if (value !== void 0) ctx.down([["DATA", value]]);
-      }
-    },
-    { name, factory }
-  );
-}
-function forEachDepBatch(ctx, start, count, fn) {
-  for (let i = 0; i < count; i += 1) {
-    for (const value of depBatch(ctx, start + i) ?? []) fn(value);
-  }
-}
-function dataIssue(code, message, opts = {}) {
-  return {
-    kind: "issue",
-    code,
-    message,
-    severity: opts.severity ?? "error",
-    subjectId: opts.subjectId,
-    refs: opts.refs?.map((r) => `${r.kind}:${r.id}`),
-    details: opts.details
-  };
-}
-function ref(kind, id) {
-  return { kind, id };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/orchestration/work-item-runtime.ts
-function workItemEffectRunProjector(graph, opts) {
-  const name = opts.name ?? "workItemEffectRuns";
-  const runtime = graph.node(
-    [opts.workItems, opts.effectRequests],
-    (ctx) => {
-      const state = ctx.state.get() ?? emptyWorkItemEffectRunState();
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const workItem = raw;
-        state.workItems.set(workItem.workItemId, workItem);
-      }
-      for (const raw of depBatch(ctx, 1) ?? []) {
-        const request = raw;
-        state.requests.set(request.requestId, request);
-        const requestRefs = workItemEffectRequestRefs(request);
-        state.statusSeq += 1;
-        state.auditSeq += 1;
-        ctx.down([
-          [
-            "DATA",
-            {
-              kind: "status",
-              status: {
-                kind: "work-item-status",
-                statusId: `${request.workItemId}:effect-request-pending:${state.statusSeq}`,
-                workItemId: request.workItemId,
-                effectRunId: request.effectRunId,
-                requestId: request.requestId,
-                state: "effect-request-pending",
-                sourceRefs: requestRefs,
-                metadata: { effectKind: request.effectKind }
-              }
-            }
-          ],
-          [
-            "DATA",
-            {
-              kind: "audit",
-              audit: {
-                id: `${request.workItemId}:effect-request-pending:${state.auditSeq}`,
-                kind: "work-item-effect-request-pending",
-                subjectId: request.workItemId,
-                sourceRefs: requestRefs,
-                metadata: { effectRunId: request.effectRunId, effectKind: request.effectKind }
-              }
-            }
-          ]
-        ]);
-        const workItem = state.workItems.get(request.workItemId);
-        if (workItem === void 0) {
-          emitWorkItemEffectRunIssue(
-            ctx,
-            state,
-            `unknown-work-item:${request.requestId}`,
-            "unknown-work-item-effect-request",
-            `WorkItemEffectRequested '${request.requestId}' references unknown WorkItem '${request.workItemId}'`,
-            request.workItemId,
-            requestRefs
-          );
-          continue;
-        }
-        const existingEffectRunId = state.effectRunsByRequest.get(request.requestId);
-        if (existingEffectRunId !== void 0) {
-          emitWorkItemEffectRunIssue(
-            ctx,
-            state,
-            `duplicate-effect-request:${request.requestId}`,
-            "duplicate-work-item-effect-request",
-            `WorkItemEffectRequested '${request.requestId}' was already mapped to EffectRun '${existingEffectRunId}'`,
-            request.workItemId,
-            requestRefs
-          );
-          continue;
-        }
-        if (state.seededEffectRunIds.has(request.effectRunId)) {
-          emitWorkItemEffectRunIssue(
-            ctx,
-            state,
-            `duplicate-effect-run:${request.effectRunId}:${request.requestId}`,
-            "duplicate-work-item-effect-run",
-            `EffectRun '${request.effectRunId}' was already seeded from another WorkItemEffectRequested fact`,
-            request.workItemId,
-            requestRefs
-          );
-          continue;
-        }
-        state.effectRunsByRequest.set(request.requestId, request.effectRunId);
-        state.seededEffectRunIds.add(request.effectRunId);
-        const run = effectRun({
-          effectRunId: request.effectRunId,
-          agentRunId: request.agentRunId,
-          subjectRefs: [ref2("work-item", request.workItemId)],
-          goal: request.goal,
-          sourceRefs: [
-            ref2("work-item", request.workItemId),
-            ref2("work-item-effect-request", request.requestId),
-            ...request.sourceRefs ?? []
-          ],
-          policyRefs: request.policyRefs,
-          limits: request.limits,
-          createdBy: request.createdBy,
-          createdAtMs: request.createdAtMs,
-          metadata: {
-            ...request.metadata ?? {},
-            effectKind: request.effectKind,
-            idempotencyKey: request.idempotencyKey
-          }
-        });
-        state.statusSeq += 1;
-        state.auditSeq += 1;
-        ctx.down([
-          ["DATA", { kind: "effect-run", effectRun: run }],
-          [
-            "DATA",
-            {
-              kind: "status",
-              status: {
-                kind: "work-item-status",
-                statusId: `${request.workItemId}:effect-run-seeded:${state.statusSeq}`,
-                workItemId: request.workItemId,
-                effectRunId: request.effectRunId,
-                requestId: request.requestId,
-                state: "effect-run-seeded",
-                sourceRefs: run.sourceRefs
-              }
-            }
-          ],
-          [
-            "DATA",
-            {
-              kind: "audit",
-              audit: {
-                id: `${request.workItemId}:effect-run-seeded:${state.auditSeq}`,
-                kind: "work-item-effect-run-seeded",
-                subjectId: request.workItemId,
-                sourceRefs: run.sourceRefs,
-                metadata: { effectRunId: request.effectRunId, effectKind: request.effectKind }
-              }
-            }
-          ]
-        ]);
-      }
-      ctx.state.set(state);
-    },
-    { name: `${name}/runtime`, factory: "workItemEffectRunProjector" }
-  );
-  return {
-    effectRuns: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/effectRuns`,
-      "workItemEffectRuns",
-      (fact) => fact.kind === "effect-run" ? fact.effectRun : void 0
-    ),
-    status: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/status`,
-      "workItemEffectRunStatus",
-      (fact) => fact.kind === "status" ? fact.status : void 0
-    ),
-    issues: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/issues`,
-      "workItemEffectRunIssues",
-      (fact) => fact.kind === "issue" ? fact.issue : void 0
-    ),
-    audit: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/audit`,
-      "workItemEffectRunAudit",
-      (fact) => fact.kind === "audit" ? fact.audit : void 0
-    ),
-    views: graph.node(
-      [opts.effectRequests, runtime],
-      (ctx) => {
-        const state = ctx.state.get() ?? {
-          pendingEffectRequests: /* @__PURE__ */ new Map(),
-          settledRequestIds: /* @__PURE__ */ new Set(),
-          issues: [],
-          audit: []
-        };
-        for (const raw of depBatch(ctx, 0) ?? []) {
-          const request = raw;
-          if (!state.settledRequestIds.has(request.requestId))
-            state.pendingEffectRequests.set(request.requestId, request);
-        }
-        for (const raw of depBatch(ctx, 1) ?? []) {
-          const fact = raw;
-          if (fact.kind === "effect-run") {
-            for (const request of state.pendingEffectRequests.values()) {
-              if (request.effectRunId === fact.effectRun.effectRunId) {
-                state.pendingEffectRequests.delete(request.requestId);
-                state.settledRequestIds.add(request.requestId);
-                break;
-              }
-            }
-          } else if (fact.kind === "issue") {
-            deletePendingWorkItemEffectRequest(state, fact.issue.refs);
-            state.issues.push(fact.issue);
-          } else if (fact.kind === "audit") state.audit.push(fact.audit);
-        }
-        ctx.state.set(state);
-        ctx.down([["DATA", freezeWorkItemEffectRequestViews(state)]]);
-      },
-      { name: `${name}/views`, factory: "workItemEffectRequestViews" }
-    )
-  };
-}
-function workItemEffectResultMapper(graph, opts) {
-  const name = opts.name ?? "workItemEffectResultMapper";
-  const policyDeps = opts.mappingPolicies ?? [];
-  const deps = [
-    opts.workItems,
-    opts.effectRuns,
-    opts.effectRunResults,
-    ...opts.effectRequests === void 0 ? [] : [opts.effectRequests],
-    ...policyDeps
-  ];
-  const effectRequestIndex = 3;
-  const policyStart = effectRequestIndex + (opts.effectRequests === void 0 ? 0 : 1);
-  const now = opts.now ?? Date.now;
-  const runtime = graph.node(
-    deps,
-    (ctx) => {
-      const state = ctx.state.get() ?? emptyWorkItemEvidenceState();
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const workItem = raw;
-        state.workItems.set(workItem.workItemId, workItem);
-      }
-      for (const raw of depBatch(ctx, 1) ?? []) {
-        const run = raw;
-        state.effectRuns.set(run.effectRunId, run);
-        const workItemRef = singleWorkItemRef([
-          ...run.subjectRefs ?? [],
-          ...run.sourceRefs ?? []
-        ]);
-        if (workItemRef !== void 0)
-          state.effectRunWorkItems.set(run.effectRunId, workItemRef.id);
-      }
-      if (opts.effectRequests !== void 0) {
-        for (const raw of depBatch(ctx, effectRequestIndex) ?? []) {
-          const request = raw;
-          state.pendingEffectRequests.set(request.requestId, request);
-          const existing = state.requestsByEffectRun.get(request.effectRunId);
-          if (existing !== void 0 && existing.requestId !== request.requestId) {
-            const ambiguous = state.ambiguousRequestsByEffectRun.get(request.effectRunId) ?? [
-              existing
-            ];
-            if (!ambiguous.some((item) => item.requestId === request.requestId))
-              ambiguous.push(request);
-            state.ambiguousRequestsByEffectRun.set(request.effectRunId, ambiguous);
-            emitWorkItemEvidenceIssue(
-              ctx,
-              state,
-              `duplicate-effect-request:${request.effectRunId}:${request.requestId}`,
-              "duplicate-work-item-effect-request",
-              `EffectRun '${request.effectRunId}' has multiple WorkItemEffectRequested facts`,
-              request.workItemId,
-              uniqueSourceRefs2(ambiguous.flatMap(workItemEffectRequestRefs))
-            );
-          } else {
-            state.requestsByEffectRun.set(request.effectRunId, request);
-          }
-        }
-      }
-      forEachPolicyDepBatch(ctx, policyStart, policyDeps.length, (raw) => {
-        const policy = raw;
-        state.policies.set(policy.policyId, policy);
-      });
-      for (const raw of depBatch(ctx, 2) ?? []) {
-        const result = raw;
-        mapEffectRunResultToWorkItemEvidence(ctx, state, result, now());
-      }
-      ctx.state.set(state);
-    },
-    { name: `${name}/runtime`, factory: "workItemEffectResultMapper" }
-  );
-  return {
-    evidence: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/evidence`,
-      "workItemEvidenceRecorded",
-      (fact) => fact.kind === "evidence" ? fact.evidence : void 0
-    ),
-    status: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/status`,
-      "workItemEvidenceStatus",
-      (fact) => fact.kind === "status" ? fact.status : void 0
-    ),
-    issues: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/issues`,
-      "workItemEvidenceIssues",
-      (fact) => fact.kind === "issue" ? fact.issue : void 0
-    ),
-    audit: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/audit`,
-      "workItemEvidenceAudit",
-      (fact) => fact.kind === "audit" ? fact.audit : void 0
-    ),
-    views: graph.node(
-      [...opts.effectRequests === void 0 ? [] : [opts.effectRequests], runtime],
-      (ctx) => {
-        const state = ctx.state.get() ?? {
-          evidenceByWorkItem: /* @__PURE__ */ new Map(),
-          latestEvidenceByEffectRun: /* @__PURE__ */ new Map(),
-          pendingEffectRequests: /* @__PURE__ */ new Map(),
-          settledEffectRunIds: /* @__PURE__ */ new Set(),
-          settledRequestIds: /* @__PURE__ */ new Set(),
-          issues: [],
-          audit: []
-        };
-        if (opts.effectRequests !== void 0) {
-          for (const raw of depBatch(ctx, 0) ?? []) {
-            const request = raw;
-            if (!state.settledRequestIds.has(request.requestId) && !state.settledEffectRunIds.has(request.effectRunId))
-              state.pendingEffectRequests.set(request.requestId, request);
-          }
-        }
-        const runtimeIndex = opts.effectRequests === void 0 ? 0 : 1;
-        for (const raw of depBatch(ctx, runtimeIndex) ?? []) {
-          const fact = raw;
-          if (fact.kind === "evidence") {
-            const evidence = fact.evidence;
-            const byWorkItem = state.evidenceByWorkItem.get(evidence.workItemId) ?? [];
-            byWorkItem.push(evidence);
-            state.evidenceByWorkItem.set(evidence.workItemId, byWorkItem);
-            state.latestEvidenceByEffectRun.set(evidence.effectRunId, evidence);
-            for (const request of state.pendingEffectRequests.values()) {
-              if (request.effectRunId === evidence.effectRunId) {
-                state.pendingEffectRequests.delete(request.requestId);
-                state.settledRequestIds.add(request.requestId);
-              }
-            }
-            state.settledEffectRunIds.add(evidence.effectRunId);
-          } else if (fact.kind === "issue") {
-            deletePendingWorkItemEffectRequest(state, fact.issue.refs);
-            state.issues.push(fact.issue);
-          } else if (fact.kind === "audit") state.audit.push(fact.audit);
-        }
-        ctx.state.set(state);
-        ctx.down([["DATA", freezeWorkItemEvidenceViews(state)]]);
-      },
-      { name: `${name}/views`, factory: "workItemEvidenceViews" }
-    )
-  };
-}
-function workItemDomainActionProposalProjector(graph, opts) {
-  const name = opts.name ?? "workItemDomainActionProposals";
-  const now = opts.now ?? Date.now;
-  const policyStart = 3;
-  const runtime = graph.node(
-    [opts.workItems, opts.evidence, opts.effectRunResults, ...opts.mappingPolicies],
-    (ctx) => {
-      const state = ctx.state.get() ?? emptyWorkItemDomainActionProposalState();
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const workItem = raw;
-        state.workItems.set(workItem.workItemId, workItem);
-      }
-      for (const raw of depBatch(ctx, 1) ?? []) {
-        const evidence = raw;
-        if (state.evidence.has(evidence.evidenceId)) {
-          emitWorkItemActionProposalIssue(
-            ctx,
-            state,
-            `duplicate-action-proposal-evidence:${evidence.evidenceId}`,
-            "duplicate-work-item-action-proposal-evidence",
-            `WorkItemEvidenceRecorded '${evidence.evidenceId}' was already seen by the action proposal projector`,
-            evidence.workItemId,
-            workItemEvidenceOnlyRefs(evidence)
-          );
-          continue;
-        }
-        state.evidence.set(evidence.evidenceId, evidence);
-      }
-      for (const raw of depBatch(ctx, 2) ?? []) {
-        const result = raw;
-        if (state.results.has(result.resultId)) {
-          emitWorkItemActionProposalIssue(
-            ctx,
-            state,
-            `duplicate-action-proposal-result:${result.resultId}`,
-            "duplicate-work-item-action-proposal-result",
-            `EffectRunResult '${result.resultId}' was already seen by the action proposal projector`,
-            workItemIdForEffectRunResult(state, result),
-            workItemResultRefs(result)
-          );
-          continue;
-        }
-        state.results.set(result.resultId, result);
-      }
-      forEachPolicyDepBatch(ctx, policyStart, opts.mappingPolicies.length, (raw) => {
-        const policy = raw;
-        state.policies.set(policy.policyId, policy);
-      });
-      evaluateWorkItemDomainActionProposals(ctx, state, now());
-      ctx.state.set(state);
-    },
-    { name: `${name}/runtime`, factory: "workItemDomainActionProposalProjector", partial: true }
-  );
-  return {
-    proposals: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/proposals`,
-      "workItemDomainActionProposals",
-      (fact) => fact.kind === "proposal" ? fact.proposal : void 0
-    ),
-    status: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/status`,
-      "workItemDomainActionProposalStatus",
-      (fact) => fact.kind === "status" ? fact.status : void 0
-    ),
-    issues: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/issues`,
-      "workItemDomainActionProposalIssues",
-      (fact) => fact.kind === "issue" ? fact.issue : void 0
-    ),
-    audit: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/audit`,
-      "workItemDomainActionProposalAudit",
-      (fact) => fact.kind === "audit" ? fact.audit : void 0
-    ),
-    views: graph.node(
-      [runtime],
-      (ctx) => {
-        const state = ctx.state.get() ?? {
-          proposalsByWorkItem: /* @__PURE__ */ new Map(),
-          proposalsByEvidence: /* @__PURE__ */ new Map(),
-          issues: [],
-          audit: []
-        };
-        for (const raw of depBatch(ctx, 0) ?? []) {
-          const fact = raw;
-          if (fact.kind === "proposal") {
-            const proposal = fact.proposal;
-            const byWorkItem = state.proposalsByWorkItem.get(proposal.workItemId) ?? [];
-            byWorkItem.push(proposal);
-            state.proposalsByWorkItem.set(proposal.workItemId, byWorkItem);
-            const byEvidence = state.proposalsByEvidence.get(proposal.evidenceId) ?? [];
-            byEvidence.push(proposal);
-            state.proposalsByEvidence.set(proposal.evidenceId, byEvidence);
-          } else if (fact.kind === "issue") state.issues.push(fact.issue);
-          else if (fact.kind === "audit") state.audit.push(fact.audit);
-        }
-        ctx.state.set(state);
-        ctx.down([["DATA", freezeWorkItemDomainActionProposalViews(state)]]);
-      },
-      { name: `${name}/views`, factory: "workItemDomainActionProposalViews" }
-    )
-  };
-}
-function workItemDomainActionAdmissionProjector(graph, opts) {
-  const name = opts.name ?? "workItemDomainActionAdmissions";
-  const policyDeps = opts.admissionPolicies ?? [];
-  const policyStart = 2;
-  const now = opts.now ?? Date.now;
-  const runtime = graph.node(
-    [opts.proposals, opts.decisions, ...policyDeps],
-    (ctx) => {
-      const state = ctx.state.get() ?? emptyWorkItemDomainActionAdmissionState();
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const proposal = raw;
-        if (state.proposals.has(proposal.proposalId)) {
-          emitWorkItemAdmissionIssue(
-            ctx,
-            state,
-            `duplicate-admission-proposal:${proposal.proposalId}`,
-            "duplicate-work-item-domain-action-proposal",
-            `WorkItemDomainActionProposal '${proposal.proposalId}' was already seen by the admission projector`,
-            proposal.workItemId,
-            workItemAdmissionProposalRefs(proposal)
-          );
-          continue;
-        }
-        state.proposals.set(proposal.proposalId, proposal);
-      }
-      forEachPolicyDepBatch(ctx, policyStart, policyDeps.length, (raw) => {
-        const policy = raw;
-        state.policies.set(policy.policyId, policy);
-      });
-      for (const raw of depBatch(ctx, 1) ?? []) {
-        const decision = raw;
-        if (state.decisions.has(decision.decisionId)) {
-          emitWorkItemAdmissionIssue(
-            ctx,
-            state,
-            `duplicate-admission-decision:${decision.decisionId}`,
-            "duplicate-work-item-domain-action-admission-decision",
-            `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' was already seen by the admission projector`,
-            decision.proposalId,
-            workItemAdmissionDecisionRefs(decision)
-          );
-          continue;
-        }
-        state.decisions.set(decision.decisionId, decision);
-      }
-      evaluateWorkItemDomainActionAdmissions(ctx, state, now());
-      ctx.state.set(state);
-    },
-    { name: `${name}/runtime`, factory: "workItemDomainActionAdmissionProjector", partial: true }
-  );
-  return {
-    admissions: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/admissions`,
-      "workItemDomainActionAdmissions",
-      (fact) => fact.kind === "admission" ? fact.admission : void 0
-    ),
-    status: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/status`,
-      "workItemDomainActionAdmissionStatus",
-      (fact) => fact.kind === "status" ? fact.status : void 0
-    ),
-    issues: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/issues`,
-      "workItemDomainActionAdmissionIssues",
-      (fact) => fact.kind === "issue" ? fact.issue : void 0
-    ),
-    audit: projectRuntimeFact2(
-      graph,
-      runtime,
-      `${name}/audit`,
-      "workItemDomainActionAdmissionAudit",
-      (fact) => fact.kind === "audit" ? fact.audit : void 0
-    ),
-    views: graph.node(
-      [runtime],
-      (ctx) => {
-        const state = ctx.state.get() ?? {
-          admissionsByProposal: /* @__PURE__ */ new Map(),
-          admissionsByWorkItem: /* @__PURE__ */ new Map(),
-          issues: [],
-          audit: []
-        };
-        for (const raw of depBatch(ctx, 0) ?? []) {
-          const fact = raw;
-          if (fact.kind === "admission") {
-            const admission = fact.admission;
-            state.admissionsByProposal.set(admission.proposalId, admission);
-            const byWorkItem = state.admissionsByWorkItem.get(admission.workItemId) ?? [];
-            byWorkItem.push(admission);
-            state.admissionsByWorkItem.set(admission.workItemId, byWorkItem);
-          } else if (fact.kind === "issue") state.issues.push(fact.issue);
-          else if (fact.kind === "audit") state.audit.push(fact.audit);
-        }
-        ctx.state.set(state);
-        ctx.down([["DATA", freezeWorkItemDomainActionAdmissionViews(state)]]);
-      },
-      { name: `${name}/views`, factory: "workItemDomainActionAdmissionViews" }
-    )
-  };
-}
-function mapEffectRunResultToWorkItemEvidence(ctx, state, result, recordedAtMs) {
-  const run = state.effectRuns.get(result.effectRunId);
-  if (run === void 0) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `unknown-effect-run:${result.resultId}`,
-      "unknown-effect-run-result",
-      `EffectRunResult '${result.resultId}' references unknown EffectRun '${result.effectRunId}'`,
-      result.effectRunId,
-      result.sourceRefs
-    );
-    return;
-  }
-  const staleEffectRunRef = (result.sourceRefs ?? []).find(
-    (sourceRef) => sourceRef.kind === "effect-run" && sourceRef.id !== result.effectRunId
-  );
-  if (staleEffectRunRef !== void 0) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `stale-effect-run-ref:${result.resultId}`,
-      "stale-effect-run-source-ref",
-      `EffectRunResult '${result.resultId}' carries a stale EffectRun source ref '${staleEffectRunRef.id}'`,
-      result.effectRunId,
-      result.sourceRefs
-    );
-    return;
-  }
-  const runWorkItemRef = singleWorkItemRef([...run.subjectRefs ?? [], ...run.sourceRefs ?? []]);
-  const resultWorkItemRefs = distinctWorkItemRefs([
-    ...result.subjectRefs ?? [],
-    ...result.sourceRefs ?? []
-  ]);
-  if (resultWorkItemRefs.length > 1) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `ambiguous-work-item-ref:${result.resultId}`,
-      "stale-work-item-source-ref",
-      `EffectRunResult '${result.resultId}' carries multiple WorkItem refs`,
-      resultWorkItemRefs[0]?.id,
-      workItemResultRefs(result)
-    );
-    return;
-  }
-  const resultWorkItemRef = resultWorkItemRefs[0];
-  if (runWorkItemRef !== void 0 && resultWorkItemRef !== void 0 && runWorkItemRef.id !== resultWorkItemRef.id) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `stale-work-item-ref:${result.resultId}`,
-      "stale-work-item-source-ref",
-      `EffectRunResult '${result.resultId}' WorkItem ref '${resultWorkItemRef.id}' does not match EffectRun '${result.effectRunId}'`,
-      resultWorkItemRef.id,
-      workItemResultRefs(result)
-    );
-    return;
-  }
-  const workItemId = resultWorkItemRef?.id ?? runWorkItemRef?.id ?? state.effectRunWorkItems.get(result.effectRunId);
-  if (workItemId === void 0) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `missing-work-item-ref:${result.resultId}`,
-      "missing-work-item-source-ref",
-      `EffectRunResult '${result.resultId}' cannot be mapped without a WorkItem source ref`,
-      result.effectRunId,
-      workItemResultRefs(result)
-    );
-    return;
-  }
-  if (!state.workItems.has(workItemId)) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `unknown-work-item:${result.resultId}`,
-      "unknown-work-item-evidence-target",
-      `EffectRunResult '${result.resultId}' references unseeded WorkItem '${workItemId}'`,
-      workItemId,
-      workItemResultRefs(result)
-    );
-    return;
-  }
-  const request = state.requestsByEffectRun.get(result.effectRunId);
-  const ambiguousRequests = state.ambiguousRequestsByEffectRun.get(result.effectRunId);
-  if (ambiguousRequests !== void 0) {
-    const refs2 = uniqueSourceRefs2([
-      ...workItemResultRefs(result),
-      ...ambiguousRequests.flatMap(workItemEffectRequestRefs)
-    ]);
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `ambiguous-effect-request:${result.effectRunId}:${result.resultId}`,
-      "duplicate-work-item-effect-request",
-      `EffectRun '${result.effectRunId}' has ambiguous WorkItemEffectRequested facts`,
-      workItemId,
-      refs2
-    );
-    clearPendingWorkItemEffectRequestsForRun(state, result.effectRunId);
-    return;
-  }
-  const policyIssue = workItemMappingPolicyIssue(state, request, run);
-  if (policyIssue !== void 0) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `${policyIssue.code}:${result.resultId}`,
-      policyIssue.code,
-      policyIssue.message,
-      workItemId,
-      workItemMappingPolicyIssueRefs(result, run, request)
-    );
-    clearPendingWorkItemEffectRequestsForRun(state, result.effectRunId);
-    return;
-  }
-  if (state.latestEvidenceByEffectRun.has(result.effectRunId)) {
-    emitWorkItemEvidenceIssue(
-      ctx,
-      state,
-      `duplicate-evidence:${result.effectRunId}:${result.resultId}`,
-      "duplicate-work-item-evidence",
-      `EffectRun '${result.effectRunId}' already recorded WorkItem evidence`,
-      workItemId,
-      workItemResultRefs(result)
-    );
-    return;
-  }
-  const evidence = workItemEvidenceFromResult(result, run, workItemId, request, recordedAtMs);
-  const byWorkItem = state.evidenceByWorkItem.get(workItemId) ?? [];
-  byWorkItem.push(evidence);
-  state.evidenceByWorkItem.set(workItemId, byWorkItem);
-  state.latestEvidenceByEffectRun.set(result.effectRunId, evidence);
-  clearPendingWorkItemEffectRequestsForRun(state, result.effectRunId);
-  state.statusSeq += 1;
-  state.auditSeq += 1;
-  const refs = evidence.sourceRefs;
-  const status = {
-    kind: "work-item-status",
-    statusId: `${workItemId}:evidence-recorded:${state.statusSeq}`,
-    workItemId,
-    state: "evidence-recorded",
-    sourceRefs: refs,
-    effectRunId: result.effectRunId,
-    evidenceId: evidence.evidenceId,
-    issues: result.issues,
-    metadata: { resultStatus: result.status }
-  };
-  const audit = {
-    id: `${workItemId}:evidence-recorded:${state.auditSeq}`,
-    kind: "work-item-evidence-recorded",
-    subjectId: workItemId,
-    sourceRefs: refs,
-    metadata: {
-      effectRunId: result.effectRunId,
-      effectRunResultId: result.resultId,
-      resultStatus: result.status
-    }
-  };
-  state.audit.push(audit);
-  ctx.down([
-    ["DATA", { kind: "evidence", evidence }],
-    ["DATA", { kind: "status", status }],
-    ["DATA", { kind: "audit", audit }]
-  ]);
-}
-function evaluateWorkItemDomainActionProposals(ctx, state, proposedAtMs) {
-  for (const evidence of state.evidence.values()) {
-    const result = state.results.get(evidence.effectRunResultId);
-    if (result === void 0) {
-      emitWorkItemActionProposalIssue(
-        ctx,
-        state,
-        `missing-action-proposal-result:${evidence.evidenceId}:${evidence.effectRunResultId}`,
-        "missing-work-item-action-proposal-result",
-        `WorkItemEvidenceRecorded '${evidence.evidenceId}' references missing EffectRunResult '${evidence.effectRunResultId}'`,
-        evidence.workItemId,
-        workItemEvidenceOnlyRefs(evidence)
-      );
-      continue;
-    }
-    if (result.effectRunId !== evidence.effectRunId || result.status !== evidence.status) {
-      emitWorkItemActionProposalIssue(
-        ctx,
-        state,
-        `stale-action-proposal-result:${evidence.evidenceId}:${result.resultId}`,
-        "stale-work-item-action-proposal-result",
-        `WorkItemEvidenceRecorded '${evidence.evidenceId}' does not match EffectRunResult '${result.resultId}'`,
-        evidence.workItemId,
-        workItemActionProposalRefs(evidence, result)
-      );
-      continue;
-    }
-    if (!state.workItems.has(evidence.workItemId)) {
-      emitWorkItemActionProposalIssue(
-        ctx,
-        state,
-        `unknown-action-proposal-work-item:${evidence.evidenceId}`,
-        "unknown-work-item-action-proposal-target",
-        `WorkItemEvidenceRecorded '${evidence.evidenceId}' references unseeded WorkItem '${evidence.workItemId}'`,
-        evidence.workItemId,
-        workItemActionProposalRefs(evidence, result)
-      );
-      continue;
-    }
-    const policyIds = referencedWorkItemMappingPolicyIds(evidence);
-    for (const policyId of policyIds) {
-      const policy = state.policies.get(policyId);
-      if (policy === void 0) {
-        emitWorkItemActionProposalIssue(
-          ctx,
-          state,
-          `missing-action-proposal-policy:${evidence.evidenceId}:${policyId}`,
-          "missing-work-item-action-proposal-policy",
-          `WorkItemEffectMappingPolicy '${policyId}' was referenced for WorkItem action proposals but not present`,
-          evidence.workItemId,
-          workItemActionProposalRefs(evidence, result)
-        );
-        continue;
-      }
-      const effectKind = effectKindFromMetadata(evidence.metadata) ?? effectKindFromMetadata(result.metadata);
-      if (!policyAppliesToRequest(policy, effectKind)) {
-        emitWorkItemActionProposalIssue(
-          ctx,
-          state,
-          `action-proposal-policy-mismatch:${evidence.evidenceId}:${policy.policyId}`,
-          "work-item-action-proposal-policy-mismatch",
-          `WorkItemEffectMappingPolicy '${policy.policyId}' does not apply to effectKind '${effectKind ?? "unknown"}'`,
-          evidence.workItemId,
-          workItemActionProposalRefs(evidence, result, policy)
-        );
-        continue;
-      }
-      for (const [index, spec] of (policy.actionProposals ?? []).entries()) {
-        emitWorkItemDomainActionProposal(
-          ctx,
-          state,
-          evidence,
-          result,
-          policy,
-          spec,
-          index,
-          proposedAtMs
-        );
-      }
-    }
-  }
-}
-function emitWorkItemDomainActionProposal(ctx, state, evidence, result, policy, spec, index, proposedAtMs) {
-  const key = `${evidence.evidenceId}:${policy.policyId}:${index}:${spec.actionKind}`;
-  if (state.proposedKeys.has(key)) return;
-  if (spec.behavior !== void 0 && spec.behavior !== "propose") {
-    emitWorkItemActionProposalIssue(
-      ctx,
-      state,
-      `unsupported-action-proposal-behavior:${key}`,
-      "unsupported-work-item-action-proposal-behavior",
-      `WorkItemEffectMappingPolicy '${policy.policyId}' uses unsupported action proposal behavior '${spec.behavior}'`,
-      evidence.workItemId,
-      workItemActionProposalRefs(evidence, result, policy)
-    );
-    return;
-  }
-  if (spec.actionKind.length === 0) {
-    emitWorkItemActionProposalIssue(
-      ctx,
-      state,
-      `malformed-action-proposal:${key}`,
-      "malformed-work-item-action-proposal",
-      `WorkItemEffectMappingPolicy '${policy.policyId}' has an empty actionKind`,
-      evidence.workItemId,
-      workItemActionProposalRefs(evidence, result, policy)
-    );
-    return;
-  }
-  if (spec.statuses !== void 0 && !spec.statuses.includes(evidence.status)) return;
-  const outputKind = evidence.output?.kind;
-  if (spec.outputKinds !== void 0 && (outputKind === void 0 || !spec.outputKinds.includes(outputKind)))
-    return;
-  state.proposedKeys.add(key);
-  state.statusSeq += 1;
-  state.auditSeq += 1;
-  const proposal = {
-    kind: "work-item-domain-action-proposal",
-    proposalId: `${evidence.workItemId}:${evidence.effectRunId}:${evidence.effectRunResultId}:${policy.policyId}:${index}:${spec.actionKind}`,
-    workItemId: evidence.workItemId,
-    actionKind: spec.actionKind,
-    effectRunId: evidence.effectRunId,
-    effectRunResultId: evidence.effectRunResultId,
-    evidenceId: evidence.evidenceId,
-    policyId: policy.policyId,
-    payload: workItemActionProposalPayload(spec, evidence, result),
-    reason: spec.reason ?? evidence.reason ?? resultReason(result),
-    sourceRefs: workItemActionProposalRefs(evidence, result, policy),
-    proposedAtMs,
-    metadata: {
-      ...policy.metadata ?? {},
-      ...spec.metadata ?? {},
-      resultStatus: evidence.status
-    }
-  };
-  const status = {
-    kind: "work-item-status",
-    statusId: `${evidence.workItemId}:domain-action-proposed:${state.statusSeq}`,
-    workItemId: evidence.workItemId,
-    state: "domain-action-proposed",
-    sourceRefs: proposal.sourceRefs,
-    effectRunId: evidence.effectRunId,
-    evidenceId: evidence.evidenceId,
-    proposalId: proposal.proposalId,
-    metadata: { actionKind: spec.actionKind, policyId: policy.policyId }
-  };
-  const audit = {
-    id: `${evidence.workItemId}:domain-action-proposed:${state.auditSeq}`,
-    kind: "work-item-domain-action-proposed",
-    subjectId: evidence.workItemId,
-    sourceRefs: proposal.sourceRefs,
-    metadata: {
-      actionKind: spec.actionKind,
-      effectRunId: evidence.effectRunId,
-      effectRunResultId: evidence.effectRunResultId,
-      evidenceId: evidence.evidenceId,
-      policyId: policy.policyId,
-      proposalId: proposal.proposalId
-    }
-  };
-  ctx.down([
-    ["DATA", { kind: "proposal", proposal }],
-    ["DATA", { kind: "status", status }],
-    ["DATA", { kind: "audit", audit }]
-  ]);
-}
-function evaluateWorkItemDomainActionAdmissions(ctx, state, admittedAtMs) {
-  let emitted = true;
-  let passes = 0;
-  while (emitted && passes <= state.decisions.size) {
-    emitted = false;
-    passes += 1;
-    for (const decision of state.decisions.values()) {
-      if (state.terminalDecisionIds.has(decision.decisionId)) continue;
-      emitted = evaluateWorkItemDomainActionAdmission(ctx, state, decision, admittedAtMs) || emitted;
-    }
-  }
-}
-function evaluateWorkItemDomainActionAdmission(ctx, state, decision, admittedAtMs) {
-  const proposal = state.proposals.get(decision.proposalId);
-  const proposalRefs = workItemAdmissionDecisionRefs(decision, proposal);
-  const subjectId = proposal?.workItemId ?? decision.proposalId;
-  if (proposal === void 0) {
-    emitWorkItemAdmissionIssue(
-      ctx,
-      state,
-      `missing-admission-proposal:${decision.decisionId}:${decision.proposalId}`,
-      "missing-work-item-domain-action-admission-proposal",
-      `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' references missing proposal '${decision.proposalId}'`,
-      subjectId,
-      proposalRefs
-    );
-    return false;
-  }
-  const staleProposalRef = (decision.sourceRefs ?? []).find(
-    (sourceRef) => sourceRef.kind === "work-item-domain-action-proposal" && sourceRef.id !== decision.proposalId && sourceRef.id !== decision.targetProposalId
-  );
-  if (staleProposalRef !== void 0) {
-    emitWorkItemAdmissionIssue(
-      ctx,
-      state,
-      `stale-admission-proposal-ref:${decision.decisionId}:${staleProposalRef.id}`,
-      "stale-work-item-domain-action-admission-proposal-ref",
-      `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' carries stale proposal ref '${staleProposalRef.id}'`,
-      proposal.workItemId,
-      proposalRefs
-    );
-    state.terminalDecisionIds.add(decision.decisionId);
-    return false;
-  }
-  const policy = admissionPolicyForDecision(state, decision);
-  if (typeof policy === "string") {
-    emitWorkItemAdmissionIssue(
-      ctx,
-      state,
-      `${policy}:${decision.decisionId}:${decision.policyId ?? "missing"}`,
-      policy,
-      admissionPolicyIssueMessage(policy, decision),
-      proposal.workItemId,
-      proposalRefs
-    );
-    if (policy === "stale-work-item-domain-action-admission-policy-ref")
-      state.terminalDecisionIds.add(decision.decisionId);
-    return false;
-  }
-  if (policy !== void 0) {
-    const policyIssue = validateWorkItemAdmissionPolicy(policy, decision, proposal);
-    if (policyIssue !== void 0) {
-      emitWorkItemAdmissionIssue(
-        ctx,
-        state,
-        `${policyIssue.code}:${decision.decisionId}:${policy.policyId}`,
-        policyIssue.code,
-        policyIssue.message,
-        proposal.workItemId,
-        workItemAdmissionDecisionRefs(decision, proposal, policy)
-      );
-      return false;
-    }
-  }
-  const mergeIssue = validateWorkItemAdmissionMergeTarget(state, decision);
-  if (mergeIssue !== void 0) {
-    emitWorkItemAdmissionIssue(
-      ctx,
-      state,
-      `${mergeIssue.code}:${decision.decisionId}:${decision.targetProposalId ?? ""}:${decision.targetAdmissionId ?? ""}`,
-      mergeIssue.code,
-      mergeIssue.message,
-      proposal.workItemId,
-      proposalRefs
-    );
-    if (mergeIssue.code !== "unknown-work-item-domain-action-admission-merge-target")
-      state.terminalDecisionIds.add(decision.decisionId);
-    return false;
-  }
-  if (state.admissionsById.has(decision.admissionId)) {
-    emitWorkItemAdmissionIssue(
-      ctx,
-      state,
-      `duplicate-admission-id:${decision.admissionId}`,
-      "duplicate-work-item-domain-action-admission",
-      `WorkItemDomainActionAdmission '${decision.admissionId}' was already emitted`,
-      proposal.workItemId,
-      proposalRefs
-    );
-    state.terminalDecisionIds.add(decision.decisionId);
-    return false;
-  }
-  if (state.admissionsByProposal.has(decision.proposalId)) {
-    emitWorkItemAdmissionIssue(
-      ctx,
-      state,
-      `duplicate-admission-proposal-decision:${decision.proposalId}:${decision.decisionId}`,
-      "duplicate-work-item-domain-action-admission-proposal",
-      `WorkItemDomainActionProposal '${decision.proposalId}' already has an admission decision`,
-      proposal.workItemId,
-      proposalRefs
-    );
-    state.terminalDecisionIds.add(decision.decisionId);
-    return false;
-  }
-  const admissionState = admissionStateForOutcome(decision.outcome);
-  if (admissionState === void 0) {
-    emitWorkItemAdmissionIssue(
-      ctx,
-      state,
-      `unsupported-admission-outcome:${decision.decisionId}:${String(decision.outcome)}`,
-      "unsupported-work-item-domain-action-admission-outcome",
-      `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' uses unsupported outcome '${String(decision.outcome)}'`,
-      proposal.workItemId,
-      proposalRefs
-    );
-    state.terminalDecisionIds.add(decision.decisionId);
-    return false;
-  }
-  const admission = {
-    kind: "work-item-domain-action-admission",
-    admissionId: decision.admissionId,
-    proposalId: proposal.proposalId,
-    workItemId: proposal.workItemId,
-    actionKind: proposal.actionKind,
-    state: admissionState,
-    decisionId: decision.decisionId,
-    policyId: decision.policyId,
-    reason: decision.reason,
-    targetProposalId: decision.targetProposalId,
-    targetAdmissionId: decision.targetAdmissionId,
-    sourceRefs: workItemAdmissionDecisionRefs(decision, proposal, policy),
-    admittedAtMs: decision.decidedAtMs ?? admittedAtMs,
-    metadata: {
-      ...proposal.metadata ?? {},
-      ...policy?.metadata ?? {},
-      ...decision.metadata ?? {}
-    }
-  };
-  state.admissionsById.set(admission.admissionId, admission);
-  state.admissionsByProposal.set(admission.proposalId, admission);
-  state.terminalDecisionIds.add(decision.decisionId);
-  state.statusSeq += 1;
-  state.auditSeq += 1;
-  const statusState = workItemAdmissionStatusState(admission.state);
-  const status = {
-    kind: "work-item-status",
-    statusId: `${proposal.workItemId}:${statusState}:${state.statusSeq}`,
-    workItemId: proposal.workItemId,
-    state: statusState,
-    sourceRefs: admission.sourceRefs,
-    effectRunId: proposal.effectRunId,
-    evidenceId: proposal.evidenceId,
-    proposalId: proposal.proposalId,
-    metadata: {
-      actionKind: proposal.actionKind,
-      admissionId: admission.admissionId,
-      decisionId: decision.decisionId,
-      policyId: decision.policyId
-    }
-  };
-  const audit = {
-    id: `${proposal.workItemId}:${statusState}:${state.auditSeq}`,
-    kind: `work-item-domain-action-${admission.state}`,
-    subjectId: proposal.workItemId,
-    sourceRefs: admission.sourceRefs,
-    metadata: {
-      actionKind: proposal.actionKind,
-      admissionId: admission.admissionId,
-      decisionId: decision.decisionId,
-      policyId: decision.policyId,
-      proposalId: proposal.proposalId
-    }
-  };
-  ctx.down([
-    ["DATA", { kind: "admission", admission }],
-    ["DATA", { kind: "status", status }],
-    ["DATA", { kind: "audit", audit }]
-  ]);
-  return true;
-}
-function workItemEvidenceFromResult(result, run, workItemId, request, recordedAtMs) {
-  const base = {
-    kind: "work-item-evidence-recorded",
-    evidenceId: `${workItemId}:${result.effectRunId}:${result.resultId}`,
-    workItemId,
-    requestId: request?.requestId,
-    effectRunId: result.effectRunId,
-    effectRunResultId: result.resultId,
-    executionInputRevision: request?.executionInputRevision,
-    planId: request?.planId,
-    planMemberId: request?.planMemberId,
-    status: result.status,
-    sourceRefs: uniqueSourceRefs2([
-      ref2("work-item", workItemId),
-      ref2("effect-run", result.effectRunId),
-      ref2("effect-run-result", result.resultId),
-      ...run.sourceRefs ?? [],
-      ...run.subjectRefs ?? [],
-      ...run.policyRefs ?? [],
-      ...result.sourceRefs ?? [],
-      ...result.subjectRefs ?? []
-    ]),
-    issues: result.issues,
-    auditRefs: result.auditRefs,
-    recordedAtMs,
-    metadata: {
-      ...result.metadata ?? {},
-      ...request?.requestId === void 0 ? {} : { requestId: request.requestId },
-      ...request?.executionInputRevision === void 0 ? {} : { executionInputRevision: request.executionInputRevision },
-      ...request?.planId === void 0 ? {} : { planId: request.planId },
-      ...request?.planMemberId === void 0 ? {} : { planMemberId: request.planMemberId }
-    }
-  };
-  if (result.status === "completed") return { ...base, output: result.output };
-  if (result.status === "failed") return { ...base, error: result.error };
-  if (result.status === "blocked") return { ...base, needs: result.needs };
-  if (result.status === "timeout") return { ...base, timeoutMs: result.timeoutMs };
-  if (result.status === "canceled" || result.status === "waived")
-    return { ...base, reason: result.reason };
-  return base;
-}
-function workItemMappingPolicyIssue(state, request, run) {
-  const context = workItemMappingPolicyContext(request, run);
-  const referencedPolicyIds = context.policyRefs.filter((sourceRef) => sourceRef.kind === "work-item-effect-mapping-policy").map((sourceRef) => sourceRef.id);
-  for (const policyId of referencedPolicyIds) {
-    const policy = state.policies.get(policyId);
-    if (policy === void 0) {
-      return {
-        code: "missing-work-item-effect-mapping-policy",
-        message: `WorkItemEffectMappingPolicy '${policyId}' was required but not present`
-      };
-    }
-    const issue = validateWorkItemMappingPolicy(policy, context.effectKind);
-    if (issue !== void 0) return issue;
-  }
-  return void 0;
-}
-function validateWorkItemMappingPolicy(policy, effectKind) {
-  if (!policyAppliesToRequest(policy, effectKind)) {
-    return {
-      code: "work-item-effect-mapping-policy-mismatch",
-      message: `WorkItemEffectMappingPolicy '${policy.policyId}' does not apply to effectKind '${effectKind ?? "unknown"}'`
-    };
-  }
-  const behavior = policy.evidence?.behavior ?? "record";
-  if (behavior !== "record") {
-    return {
-      code: "unsupported-work-item-evidence-behavior",
-      message: `WorkItemEffectMappingPolicy '${policy.policyId}' uses unsupported evidence behavior '${behavior}'`
-    };
-  }
-  return void 0;
-}
-function admissionPolicyForDecision(state, decision) {
-  if (decision.policyId === void 0) return void 0;
-  const stalePolicyRef = (decision.sourceRefs ?? []).find(
-    (sourceRef) => sourceRef.kind === "work-item-domain-action-admission-policy" && sourceRef.id !== decision.policyId
-  );
-  if (stalePolicyRef !== void 0) return "stale-work-item-domain-action-admission-policy-ref";
-  return state.policies.get(decision.policyId) ?? "missing-work-item-domain-action-admission-policy";
-}
-function admissionPolicyIssueMessage(code, decision) {
-  if (code === "missing-work-item-domain-action-admission-policy") {
-    return `WorkItemDomainActionAdmissionPolicy '${decision.policyId}' was referenced for WorkItem action admission but not present`;
-  }
-  return `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' carries a stale admission policy source ref`;
-}
-function validateWorkItemAdmissionPolicy(policy, decision, proposal) {
-  if (policy.actionKinds !== void 0 && !policy.actionKinds.includes(proposal.actionKind)) {
-    return {
-      code: "work-item-domain-action-admission-policy-mismatch",
-      message: `WorkItemDomainActionAdmissionPolicy '${policy.policyId}' does not apply to actionKind '${proposal.actionKind}'`
-    };
-  }
-  if (policy.allowedOutcomes !== void 0 && !policy.allowedOutcomes.includes(decision.outcome)) {
-    return {
-      code: "unsupported-work-item-domain-action-admission-outcome",
-      message: `WorkItemDomainActionAdmissionPolicy '${policy.policyId}' does not allow outcome '${decision.outcome}'`
-    };
-  }
-  return void 0;
-}
-function validateWorkItemAdmissionMergeTarget(state, decision) {
-  const hasTargetProposal = decision.targetProposalId !== void 0;
-  const hasTargetAdmission = decision.targetAdmissionId !== void 0;
-  if (decision.outcome !== "merge") {
-    if (hasTargetProposal || hasTargetAdmission) {
-      return {
-        code: "ambiguous-work-item-domain-action-admission-merge-target",
-        message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' carries a merge target for non-merge outcome '${decision.outcome}'`
-      };
-    }
-    return void 0;
-  }
-  if (hasTargetProposal === hasTargetAdmission) {
-    return {
-      code: "ambiguous-work-item-domain-action-admission-merge-target",
-      message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' must reference exactly one merge target`
-    };
-  }
-  if (decision.targetProposalId === decision.proposalId) {
-    return {
-      code: "ambiguous-work-item-domain-action-admission-merge-target",
-      message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' cannot merge a proposal into itself`
-    };
-  }
-  if (decision.targetProposalId !== void 0 && !state.proposals.has(decision.targetProposalId)) {
-    return {
-      code: "unknown-work-item-domain-action-admission-merge-target",
-      message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' references unknown target proposal '${decision.targetProposalId}'`
-    };
-  }
-  if (decision.targetAdmissionId !== void 0 && !state.admissionsById.has(decision.targetAdmissionId)) {
-    return {
-      code: "unknown-work-item-domain-action-admission-merge-target",
-      message: `WorkItemDomainActionAdmissionDecision '${decision.decisionId}' references unknown target admission '${decision.targetAdmissionId}'`
-    };
-  }
-  return void 0;
-}
-function admissionStateForOutcome(outcome) {
-  if (outcome === "admit") return "admitted";
-  if (outcome === "reject") return "rejected";
-  if (outcome === "defer") return "deferred";
-  if (outcome === "merge") return "merged";
-  return void 0;
-}
-function workItemAdmissionStatusState(state) {
-  if (state === "admitted") return "domain-action-admitted";
-  if (state === "rejected") return "domain-action-rejected";
-  if (state === "deferred") return "domain-action-deferred";
-  return "domain-action-merged";
-}
-function policyAppliesToRequest(policy, effectKind) {
-  return policy.effectKinds === void 0 || effectKind !== void 0 && policy.effectKinds.includes(effectKind);
-}
-function workItemMappingPolicyContext(request, run) {
-  return {
-    policyRefs: request?.policyRefs ?? run.policyRefs ?? [],
-    effectKind: request?.effectKind ?? effectKindFromRun(run)
-  };
-}
-function effectKindFromRun(run) {
-  const effectKind = run.metadata?.effectKind;
-  return typeof effectKind === "string" ? effectKind : void 0;
-}
-function workItemMappingPolicyIssueRefs(result, run, request) {
-  return uniqueSourceRefs2([
-    ...workItemResultRefs(result),
-    ...request === void 0 ? [...run.sourceRefs ?? [], ...run.subjectRefs ?? [], ...run.policyRefs ?? []] : workItemEffectRequestRefs(request)
-  ]);
-}
-function clearPendingWorkItemEffectRequestsForRun(state, effectRunId) {
-  for (const pendingRequest of state.pendingEffectRequests.values()) {
-    if (pendingRequest.effectRunId === effectRunId)
-      state.pendingEffectRequests.delete(pendingRequest.requestId);
-  }
-}
-function emitWorkItemEffectRunIssue(ctx, state, key, code, message, subjectId, sourceRefs) {
-  if (state.issueKeys.has(key)) return;
-  state.issueKeys.add(key);
-  state.issueSeq += 1;
-  state.statusSeq += 1;
-  state.auditSeq += 1;
-  const issue = dataIssue2(code, message, { subjectId, refs: sourceRefs });
-  const status = {
-    kind: "work-item-status",
-    statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
-    workItemId: subjectId ?? "unknown",
-    state: "mapping-issue",
-    sourceRefs,
-    issues: [issue]
-  };
-  const audit = {
-    id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
-    kind: "work-item-effect-run-issue",
-    subjectId,
-    issueCode: code,
-    message,
-    sourceRefs
-  };
-  state.issues.push(issue);
-  state.audit.push(audit);
-  ctx.down([
-    ["DATA", { kind: "issue", issue }],
-    ["DATA", { kind: "status", status }],
-    ["DATA", { kind: "audit", audit }]
-  ]);
-}
-function emitWorkItemEvidenceIssue(ctx, state, key, code, message, subjectId, sourceRefs) {
-  if (state.issueKeys.has(key)) return;
-  state.issueKeys.add(key);
-  state.issueSeq += 1;
-  state.statusSeq += 1;
-  state.auditSeq += 1;
-  const issue = dataIssue2(code, message, { subjectId, refs: sourceRefs });
-  const status = {
-    kind: "work-item-status",
-    statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
-    workItemId: subjectId ?? "unknown",
-    state: "mapping-issue",
-    sourceRefs,
-    issues: [issue]
-  };
-  const audit = {
-    id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
-    kind: "work-item-evidence-mapping-issue",
-    subjectId,
-    issueCode: code,
-    message,
-    sourceRefs
-  };
-  state.issues.push(issue);
-  state.audit.push(audit);
-  ctx.down([
-    ["DATA", { kind: "issue", issue }],
-    ["DATA", { kind: "status", status }],
-    ["DATA", { kind: "audit", audit }]
-  ]);
-}
-function emitWorkItemActionProposalIssue(ctx, state, key, code, message, subjectId, sourceRefs) {
-  if (state.issueKeys.has(key)) return;
-  state.issueKeys.add(key);
-  state.issueSeq += 1;
-  state.statusSeq += 1;
-  state.auditSeq += 1;
-  const issue = dataIssue2(code, message, { subjectId, refs: sourceRefs });
-  const status = {
-    kind: "work-item-status",
-    statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
-    workItemId: subjectId ?? "unknown",
-    state: "mapping-issue",
-    sourceRefs,
-    issues: [issue]
-  };
-  const audit = {
-    id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
-    kind: "work-item-action-proposal-issue",
-    subjectId,
-    issueCode: code,
-    message,
-    sourceRefs
-  };
-  ctx.down([
-    ["DATA", { kind: "issue", issue }],
-    ["DATA", { kind: "status", status }],
-    ["DATA", { kind: "audit", audit }]
-  ]);
-}
-function emitWorkItemAdmissionIssue(ctx, state, key, code, message, subjectId, sourceRefs) {
-  if (state.issueKeys.has(key)) return;
-  state.issueKeys.add(key);
-  state.issueSeq += 1;
-  state.statusSeq += 1;
-  state.auditSeq += 1;
-  const issue = dataIssue2(code, message, { subjectId, refs: sourceRefs });
-  const status = {
-    kind: "work-item-status",
-    statusId: `${subjectId ?? "work-item"}:mapping-issue:${state.statusSeq}`,
-    workItemId: subjectId ?? "unknown",
-    state: "mapping-issue",
-    sourceRefs,
-    issues: [issue]
-  };
-  const audit = {
-    id: `${subjectId ?? "work-item"}:${code}:${state.auditSeq}`,
-    kind: "work-item-domain-action-admission-issue",
-    subjectId,
-    issueCode: code,
-    message,
-    sourceRefs
-  };
-  ctx.down([
-    ["DATA", { kind: "issue", issue }],
-    ["DATA", { kind: "status", status }],
-    ["DATA", { kind: "audit", audit }]
-  ]);
-}
-function emptyWorkItemEffectRunState() {
-  return {
-    workItems: /* @__PURE__ */ new Map(),
-    requests: /* @__PURE__ */ new Map(),
-    effectRunsByRequest: /* @__PURE__ */ new Map(),
-    seededEffectRunIds: /* @__PURE__ */ new Set(),
-    issues: [],
-    audit: [],
-    issueKeys: /* @__PURE__ */ new Set(),
-    statusSeq: 0,
-    issueSeq: 0,
-    auditSeq: 0
-  };
-}
-function emptyWorkItemEvidenceState() {
-  return {
-    workItems: /* @__PURE__ */ new Map(),
-    effectRuns: /* @__PURE__ */ new Map(),
-    effectRunWorkItems: /* @__PURE__ */ new Map(),
-    evidenceByWorkItem: /* @__PURE__ */ new Map(),
-    latestEvidenceByEffectRun: /* @__PURE__ */ new Map(),
-    pendingEffectRequests: /* @__PURE__ */ new Map(),
-    requestsByEffectRun: /* @__PURE__ */ new Map(),
-    ambiguousRequestsByEffectRun: /* @__PURE__ */ new Map(),
-    policies: /* @__PURE__ */ new Map(),
-    issues: [],
-    audit: [],
-    issueKeys: /* @__PURE__ */ new Set(),
-    statusSeq: 0,
-    issueSeq: 0,
-    auditSeq: 0
-  };
-}
-function emptyWorkItemDomainActionProposalState() {
-  return {
-    workItems: /* @__PURE__ */ new Map(),
-    evidence: /* @__PURE__ */ new Map(),
-    results: /* @__PURE__ */ new Map(),
-    policies: /* @__PURE__ */ new Map(),
-    proposedKeys: /* @__PURE__ */ new Set(),
-    issueKeys: /* @__PURE__ */ new Set(),
-    statusSeq: 0,
-    issueSeq: 0,
-    auditSeq: 0
-  };
-}
-function emptyWorkItemDomainActionAdmissionState() {
-  return {
-    proposals: /* @__PURE__ */ new Map(),
-    policies: /* @__PURE__ */ new Map(),
-    decisions: /* @__PURE__ */ new Map(),
-    admissionsById: /* @__PURE__ */ new Map(),
-    admissionsByProposal: /* @__PURE__ */ new Map(),
-    terminalDecisionIds: /* @__PURE__ */ new Set(),
-    issueKeys: /* @__PURE__ */ new Set(),
-    statusSeq: 0,
-    issueSeq: 0,
-    auditSeq: 0
-  };
-}
-function freezeWorkItemEffectRequestViews(state) {
-  return {
-    pendingEffectRequests: Object.freeze(Array.from(state.pendingEffectRequests.values())),
-    issues: Object.freeze([...state.issues]),
-    audit: Object.freeze([...state.audit])
-  };
-}
-function freezeWorkItemEvidenceViews(state) {
-  return {
-    evidenceByWorkItem: new Map(
-      Array.from(state.evidenceByWorkItem, ([key, value]) => [key, Object.freeze([...value])])
-    ),
-    latestEvidenceByEffectRun: new Map(state.latestEvidenceByEffectRun),
-    issues: Object.freeze([...state.issues]),
-    audit: Object.freeze([...state.audit]),
-    pendingEffectRequests: Object.freeze(Array.from(state.pendingEffectRequests.values()))
-  };
-}
-function freezeWorkItemDomainActionProposalViews(state) {
-  return {
-    proposalsByWorkItem: new Map(
-      Array.from(state.proposalsByWorkItem, ([key, value]) => [key, Object.freeze([...value])])
-    ),
-    proposalsByEvidence: new Map(
-      Array.from(state.proposalsByEvidence, ([key, value]) => [key, Object.freeze([...value])])
-    ),
-    issues: Object.freeze([...state.issues]),
-    audit: Object.freeze([...state.audit])
-  };
-}
-function freezeWorkItemDomainActionAdmissionViews(state) {
-  return {
-    admissionsByProposal: new Map(state.admissionsByProposal),
-    admissionsByWorkItem: new Map(
-      Array.from(state.admissionsByWorkItem, ([key, value]) => [key, Object.freeze([...value])])
-    ),
-    issues: Object.freeze([...state.issues]),
-    audit: Object.freeze([...state.audit])
-  };
-}
-function deletePendingWorkItemEffectRequest(state, refs) {
-  for (const requestRef of refs?.filter((value) => value.startsWith("work-item-effect-request:")) ?? []) {
-    const requestId = requestRef.slice("work-item-effect-request:".length);
-    state.pendingEffectRequests.delete(requestId);
-    state.settledRequestIds.add(requestId);
-  }
-}
-function workItemEffectRequestRefs(request) {
-  return [
-    ref2("work-item", request.workItemId),
-    ref2("work-item-effect-request", request.requestId),
-    ...request.sourceRefs ?? []
-  ];
-}
-function workItemResultRefs(result) {
-  return [
-    ref2("effect-run", result.effectRunId),
-    ref2("effect-run-result", result.resultId),
-    ...result.sourceRefs ?? [],
-    ...result.subjectRefs ?? []
-  ];
-}
-function workItemActionProposalRefs(evidence, result, policy) {
-  return uniqueSourceRefs2([
-    ref2("work-item", evidence.workItemId),
-    ref2("effect-run", evidence.effectRunId),
-    ref2("effect-run-result", evidence.effectRunResultId),
-    ref2("work-item-evidence", evidence.evidenceId),
-    ...policy === void 0 ? [] : [ref2("work-item-effect-mapping-policy", policy.policyId)],
-    ...evidence.sourceRefs ?? [],
-    ...result.sourceRefs ?? [],
-    ...result.subjectRefs ?? []
-  ]);
-}
-function workItemAdmissionProposalRefs(proposal) {
-  return uniqueSourceRefs2([
-    ref2("work-item", proposal.workItemId),
-    ref2("work-item-domain-action-proposal", proposal.proposalId),
-    ref2("effect-run", proposal.effectRunId),
-    ref2("effect-run-result", proposal.effectRunResultId),
-    ref2("work-item-evidence", proposal.evidenceId),
-    ref2("work-item-effect-mapping-policy", proposal.policyId),
-    ...proposal.sourceRefs ?? []
-  ]);
-}
-function workItemAdmissionDecisionRefs(decision, proposal, policy) {
-  return uniqueSourceRefs2([
-    ...proposal === void 0 ? [] : workItemAdmissionProposalRefs(proposal),
-    ref2("work-item-domain-action-admission-decision", decision.decisionId),
-    ref2("work-item-domain-action-admission", decision.admissionId),
-    ref2("work-item-domain-action-proposal", decision.proposalId),
-    ...decision.policyId === void 0 ? [] : [ref2("work-item-domain-action-admission-policy", decision.policyId)],
-    ...policy === void 0 ? [] : [ref2("work-item-domain-action-admission-policy", policy.policyId)],
-    ...decision.targetProposalId === void 0 ? [] : [ref2("work-item-domain-action-proposal", decision.targetProposalId)],
-    ...decision.targetAdmissionId === void 0 ? [] : [ref2("work-item-domain-action-admission", decision.targetAdmissionId)],
-    ...decision.sourceRefs ?? []
-  ]);
-}
-function workItemEvidenceOnlyRefs(evidence) {
-  return uniqueSourceRefs2([
-    ref2("work-item", evidence.workItemId),
-    ref2("effect-run", evidence.effectRunId),
-    ref2("effect-run-result", evidence.effectRunResultId),
-    ref2("work-item-evidence", evidence.evidenceId),
-    ...evidence.sourceRefs ?? []
-  ]);
-}
-function referencedWorkItemMappingPolicyIds(evidence) {
-  const refs = uniqueSourceRefs2([...evidence.sourceRefs ?? []]);
-  return refs.filter((sourceRef) => sourceRef.kind === "work-item-effect-mapping-policy").map((sourceRef) => sourceRef.id);
-}
-function effectKindFromMetadata(metadata) {
-  const effectKind = metadata?.effectKind;
-  return typeof effectKind === "string" ? effectKind : void 0;
-}
-function workItemActionProposalPayload(spec, evidence, result) {
-  if (spec.payload !== void 0) return spec.payload;
-  const payloadFrom = spec.payloadFrom;
-  if (payloadFrom === void 0) return void 0;
-  if (payloadFrom === "effect-run-result")
-    return { kind: "effect-run-result-ref", resultId: result.resultId };
-  if (payloadFrom === "output") return evidence.output;
-  return { kind: "work-item-evidence-ref", evidenceId: evidence.evidenceId };
-}
-function resultReason(result) {
-  if (result.status === "canceled" || result.status === "waived") return result.reason;
-  return void 0;
-}
-function workItemIdForEffectRunResult(state, result) {
-  for (const evidence of state.evidence.values()) {
-    if (evidence.effectRunResultId === result.resultId && evidence.effectRunId === result.effectRunId)
-      return evidence.workItemId;
-  }
-  return void 0;
-}
-function uniqueSourceRefs2(sourceRefs) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const sourceRef of sourceRefs) {
-    const key = sourceRefKey(sourceRef);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push(sourceRef);
-  }
-  return unique;
-}
-function sourceRefKey(sourceRef) {
-  return `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
-}
-function distinctWorkItemRefs(sourceRefs) {
-  const refs = /* @__PURE__ */ new Map();
-  for (const sourceRef of sourceRefs ?? []) {
-    if (sourceRef.kind === "work-item") refs.set(sourceRef.id, sourceRef);
-  }
-  return Array.from(refs.values());
-}
-function singleWorkItemRef(sourceRefs) {
-  const matches = distinctWorkItemRefs(sourceRefs);
-  return matches.length === 1 ? matches[0] : void 0;
-}
-function projectRuntimeFact2(graph, runtime, name, factory, pick) {
-  return graph.node(
-    [runtime],
-    (ctx) => {
-      for (const fact of depBatch(ctx, 0) ?? []) {
-        const typed = fact;
-        const value = pick(typed);
-        if (value !== void 0) ctx.down([["DATA", value]]);
-      }
-    },
-    { name, factory }
-  );
-}
-function forEachPolicyDepBatch(ctx, start, count, fn) {
-  for (let i = 0; i < count; i += 1) {
-    for (const value of depBatch(ctx, start + i) ?? []) fn(value);
-  }
-}
-function dataIssue2(code, message, opts = {}) {
-  return {
-    kind: "issue",
-    code,
-    message,
-    severity: opts.severity ?? "error",
-    subjectId: opts.subjectId,
-    refs: opts.refs?.map((r) => `${r.kind}:${r.id}`),
-    details: opts.details
-  };
-}
-function ref2(kind, id) {
-  return { kind, id };
-}
-
-export {
-  effectRun,
-  agentRequestProposalFromDecision,
-  admitAgentRequestProposal,
-  issueAgentRequest,
-  agentRequestLedgerViews,
-  requestSatisfactionProjector,
-  localBuiltinToolProviderCatalog,
-  executorOutcomeViewProjector,
-  structuredAgentDecisionInterpreter,
-  effectRunCompletionProjector,
-  fakeExecutorResult,
-  fakeExecutorFailure,
-  fakeExecutorBlocked,
-  fakeExecutorTimeout,
-  fakeExecutorCanceled,
-  workItemEffectRunProjector,
-  workItemEffectResultMapper,
-  workItemDomainActionProposalProjector,
-  workItemDomainActionAdmissionProjector
-};
-//# sourceMappingURL=chunk-PC3BTTBE.js.map