@graphrefly/ts 0.0.0 → 0.0.1

package/dist/orchestration/index.cjs

@@ -20,18 +20,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/orchestration/index.ts
 var orchestration_exports = {};
 __export(orchestration_exports, {
+  admitAgentRequestProposal: () => admitAgentRequestProposal,
+  agentRequestLedgerViews: () => agentRequestLedgerViews,
+  agentRequestProposalFromDecision: () => agentRequestProposalFromDecision,
   backoffDelayMs: () => backoffDelayMs,
   breakerBundle: () => breakerBundle,
   constantBackoff: () => constantBackoff,
+  effectRun: () => effectRun,
+  effectRunCompletionProjector: () => effectRunCompletionProjector,
+  executorOutcomeViewProjector: () => executorOutcomeViewProjector,
+  fakeExecutorBlocked: () => fakeExecutorBlocked,
+  fakeExecutorCanceled: () => fakeExecutorCanceled,
+  fakeExecutorFailure: () => fakeExecutorFailure,
+  fakeExecutorResult: () => fakeExecutorResult,
+  fakeExecutorTimeout: () => fakeExecutorTimeout,
+  issueAgentRequest: () => issueAgentRequest,
+  localBuiltinToolProviderCatalog: () => localBuiltinToolProviderCatalog,
   nextRetryDelayMs: () => nextRetryDelayMs,
   noBackoff: () => noBackoff,
   processBundle: () => processBundle,
   processEffectRunner: () => processEffectRunner,
   rateLimitBundle: () => rateLimitBundle,
+  requestSatisfactionProjector: () => requestSatisfactionProjector,
   retryPolicy: () => retryPolicy,
   retryStatusBundle: () => retryStatusBundle,
   shouldRetry: () => shouldRetry,
-  timeoutBundle: () => timeoutBundle
+  structuredAgentDecisionInterpreter: () => structuredAgentDecisionInterpreter,
+  timeoutBundle: () => timeoutBundle,
+  workItemDomainActionAdmissionProjector: () => workItemDomainActionAdmissionProjector,
+  workItemDomainActionProposalProjector: () => workItemDomainActionProposalProjector,
+  workItemEffectResultMapper: () => workItemEffectResultMapper,
+  workItemEffectRunProjector: () => workItemEffectRunProjector
 });
 module.exports = __toCommonJS(orchestration_exports);
 
