@graphrefly/ts 0.0.0 → 0.0.1

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { W as Wave } from '../messages-BZqrGGm1.js';
+import { W as Wave } from '../messages-CAzUPPJM.js';
 
 /**
  * Public testing assertions for clean-slate GraphReFly message streams.

package/dist/testing/index.js

@@ -1,7 +1,8 @@
 import {
   assertDirtyPrecedesTerminalData
-} from "../chunk-TEW47IVR.js";
-import "../chunk-DK554R7P.js";
+} from "../chunk-VPEFSDME.js";
+import "../chunk-S6HXABGL.js";
+import "../chunk-DGUM43GV.js";
 export {
   assertDirtyPrecedesTerminalData
 };

package/dist/{types-h12mNYbq.d.ts → types-BsJvElYZ.d.ts}

@@ -1,4 +1,4 @@
-import { L as LockId, W as Wave, M as Message } from './messages-BZqrGGm1.js';
+import { L as LockId, W as Wave, P as PullDemand, M as Message } from './messages-CAzUPPJM.js';
 
 /**
  * Dispatcher, pools, and the pure-data Handle.
@@ -324,15 +324,16 @@ interface NodeOptions<T = unknown> {
     /** PAUSE/RESUME behavior (R-pause-modes). Default true. */
     pausable?: boolean | "resumeAll";
     /**
-     * Pull-mode node (R-pull / D55,D59): a quiet-until-demanded source, identified by this
+     * Pull-mode node (R-pull / D269): a quiet-until-demanded source, identified by this
      * author-supplied `pullId` (a unique LockId — a `Symbol` recommended; NOT the node name, NOT a
-     * bare string which collides with a same-string pause lock). The node self-holds the pullId as
-     * its demand lock. QUIET by default: it ABSORBS an upstream DIRTY WITHOUT relaying it downstream
-     * (the wedge fix) and does NOT push-on-subscribe its cached value (START only). A DEMAND = a
-     * cone-routed `RESUME` of this pullId (R-up-routing — NO new message type): a downstream consumer
-     * issues `ctx.up([[RESUME, pullId]])` (broadcast up the declared cone) or `ctx.up(msgs, towardDep)`
-     * (directed) WITHOUT holding this node's reference; the RESUME travels up to the pullId-holder,
-     * which fires EXACTLY ONE delivery (DIRTY-before-DATA) then RE-QUIETS (1:1). Delivery content =
+     * bare string if callers may also use strings as pause locks). QUIET by default: it ABSORBS
+     * an upstream DIRTY WITHOUT relaying it downstream
+     * (the wedge fix) and does NOT push-on-subscribe its cached value (START only). A DEMAND =
+     * cone-routed `PULL({pullId, params?})`: a downstream consumer issues
+     * `ctx.up([["PULL", { pullId, params }]])` (broadcast up the declared cone) or
+     * `ctx.up(msgs, towardDep)` (directed) WITHOUT holding this node's reference; the PULL travels
+     * up to the pullId-holder, which fires EXACTLY ONE delivery (DIRTY-before-DATA when it emits)
+     * then RE-QUIETS (1:1). Delivery content =
      * the orthogonal `pausable` mode: `true` → coalesced LATEST (one DATA); `'resumeAll'` → buffered
      * BACKLOG. `pullId` + `pausable:false` is REJECTED at construction. A SELF-triggered demand (a
      * consumer demanding a dep it ALSO reads) must defer via {@link Ctx.upNext} (R-rewire-deferred /
@@ -381,15 +382,14 @@ declare class Node<T = unknown> {
     private get _syncCtx();
     private set _syncCtx(value);
     constructor(deps: Node<unknown>[], handleOrFn: Handle | NodeFn | null, opts?: NodeOptions<T>);
-    /** 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. */
     private _isPullQuiet;
     /**
-     * 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(): LockId | undefined;
     get cache(): T | undefined;
@@ -428,10 +428,10 @@ declare class Node<T = unknown> {
      */
     private _requestRewireNext;
     /**
-     * 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.
      */