@@ -54,6 +73,7 @@ var TIER = {
   START: TIER_START,
   PAUSE: TIER_CONTROL,
   RESUME: TIER_CONTROL,
+  PULL: TIER_CONTROL,
   DIRTY: TIER_NOTIFICATION,
   DATA: TIER_VALUE,
   RESOLVED: TIER_VALUE,
@@ -967,6 +987,17 @@ function notifyTopologyDepsChanged(node, prevDeps, deps) {
 function terminalView(t) {
   return t === void 0 ? false : t;
 }
+function normalizePullDemand(demand) {
+  if (typeof demand !== "object" || demand === null || Array.isArray(demand)) {
+    throw new Error("ctx.up: PULL requires { pullId, params? } demand payload (D269)");
+  }
+  const pullId = demand.pullId;
+  if (typeof pullId !== "string" && typeof pullId !== "symbol") {
+    throw new Error("ctx.up: PULL demand requires a string or symbol pullId (D269)");
+  }
+  const params = demand.params;
+  return params === void 0 ? { pullId } : { pullId, params };
+}
 function validateDownPayloads(msgs) {
   for (const m of msgs) {
     if (m[0] === "DATA" && m[1] === void 0) {
@@ -1010,7 +1041,7 @@ var Node = class {
     const pull = opts.pullId !== void 0;
     if (pull && pausable === false)
       throw new Error(
-        "node: pullId is incompatible with pausable:false \u2014 a pull node is demanded via RESUME, which pausable:false ignores (R-pull / R-pause-modes / D55,D59)"
+        "node: pullId is incompatible with pausable:false \u2014 a pull node uses the pausable delivery-content axis (R-pull / R-pause-modes / D55,D269)"
       );
     let handle;
     if (handleOrFn === null) handle = null;
@@ -1033,7 +1064,6 @@ var Node = class {
       value.status = "settled";
     }
     const pauseLockset = /* @__PURE__ */ new Set();
-    if (pull) pauseLockset.add(pullLock);
     this._core = core ?? new NodeCore();
     const created = this._core.createSlot(
       {
@@ -1074,7 +1104,9 @@ var Node = class {
           pauseLockset,
           pausedDepWaveOccurred: false,
           pauseBuffer: [],
-          demandOwed: false,
+          demandOwed: void 0,
+          activePull: void 0,
+          pullDirtyOwed: false,
           inDeliverDemand: false
         },
         privateState: { value: SENTINEL, persist: false },
@@ -1131,10 +1163,11 @@ var Node = class {
       this._wave.batchDirtyOwed = false;
       this._control.pauseBuffer = [];
       this._control.pausedDepWaveOccurred = false;
-      this._control.demandOwed = false;
+      this._control.demandOwed = void 0;
+      this._control.activePull = void 0;
+      this._control.pullDirtyOwed = false;
       this._control.inDeliverDemand = false;
       this._control.pauseLockset.clear();
-      if (this._slot.pull) this._control.pauseLockset.add(this._slot.pullLock);
       this._privateState.value = state.ctxState.value;
       this._privateState.persist = state.ctxState.persist;
       if (state.version === false) {
@@ -1173,17 +1206,16 @@ var Node = class {
     subscriberCountReaders.set(this, () => this._subscriberCount());
     activationReaders.set(this, () => this._lifecycle.activated);
   }
-  /** R-pull (D55): true while a pull node is quiet (holds its own pullId/demand lock). */
+  /** R-pull (D55/D272): true while a pull node is not serving a PULL demand pulse. */
   _isPullQuiet() {
-    return this._slot.pull && this._control.pauseLockset.has(this._slot.pullLock);
+    return this._slot.pull && this._control.activePull === void 0;
   }
   /**
-   * R-pull (D55/D59): this pull node's pullId (pure data, like {@link cache}/{@link handle} — never
-   * triggers computation). A consumer demands one delivery by cone-routing a RESUME of it (no node
-   * reference): `ctx.up([["RESUME", pullId]])` (immediate; loops back → D37 for a self-read dep) or
-   * `ctx.upNext([["RESUME", pullId]])` (boundary-deferred self-demand, R-up-routing/R-rewire-deferred).
-   * Undefined for a non-pull node. The author writes the pullId verbatim, so this getter is mainly
-   * for inspection/describe; routing matches by the pullId value carried in the RESUME, by identity.
+   * R-pull (D269/D272): this pull node's pullId (pure data, like {@link cache}/{@link handle} —
+   * never triggers computation). A consumer demands one delivery by cone-routing PULL of it (no
+   * node reference): `ctx.up([["PULL", { pullId }]])` (immediate; loops back → D37 for a self-read
+   * dep) or `ctx.upNext([["PULL", { pullId }]])` (boundary-deferred self-demand). Undefined for a
+   * non-pull node. The author writes the pullId verbatim; routing matches by identity.
    */
   get pullId() {
     return this._slot.pullLock;
@@ -1290,10 +1322,10 @@ var Node = class {
     });
   }
   /**
-   * Enqueue a deferred up-going control wave (R-up-routing / R-pull / D59): at the committed wave
+   * Enqueue a deferred up-going control/demand wave (R-up-routing / R-pull / D269): at the committed wave
    * boundary, route `msgs` up from THIS node (broadcast, or up the single `towardDep` edge). The
-   * deferred form of `ctx.up` — the SELF-demand path: a consumer issues `ctx.upNext([[RESUME,
-   * pullId]])` to demand a dep it ALSO reads; the demand applies at the boundary (not mid-fn), so
+   * deferred form of `ctx.up` — the SELF-demand path: a consumer issues `ctx.upNext([[PULL,
+   * { pullId }]])` to demand a dep it ALSO reads; the demand applies at the boundary (not mid-fn), so
    * the pull node's delivery loops back as a FRESH wave rather than re-entering the consumer (D37 /
    * R-reentrancy). Rides the same R-rewire-deferred (D47) drain as ctx.rewireNext.
    */
@@ -1508,7 +1540,6 @@ var Node = class {
     this._lifecycle.activated = true;
     const seedRestoredDeps = this._restoredActivationPending;
     this._restoredActivationPending = false;
-    if (this._slot.pull) this._control.pauseLockset.add(this._slot.pullLock);
     this._dep.unsubs = new Array(this._slot.deps.length);
     this._dep.idxBoxes = new Array(this._slot.deps.length);
     for (const dep of this._slot.deps)
@@ -1580,7 +1611,9 @@ var Node = class {
     this._control.pauseLockset.clear();
     this._control.pauseBuffer = [];
     this._control.pausedDepWaveOccurred = false;
-    this._control.demandOwed = false;
+    this._control.demandOwed = void 0;
+    this._control.activePull = void 0;
+    this._control.pullDirtyOwed = false;
     this._value.replayRing = [];
     if (!this._privateState.persist) this._privateState.value = SENTINEL;
   }
@@ -1592,8 +1625,7 @@ var Node = class {
     return this._lifecycle.subscribers.size;
   }
   _isRuntimeQuiescentForRelease() {
-    const allowedPullQuietLock = this._slot.pull && this._control.pauseLockset.size === 1 && this._control.pauseLockset.has(this._slot.pullLock);
-    return !this._released && this._value.status !== "dirty" && this._value.status !== "pending" && this._wave.pending === 0 && !this._wave.insideRunWave && !this._wave.inDepMutation && !this._wave.rewireRunPending && !this._wave.batchDirtyOwed && this._dep.dirty.every((dirty) => !dirty) && this._control.pauseBuffer.length === 0 && !this._control.pausedDepWaveOccurred && !this._control.demandOwed && !this._control.inDeliverDemand && (this._control.pauseLockset.size === 0 || allowedPullQuietLock);
+    return !this._released && this._value.status !== "dirty" && this._value.status !== "pending" && this._wave.pending === 0 && !this._wave.insideRunWave && !this._wave.inDepMutation && !this._wave.rewireRunPending && !this._wave.batchDirtyOwed && this._dep.dirty.every((dirty) => !dirty) && this._control.pauseBuffer.length === 0 && !this._control.pausedDepWaveOccurred && this._control.demandOwed === void 0 && this._control.activePull === void 0 && !this._control.inDeliverDemand && this._control.pauseLockset.size === 0;
   }
   _releaseRuntime() {
     if (this._released) return;
@@ -1649,7 +1681,9 @@ var Node = class {
     this._control.pauseLockset.clear();
     this._control.pauseBuffer = [];
     this._control.pausedDepWaveOccurred = false;
-    this._control.demandOwed = false;
+    this._control.demandOwed = void 0;
+    this._control.activePull = void 0;
+    this._control.pullDirtyOwed = false;
     this._restoredActivationPending = false;
     checkpointReaders.delete(this);
     restoreWriters.delete(this);
@@ -1831,7 +1865,7 @@ var Node = class {
       this._wave.rewireRunPending = true;
       return;
     }
-    if (this._slot.pausable === true && this._isPaused()) {
+    if (this._slot.pausable === true && (this._isPaused() || this._isPullQuiet())) {
       this._control.pausedDepWaveOccurred = true;
       return;
     }
@@ -1971,10 +2005,11 @@ var Node = class {
         unsubscribeDep: (dep, fn) => this._requestRewireNext({ kind: "remove", dep, fn }),
         replaceDeps: (deps, fn) => this._requestRewireNext({ kind: "set", deps, fn })
       },
-      // R-up-routing / R-pull (D59): deferred up — route a control wave (e.g. a RESUME pull
-      // DEMAND) up the declared cone at the committed boundary. The SELF-demand path: an
+      // R-up-routing / R-pull (D269): deferred up — route a control/demand wave (e.g. PULL)
+      // up the declared cone at the committed boundary. The SELF-demand path: an
       // immediate ctx.up whose delivery loops back re-enters this fn (D37 / R-reentrancy).
       upNext: (msgs, towardDep) => this._requestUpNext(msgs, towardDep),
+      ...this._control.activePull === void 0 ? {} : { pull: this._control.activePull },
       [CTX_DEP_CACHE]: { latest: snapshot?.latest ?? this._dep.prev },
       [CTX_NODE_BINDING]: {
         dispatcher: this._slot.dispatcher,
@@ -1989,6 +2024,11 @@ var Node = class {
   _refreshCtx(ctx) {
     ctx.waveData = this._dep.waveData;
     ctx.terminal = this._dep.terminalInput.map(terminalView);
+    if (this._control.activePull === void 0) {
+      delete ctx.pull;
+    } else {
+      ctx.pull = this._control.activePull;
+    }
     ctx[CTX_DEP_CACHE] = { latest: this._dep.prev };
   }
   _makeState() {
@@ -2081,7 +2121,7 @@ var Node = class {
         plannedVersions[i] = plannedVersion;
       }
     }
-    if (hasTier3 && !this._wave.insideRunWave && !this._wave.emittedDirtyThisWave) {
+    if (hasTier3 && (!this._wave.insideRunWave || this._control.pullDirtyOwed) && !this._wave.emittedDirtyThisWave) {
       this._wave.emittedDirtyThisWave = true;
       this._value.status = "dirty";
       this._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
@@ -2161,13 +2201,18 @@ var Node = class {
       if (m[0] === "PAUSE") {
         this._pauseAcquire(m[1]);
       } else if (m[0] === "RESUME") {
-        if (this._slot.pull && m[1] === this._slot.pullLock) {
-          if (!this._markDemandRouted(m[1], routeState)) this._onDemand();
-        } else if (this._control.pauseLockset.has(m[1])) {
+        if (this._control.pauseLockset.has(m[1])) {
           this._pauseRelease(m[1]);
         } else {
           this._forwardUp(m, towardDep, routeState);
         }
+      } else if (m[0] === "PULL") {
+        const demand = normalizePullDemand(m[1]);
+        if (this._slot.pull && demand.pullId === this._slot.pullLock) {
+          if (!this._markDemandRouted(demand.pullId, routeState)) this._onDemand(demand);
+        } else {
+          this._forwardUp(["PULL", demand], towardDep, routeState);
+        }
       } else if (this._slot.deps.length === 0) {
         if (m[0] === "INVALIDATE") this._down([["INVALIDATE"]]);
       } else {
@@ -2189,7 +2234,7 @@ var Node = class {
    * Forward one up-going control message toward deps (R-up-routing): up the single declared edge
    * `towardDep` (directed — prunes other branches; only meaningful on the issuer's FIRST hop) or
    * broadcast up ALL deps. A depless source has no deps → the message DROPS here (the terminus —
-   * e.g. a cone-routed RESUME whose pullId no node up this cone holds, R-up-at-source). Recursive
+   * e.g. a cone-routed PULL whose pullId no node up this cone holds, R-up-at-source). Recursive
    * forwarding carries the same per-wave route state and no `towardDep` → broadcast beyond the
    * first hop.
    */
@@ -2208,9 +2253,7 @@ var Node = class {
   }
   _hasBoundaryPauseLock() {
     if (this._slot.pausable === false) return false;
-    let locks = this._control.pauseLockset.size;
-    if (this._slot.pull && this._control.pauseLockset.has(this._slot.pullLock)) locks--;
-    return locks > 0;
+    return this._control.pauseLockset.size > 0;
   }
   _isAsyncPool() {
     return this._slot.handle !== null && this._slot.dispatcher.poolKind(this._slot.handle.poolId) === "async";
@@ -2221,17 +2264,19 @@ var Node = class {
   _pauseRelease(lockId) {
     if (!this._control.pauseLockset.has(lockId)) return;
     this._control.pauseLockset.delete(lockId);
-    if (this._slot.pull && this._control.demandOwed) this._fireOwedDemandIfReady();
+    if (this._slot.pull && this._control.demandOwed !== void 0) this._fireOwedDemandIfReady();
     if (this._hasBoundaryPauseLock()) return;
     scheduleBoundaryDrain(this._core);
-    if (this._control.pauseLockset.size > 0) return;
+    if (this._slot.pull) return;
     this._onResume();
   }
   _onResume() {
     if (this._value.terminal !== void 0) {
       this._control.pauseBuffer = [];
       this._control.pausedDepWaveOccurred = false;
-      this._control.demandOwed = false;
+      this._control.demandOwed = void 0;
+      this._control.activePull = void 0;
+      this._control.pullDirtyOwed = false;
       return;
     }
     if (this._control.pauseBuffer.length > 0) {
@@ -2245,41 +2290,38 @@ var Node = class {
     }
   }
   /**
-   * R-pull (D59): can this pull node fire a demand NOW? — not terminal, settle-ready (_pending===0),
+   * R-pull (D269): can this pull node fire a demand NOW? — not terminal, settle-ready (_pending===0),
    * and no OTHER (non-pullId) lock holds it paused. The gate that decides fire-now vs OWE.
    */
   _canFireDemand() {
     if (this._value.terminal !== void 0 || this._wave.pending > 0) return false;
-    const own = this._control.pauseLockset.has(this._slot.pullLock) ? 1 : 0;
-    return this._control.pauseLockset.size <= own;
+    return this._control.pauseLockset.size === 0;
   }
   /**
-   * R-pull (D59): deliver ONE demand pulse — release the pullId so the demand wave RELAYS (not
-   * absorbed), fire it, then RE-QUIET (1:1). The pullId re-add + the re-entrancy flag are in a
-   * `finally` so a throwing pull fn (graph-less node, no D30 catch) cannot leave the node
-   * permanently non-quiet (the wedge-fix silently disabled) — QA-found robustness fix.
+   * R-pull (D269/D272): deliver ONE demand pulse — install activePull so the demand wave may
+   * emit, fire it, then clear activePull so the node is quiet again (1:1).
    */
-  _deliverPullDemand() {
-    this._control.demandOwed = false;
+  _deliverPullDemand(demand) {
+    this._control.demandOwed = void 0;
+    this._control.activePull = demand;
     this._control.inDeliverDemand = true;
-    this._control.pauseLockset.delete(this._slot.pullLock);
     try {
       this._firePullDemand();
     } finally {
-      this._control.pauseLockset.add(this._slot.pullLock);
+      this._control.activePull = void 0;
       this._control.inDeliverDemand = false;
     }
   }
   /**
-   * R-pull (D59): a cone-routed RESUME of THIS node's pullId arrived (R-up-routing) = a DEMAND.
+   * R-pull (D269): a cone-routed PULL of THIS node's pullId arrived (R-up-routing) = a DEMAND.
    * Fire immediately if able; else OWE it — pin-5 (a dep DIRTY in flight, _pending>0) or F4/F5 (an
    * external PAUSE lock co-holds the node) — and fire when the node next becomes able. A demand
    * arriving WHILE a delivery is in flight (synchronous re-entry) is DROPPED (1:1, QA guard).
    */
-  _onDemand() {
+  _onDemand(demand) {
     if (this._control.inDeliverDemand) return;
-    if (this._canFireDemand()) this._deliverPullDemand();
-    else this._control.demandOwed = true;
+    if (this._canFireDemand()) this._deliverPullDemand(demand);
+    else this._control.demandOwed = demand;
   }
   /**
    * R-pull (D55): service ONE demand. Delivery content = the orthogonal pausable mode:
@@ -2292,33 +2334,53 @@ var Node = class {
    * `_markDirty` relays the leading DIRTY (not absorbed).
    */
   _firePullDemand() {
+    let drainedBuffer = false;
     if (this._control.pauseBuffer.length > 0) {
       const buf = this._control.pauseBuffer;
       this._control.pauseBuffer = [];
       for (const wave of buf) this._down(wave);
+      drainedBuffer = true;
     }
+    if (drainedBuffer) return;
     if (this._control.pausedDepWaveOccurred) {
       const gated = this._slot.handle !== null && !this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled());
       if (this._wave.pending > 0 || gated) return;
       this._control.pausedDepWaveOccurred = false;
-      this._markDirty();
-      this._tryRun();
+      this._wave.emittedDirtyThisWave = false;
+      this._control.pullDirtyOwed = true;
+      try {
+        this._tryRun();
+      } finally {
+        this._control.pullDirtyOwed = false;
+      }
+      return;
+    }
+    if (this._slot.handle !== null) {
+      if (!this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled())) return;
+      this._wave.emittedDirtyThisWave = false;
+      this._control.pullDirtyOwed = true;
+      try {
+        this._runWave();
+      } finally {
+        this._control.pullDirtyOwed = false;
+      }
     }
   }
   /**
-   * R-pull (D55/D59): fire a demand that was OWED (deferred at demand time) once the node becomes
+   * R-pull (D269): fire a demand that was OWED (deferred at demand time) once the node becomes
    * able — called from the dep-settle arms (DATA/RESOLVED/INVALIDATE/terminal drain _pending, pin-5
    * + B1/F6) and from `_pauseRelease` (an external PAUSE lock releases, F4/F5).
    */
   _fireOwedDemandIfReady() {
     if (this._control.inDeliverDemand) return;
-    if (this._slot.pull && this._control.demandOwed && this._canFireDemand())
-      this._deliverPullDemand();
+    if (this._slot.pull && this._control.demandOwed !== void 0 && this._canFireDemand()) {
+      this._deliverPullDemand(this._control.demandOwed);
+    }
   }
   /** Should an outgoing settle slice be deferred into the pause buffer? */
   _shouldBufferOnPause() {
     if (this._slot.pausable === false) return false;
-    if (!this._isPaused()) return false;
+    if (!this._isPaused() && !this._isPullQuiet()) return false;
     if (this._slot.pausable === "resumeAll") return true;
     if (!this._wave.insideRunWave && this._isAsyncPool() && this._slot.deps.length > 0) return true;
     return false;
@@ -2358,7 +2420,9 @@ var Node = class {
     this._control.pauseLockset.clear();
     this._control.pauseBuffer = [];
     this._control.pausedDepWaveOccurred = false;
-    this._control.demandOwed = false;
+    this._control.demandOwed = void 0;
+    this._control.activePull = void 0;
+    this._control.pullDirtyOwed = false;
     this._value.replayRing = [];
     const isCompute = this._slot.handle !== null || this._slot.deps.length > 0;
     if (isCompute) {
@@ -2553,6 +2617,3197 @@ function timeout(source2, ms) {
   );
 }
 
+// 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 source2 = raw.source;
+  if (!isRecord(source2) || source2.requestId !== outcome.requestId || source2.operationId !== outcome.operationId || source2.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 };
+}
+
 // src/orchestration/index.ts
 var processCommandSources = /* @__PURE__ */ new WeakMap();
 function retryStatusBundle(graph, events, opts = {}) {
@@ -3525,17 +6780,36 @@ function errorMessage(error) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  admitAgentRequestProposal,
+  agentRequestLedgerViews,
+  agentRequestProposalFromDecision,
   backoffDelayMs,
   breakerBundle,
   constantBackoff,
+  effectRun,
+  effectRunCompletionProjector,
+  executorOutcomeViewProjector,
+  fakeExecutorBlocked,
+  fakeExecutorCanceled,
+  fakeExecutorFailure,
+  fakeExecutorResult,
+  fakeExecutorTimeout,
+  issueAgentRequest,
+  localBuiltinToolProviderCatalog,
   nextRetryDelayMs,
   noBackoff,
   processBundle,
   processEffectRunner,
   rateLimitBundle,
+  requestSatisfactionProjector,
   retryPolicy,
   retryStatusBundle,
   shouldRetry,
-  timeoutBundle
+  structuredAgentDecisionInterpreter,
+  timeoutBundle,
+  workItemDomainActionAdmissionProjector,
+  workItemDomainActionProposalProjector,
+  workItemEffectResultMapper,
+  workItemEffectRunProjector
 });
 //# sourceMappingURL=index.cjs.map