@@ -517,7 +517,7 @@ declare class Node<T = unknown> {
      * 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.
      */
@@ -529,19 +529,17 @@ declare class Node<T = unknown> {
     private _pauseRelease;
     private _onResume;
     /**
-     * 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.
      */
     private _canFireDemand;
     /**
-     * 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).
      */
     private _deliverPullDemand;
     /**
-     * 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).
@@ -559,7 +557,7 @@ declare class Node<T = unknown> {
      */
     private _firePullDemand;
     /**
-     * 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).
      */
@@ -667,8 +665,8 @@ interface Ctx {
     /**
      * Emit upstream toward deps — control tiers only (R-ctx-up). IMMEDIATE. `towardDep` (a dep index)
      * routes the wave up ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
-     * A pull DEMAND is `up([[RESUME, pullId]])` — but for a SELF-demand (demanding a dep this fn also
-     * reads) use {@link Ctx.upNext} instead, since an immediate demand whose delivery loops back
+     * A pull DEMAND is `up([[PULL, { pullId, params }]])` — but for a SELF-demand (demanding a dep
+     * this fn also reads) use {@link Ctx.upNext} instead, since an immediate demand whose delivery loops back
      * re-enters this fn mid-wave (D37 / R-reentrancy).
      */
     up(msgs: Wave, towardDep?: number): void;
@@ -689,6 +687,8 @@ interface Ctx {
     onInvalidate(fn: () => void): void;
     /** Graph-owned environment drivers for source/adapter boundaries (D130/D131). */
     environment(): EnvironmentDrivers;
+    /** Holder-visible context for a PULL-caused invocation (D272); absent for ordinary waves. */
+    readonly pull?: PullDemand;
     /**
      * Deferred SELF-rewire (R-rewire-deferred / D47) — the substrate affordance higher-order
      * operators (switchMap/mergeMap/concatMap/exhaustMap/flatMap) use to grow/shrink their own
@@ -699,8 +699,8 @@ interface Ctx {
      * Deferred up — the boundary-deferred form of {@link Ctx.up} (R-up-routing / R-pull / D59). Routes
      * `msgs` up from this node at the COMMITTED wave boundary (broadcast, or up the single `towardDep`
      * edge), riding the same R-rewire-deferred (D47) drain as {@link RewireNext}. This is the
-     * SELF-DEMAND path: a consumer issues `ctx.upNext([[RESUME, pullId]])` to demand a pull dep it
-     * ALSO reads — the cone-routed RESUME reaches the pullId-holder, whose delivery loops back as a
+     * SELF-DEMAND path: a consumer issues `ctx.upNext([[PULL, { pullId, params }]])` to demand a pull
+     * dep it ALSO reads — the cone-routed PULL reaches the pullId-holder, whose delivery loops back as a
      * FRESH wave (not a mid-fn re-entry → no D37). The consumer accepts one-wave latency (the
      * HTTP-request model). No node reference needed: the author writes the pullId verbatim.
      */

package/dist/{types-bNMSWKqF.d.cts → types-CcPIn7sy.d.cts}

@@ -1,4 +1,4 @@
-import { L as LockId, W as Wave, M as Message } from './messages-BZqrGGm1.cjs';
+import { L as LockId, W as Wave, P as PullDemand, M as Message } from './messages-CAzUPPJM.cjs';
 
 /**
  * Dispatcher, pools, and the pure-data Handle.
@@ -324,15 +324,16 @@ interface NodeOptions<T = unknown> {
     /** PAUSE/RESUME behavior (R-pause-modes). Default true. */
     pausable?: boolean | "resumeAll";
     /**
-     * Pull-mode node (R-pull / D55,D59): a quiet-until-demanded source, identified by this
+     * Pull-mode node (R-pull / D269): a quiet-until-demanded source, identified by this
      * author-supplied `pullId` (a unique LockId — a `Symbol` recommended; NOT the node name, NOT a
-     * bare string which collides with a same-string pause lock). The node self-holds the pullId as
-     * its demand lock. QUIET by default: it ABSORBS an upstream DIRTY WITHOUT relaying it downstream
-     * (the wedge fix) and does NOT push-on-subscribe its cached value (START only). A DEMAND = a
-     * cone-routed `RESUME` of this pullId (R-up-routing — NO new message type): a downstream consumer
-     * issues `ctx.up([[RESUME, pullId]])` (broadcast up the declared cone) or `ctx.up(msgs, towardDep)`
-     * (directed) WITHOUT holding this node's reference; the RESUME travels up to the pullId-holder,
-     * which fires EXACTLY ONE delivery (DIRTY-before-DATA) then RE-QUIETS (1:1). Delivery content =
+     * bare string if callers may also use strings as pause locks). QUIET by default: it ABSORBS
+     * an upstream DIRTY WITHOUT relaying it downstream
+     * (the wedge fix) and does NOT push-on-subscribe its cached value (START only). A DEMAND =
+     * cone-routed `PULL({pullId, params?})`: a downstream consumer issues
+     * `ctx.up([["PULL", { pullId, params }]])` (broadcast up the declared cone) or
+     * `ctx.up(msgs, towardDep)` (directed) WITHOUT holding this node's reference; the PULL travels
+     * up to the pullId-holder, which fires EXACTLY ONE delivery (DIRTY-before-DATA when it emits)
+     * then RE-QUIETS (1:1). Delivery content =
      * the orthogonal `pausable` mode: `true` → coalesced LATEST (one DATA); `'resumeAll'` → buffered
      * BACKLOG. `pullId` + `pausable:false` is REJECTED at construction. A SELF-triggered demand (a
      * consumer demanding a dep it ALSO reads) must defer via {@link Ctx.upNext} (R-rewire-deferred /
@@ -381,15 +382,14 @@ declare class Node<T = unknown> {
     private get _syncCtx();
     private set _syncCtx(value);
     constructor(deps: Node<unknown>[], handleOrFn: Handle | NodeFn | null, opts?: NodeOptions<T>);
-    /** 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. */
     private _isPullQuiet;
     /**
-     * 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(): LockId | undefined;
     get cache(): T | undefined;
@@ -428,10 +428,10 @@ declare class Node<T = unknown> {
      */
     private _requestRewireNext;
     /**
-     * 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.
      */
@@ -517,7 +517,7 @@ declare class Node<T = unknown> {
      * 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.
      */
@@ -529,19 +529,17 @@ declare class Node<T = unknown> {
     private _pauseRelease;
     private _onResume;
     /**
-     * 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.
      */
     private _canFireDemand;
     /**
-     * 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).
      */
     private _deliverPullDemand;
     /**
-     * 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).
@@ -559,7 +557,7 @@ declare class Node<T = unknown> {
      */
     private _firePullDemand;
     /**
-     * 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).
      */
@@ -667,8 +665,8 @@ interface Ctx {
     /**
      * Emit upstream toward deps — control tiers only (R-ctx-up). IMMEDIATE. `towardDep` (a dep index)
      * routes the wave up ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
-     * A pull DEMAND is `up([[RESUME, pullId]])` — but for a SELF-demand (demanding a dep this fn also
-     * reads) use {@link Ctx.upNext} instead, since an immediate demand whose delivery loops back
+     * A pull DEMAND is `up([[PULL, { pullId, params }]])` — but for a SELF-demand (demanding a dep
+     * this fn also reads) use {@link Ctx.upNext} instead, since an immediate demand whose delivery loops back
      * re-enters this fn mid-wave (D37 / R-reentrancy).
      */
     up(msgs: Wave, towardDep?: number): void;
@@ -689,6 +687,8 @@ interface Ctx {
     onInvalidate(fn: () => void): void;
     /** Graph-owned environment drivers for source/adapter boundaries (D130/D131). */
     environment(): EnvironmentDrivers;
+    /** Holder-visible context for a PULL-caused invocation (D272); absent for ordinary waves. */
+    readonly pull?: PullDemand;
     /**
      * Deferred SELF-rewire (R-rewire-deferred / D47) — the substrate affordance higher-order
      * operators (switchMap/mergeMap/concatMap/exhaustMap/flatMap) use to grow/shrink their own
@@ -699,8 +699,8 @@ interface Ctx {
      * Deferred up — the boundary-deferred form of {@link Ctx.up} (R-up-routing / R-pull / D59). Routes
      * `msgs` up from this node at the COMMITTED wave boundary (broadcast, or up the single `towardDep`
      * edge), riding the same R-rewire-deferred (D47) drain as {@link RewireNext}. This is the
-     * SELF-DEMAND path: a consumer issues `ctx.upNext([[RESUME, pullId]])` to demand a pull dep it
-     * ALSO reads — the cone-routed RESUME reaches the pullId-holder, whose delivery loops back as a
+     * SELF-DEMAND path: a consumer issues `ctx.upNext([[PULL, { pullId, params }]])` to demand a pull
+     * dep it ALSO reads — the cone-routed PULL reaches the pullId-holder, whose delivery loops back as a
      * FRESH wave (not a mid-fn re-entry → no D37). The consumer accepts one-wave latency (the
      * HTTP-request model). No node reference needed: the author writes the pullId verbatim.
      */

package/dist/work-item-runtime-C3M79vE9.d.ts

@@ -0,0 +1,228 @@
+import { DataIssue } from './data/index.js';
+import { d as Graph } from './graph-D-1-SQeC.js';
+import { N as Node } from './types-BsJvElYZ.js';
+import { S as SourceRef, v as AgentRuntimeAuditRecord, H as EffectRunResultStatus, z as EffectRunGoal, B as EffectRunLimits, w as EffectRun, h as AgentOutputEnvelope, g as AgentNeed, F as EffectRunResult } from './agent-runtime-BesGDZcB.js';
+
+interface WorkItemSeed {
+    readonly kind: "work-item";
+    readonly workItemId: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly workItemKind?: string;
+    readonly summary?: string;
+    readonly detailRef?: string;
+    readonly lifecycleStatus?: string;
+    readonly issues?: readonly DataIssue[];
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemEffectRequested<TInput = unknown> {
+    readonly kind: "work-item-effect-requested";
+    readonly requestId: string;
+    readonly workItemId: string;
+    readonly effectRunId: string;
+    readonly effectKind: string;
+    readonly executionInputRevision?: number;
+    readonly planId?: string;
+    readonly planMemberId?: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly goal: EffectRunGoal<TInput>;
+    readonly agentRunId?: string;
+    readonly policyRefs?: readonly SourceRef[];
+    readonly limits?: EffectRunLimits;
+    readonly createdBy?: string;
+    readonly createdAtMs?: number;
+    readonly idempotencyKey?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemEvidenceRecorded {
+    readonly kind: "work-item-evidence-recorded";
+    readonly evidenceId: string;
+    readonly workItemId: string;
+    readonly requestId?: string;
+    readonly effectRunId: string;
+    readonly effectRunResultId: string;
+    readonly executionInputRevision?: number;
+    readonly planId?: string;
+    readonly planMemberId?: string;
+    readonly status: EffectRunResultStatus;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly output?: AgentOutputEnvelope;
+    readonly error?: DataIssue;
+    readonly needs?: readonly AgentNeed[];
+    readonly reason?: string;
+    readonly timeoutMs?: number;
+    readonly issues?: readonly DataIssue[];
+    readonly auditRefs?: readonly string[];
+    readonly recordedAtMs?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+type WorkItemDomainActionProposalPayloadFrom = "evidence" | "effect-run-result" | "output";
+interface WorkItemDomainActionProposalSpec<TPayload = unknown> {
+    readonly actionKind: string;
+    readonly behavior?: "propose";
+    readonly statuses?: readonly EffectRunResultStatus[];
+    readonly outputKinds?: readonly string[];
+    readonly payloadFrom?: WorkItemDomainActionProposalPayloadFrom;
+    readonly payload?: TPayload;
+    readonly reason?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemDomainActionProposal<TPayload = unknown> {
+    readonly kind: "work-item-domain-action-proposal";
+    readonly proposalId: string;
+    readonly workItemId: string;
+    readonly actionKind: string;
+    readonly effectRunId: string;
+    readonly effectRunResultId: string;
+    readonly evidenceId: string;
+    readonly policyId: string;
+    readonly payload?: TPayload;
+    readonly reason?: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly proposedAtMs?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+type WorkItemDomainActionAdmissionOutcome = "admit" | "reject" | "defer" | "merge";
+type WorkItemDomainActionAdmissionState = "admitted" | "rejected" | "deferred" | "merged";
+interface WorkItemDomainActionAdmissionPolicy {
+    readonly kind: "work-item-domain-action-admission-policy";
+    readonly policyId: string;
+    readonly actionKinds?: readonly string[];
+    readonly allowedOutcomes?: readonly WorkItemDomainActionAdmissionOutcome[];
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemDomainActionAdmissionDecision {
+    readonly kind: "work-item-domain-action-admission-decision";
+    readonly decisionId: string;
+    readonly admissionId: string;
+    readonly proposalId: string;
+    readonly outcome: WorkItemDomainActionAdmissionOutcome;
+    readonly policyId?: string;
+    readonly reason?: string;
+    readonly targetProposalId?: string;
+    readonly targetAdmissionId?: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly decidedAtMs?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemDomainActionAdmission {
+    readonly kind: "work-item-domain-action-admission";
+    readonly admissionId: string;
+    readonly proposalId: string;
+    readonly workItemId: string;
+    readonly actionKind: string;
+    readonly state: WorkItemDomainActionAdmissionState;
+    readonly decisionId: string;
+    readonly policyId?: string;
+    readonly reason?: string;
+    readonly targetProposalId?: string;
+    readonly targetAdmissionId?: string;
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly admittedAtMs?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemEffectMappingPolicy {
+    readonly kind: "work-item-effect-mapping-policy";
+    readonly policyId: string;
+    readonly effectKinds?: readonly string[];
+    readonly evidence?: {
+        readonly behavior?: "record";
+    };
+    readonly actionProposals?: readonly WorkItemDomainActionProposalSpec[];
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemStatusRecord {
+    readonly kind: "work-item-status";
+    readonly statusId: string;
+    readonly workItemId: string;
+    readonly state: "effect-request-pending" | "effect-run-seeded" | "evidence-recorded" | "domain-action-proposed" | "domain-action-admitted" | "domain-action-rejected" | "domain-action-deferred" | "domain-action-merged" | "mapping-issue";
+    readonly sourceRefs?: readonly SourceRef[];
+    readonly effectRunId?: string;
+    readonly requestId?: string;
+    readonly evidenceId?: string;
+    readonly proposalId?: string;
+    readonly issues?: readonly DataIssue[];
+    readonly metadata?: Record<string, unknown>;
+}
+interface WorkItemEffectRequestViews {
+    readonly pendingEffectRequests: readonly WorkItemEffectRequested[];
+    readonly issues: readonly DataIssue[];
+    readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+interface WorkItemEvidenceViews {
+    readonly evidenceByWorkItem: ReadonlyMap<string, readonly WorkItemEvidenceRecorded[]>;
+    readonly latestEvidenceByEffectRun: ReadonlyMap<string, WorkItemEvidenceRecorded>;
+    readonly issues: readonly DataIssue[];
+    readonly audit: readonly AgentRuntimeAuditRecord[];
+    readonly pendingEffectRequests: readonly WorkItemEffectRequested[];
+}
+interface WorkItemDomainActionProposalViews {
+    readonly proposalsByWorkItem: ReadonlyMap<string, readonly WorkItemDomainActionProposal[]>;
+    readonly proposalsByEvidence: ReadonlyMap<string, readonly WorkItemDomainActionProposal[]>;
+    readonly issues: readonly DataIssue[];
+    readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+interface WorkItemDomainActionAdmissionViews {
+    readonly admissionsByProposal: ReadonlyMap<string, WorkItemDomainActionAdmission>;
+    readonly admissionsByWorkItem: ReadonlyMap<string, readonly WorkItemDomainActionAdmission[]>;
+    readonly issues: readonly DataIssue[];
+    readonly audit: readonly AgentRuntimeAuditRecord[];
+}
+interface WorkItemEffectRunBundle {
+    readonly effectRuns: Node<EffectRun>;
+    readonly status: Node<WorkItemStatusRecord>;
+    readonly issues: Node<DataIssue>;
+    readonly audit: Node<AgentRuntimeAuditRecord>;
+    readonly views: Node<WorkItemEffectRequestViews>;
+}
+interface WorkItemEvidenceMapperBundle {
+    readonly evidence: Node<WorkItemEvidenceRecorded>;
+    readonly status: Node<WorkItemStatusRecord>;
+    readonly issues: Node<DataIssue>;
+    readonly audit: Node<AgentRuntimeAuditRecord>;
+    readonly views: Node<WorkItemEvidenceViews>;
+}
+interface WorkItemDomainActionProposalBundle {
+    readonly proposals: Node<WorkItemDomainActionProposal>;
+    readonly status: Node<WorkItemStatusRecord>;
+    readonly issues: Node<DataIssue>;
+    readonly audit: Node<AgentRuntimeAuditRecord>;
+    readonly views: Node<WorkItemDomainActionProposalViews>;
+}
+interface WorkItemDomainActionAdmissionBundle {
+    readonly admissions: Node<WorkItemDomainActionAdmission>;
+    readonly status: Node<WorkItemStatusRecord>;
+    readonly issues: Node<DataIssue>;
+    readonly audit: Node<AgentRuntimeAuditRecord>;
+    readonly views: Node<WorkItemDomainActionAdmissionViews>;
+}
+declare function workItemEffectRunProjector(graph: Graph, opts: {
+    readonly name?: string;
+    readonly workItems: Node<WorkItemSeed>;
+    readonly effectRequests: Node<WorkItemEffectRequested>;
+}): WorkItemEffectRunBundle;
+declare function workItemEffectResultMapper(graph: Graph, opts: {
+    readonly name?: string;
+    readonly workItems: Node<WorkItemSeed>;
+    readonly effectRuns: Node<EffectRun>;
+    readonly effectRunResults: Node<EffectRunResult>;
+    readonly effectRequests?: Node<WorkItemEffectRequested>;
+    readonly mappingPolicies?: readonly Node<WorkItemEffectMappingPolicy>[];
+    readonly now?: () => number;
+}): WorkItemEvidenceMapperBundle;
+declare function workItemDomainActionProposalProjector(graph: Graph, opts: {
+    readonly name?: string;
+    readonly workItems: Node<WorkItemSeed>;
+    readonly evidence: Node<WorkItemEvidenceRecorded>;
+    readonly effectRunResults: Node<EffectRunResult>;
+    readonly mappingPolicies: readonly Node<WorkItemEffectMappingPolicy>[];
+    readonly now?: () => number;
+}): WorkItemDomainActionProposalBundle;
+declare function workItemDomainActionAdmissionProjector(graph: Graph, opts: {
+    readonly name?: string;
+    readonly proposals: Node<WorkItemDomainActionProposal>;
+    readonly decisions: Node<WorkItemDomainActionAdmissionDecision>;
+    readonly admissionPolicies?: readonly Node<WorkItemDomainActionAdmissionPolicy>[];
+    readonly now?: () => number;
+}): WorkItemDomainActionAdmissionBundle;
+
+export { type WorkItemDomainActionAdmission as W, type WorkItemDomainActionAdmissionBundle as a, type WorkItemDomainActionAdmissionDecision as b, type WorkItemDomainActionAdmissionOutcome as c, type WorkItemDomainActionAdmissionPolicy as d, type WorkItemDomainActionAdmissionState as e, type WorkItemDomainActionAdmissionViews as f, type WorkItemDomainActionProposal as g, type WorkItemDomainActionProposalBundle as h, type WorkItemDomainActionProposalPayloadFrom as i, type WorkItemDomainActionProposalSpec as j, type WorkItemDomainActionProposalViews as k, type WorkItemEffectMappingPolicy as l, type WorkItemEffectRequestViews as m, type WorkItemEffectRequested as n, type WorkItemEffectRunBundle as o, type WorkItemEvidenceMapperBundle as p, type WorkItemEvidenceRecorded as q, type WorkItemEvidenceViews as r, type WorkItemSeed as s, type WorkItemStatusRecord as t, workItemDomainActionProposalProjector as u, workItemEffectResultMapper as v, workItemDomainActionAdmissionProjector as w, workItemEffectRunProjector as x };