@graphrefly/graphrefly 0.47.2 → 0.48.0

package/dist/presets/harness/index.d.cts

@@ -3,8 +3,8 @@ import { ReactiveLogBundle, OwnershipChange, NodeInput } from '@graphrefly/pure-
 import { Graph, GraphProfileResult, GraphProfileOptions } from '@graphrefly/pure-ts/graph';
 import { R as RenderedEntry, b as ContextEntry, c as ContextView, e as TaggedContextPoolBundle } from '../../index-DLAxYaN5.cjs';
 import { b as ExecuteOutput, p as TriagedItem, V as VerifyOutput, g as HarnessVerifier, H as HarnessExecutor, k as QueueRoute } from '../../types-vCq7ShIm.cjs';
-import { f as Evaluator, D as DatasetItem, d as EvalResult, i as RefineStrategy, g as RefineLoopOptions, H as HarnessGraph, h as RefineStatus } from '../../spawnable-5mDY501F.cjs';
-export { A as AnalyzeEvent, B as BlindVariationContext, a as BlindVariationOptions, C as ConvergenceOptions, b as DecideEvent, E as ErrorCritiqueContext, c as ErrorCritiqueOptions, e as EvaluateEvent, F as Feedback, G as GenerateEvent, I as Iteration, R as RefineLoopGraph, S as SpawnPayload, j as SpawnRejection, k as SpawnableBundle, l as SpawnableGraph, m as SpawnableOpts, n as blindVariation, o as defaultLlmExecutor, p as defaultLlmVerifier, q as errorCritique, r as harnessLoop, s as refineLoop, t as spawnable } from '../../spawnable-5mDY501F.cjs';
+import { f as Evaluator, D as DatasetItem, d as EvalResult, i as RefineStrategy, g as RefineLoopOptions, H as HarnessGraph, h as RefineStatus } from '../../spawnable-B2IlW60f.cjs';
+export { A as AnalyzeEvent, B as BlindVariationContext, a as BlindVariationOptions, C as ConvergenceOptions, b as DecideEvent, E as ErrorCritiqueContext, c as ErrorCritiqueOptions, e as EvaluateEvent, F as Feedback, G as GenerateEvent, I as Iteration, R as RefineLoopGraph, S as SpawnPayload, j as SpawnRejection, k as SpawnableBundle, l as SpawnableGraph, m as SpawnableOpts, n as blindVariation, o as defaultLlmExecutor, p as defaultLlmVerifier, q as errorCritique, r as harnessLoop, s as refineLoop, t as spawnable } from '../../spawnable-B2IlW60f.cjs';
 import { TopicGraph } from '../../utils/messaging/index.cjs';
 import '../../types-BB5Lw-pB.cjs';
 import '../../utils/job-queue/index.cjs';
@@ -73,7 +73,12 @@ interface ActorHandle<T> {
 }
 interface ActorPoolOptions<T> {
     readonly name?: string;
-    /** Max recursion depth; `attachActor` with `depth > depthCap` throws. */
+    /**
+     * Max recursion depth; `attachActor` with `depth > depthCap` throws.
+     * Default: `8` (F-ACTOR, 2026-05-18 smell sweep — a finite default bounds
+     * runaway recursive fan-out; previously silently `Infinity`). Pass an
+     * explicit `Number.POSITIVE_INFINITY` to opt in to unbounded recursion.
+     */
     readonly depthCap?: number;
     /** Forwarded to the backing context pool. */
     readonly contextTopic?: string;
@@ -444,8 +449,13 @@ declare function harnessProfile(harness: HarnessGraph, opts?: GraphProfileOption
 
 /** Terminal-run snapshot passed to a custom `toOutput` mapper. */
 interface RefineExecutorResult<T> {
-    /** Best candidate the inner loop converged on. `null` if no candidates were scored. */
-    readonly best: T | null;
+    /**
+     * Best candidate the inner loop converged on. `undefined` (SENTINEL) if the
+     * inner loop never produced a best — e.g. it `errored` before any iteration
+     * settled. (`loop.best` is a SENTINEL `Node<T>` post the 2026-05-18
+     * anti-pattern sweep — no `null` placeholder.)
+     */
+    readonly best: T | undefined;
     /** Aggregate score at termination. `-Infinity` if the batch was empty. */
     readonly score: number;
     /** Reason the loop terminated. */

package/dist/presets/harness/index.d.ts

@@ -3,8 +3,8 @@ import { ReactiveLogBundle, OwnershipChange, NodeInput } from '@graphrefly/pure-
 import { Graph, GraphProfileResult, GraphProfileOptions } from '@graphrefly/pure-ts/graph';
 import { R as RenderedEntry, b as ContextEntry, c as ContextView, e as TaggedContextPoolBundle } from '../../index-DLAxYaN5.js';
 import { b as ExecuteOutput, p as TriagedItem, V as VerifyOutput, g as HarnessVerifier, H as HarnessExecutor, k as QueueRoute } from '../../types-CJWIMJiZ.js';
-import { f as Evaluator, D as DatasetItem, d as EvalResult, i as RefineStrategy, g as RefineLoopOptions, H as HarnessGraph, h as RefineStatus } from '../../spawnable-D3lR0oQu.js';
-export { A as AnalyzeEvent, B as BlindVariationContext, a as BlindVariationOptions, C as ConvergenceOptions, b as DecideEvent, E as ErrorCritiqueContext, c as ErrorCritiqueOptions, e as EvaluateEvent, F as Feedback, G as GenerateEvent, I as Iteration, R as RefineLoopGraph, S as SpawnPayload, j as SpawnRejection, k as SpawnableBundle, l as SpawnableGraph, m as SpawnableOpts, n as blindVariation, o as defaultLlmExecutor, p as defaultLlmVerifier, q as errorCritique, r as harnessLoop, s as refineLoop, t as spawnable } from '../../spawnable-D3lR0oQu.js';
+import { f as Evaluator, D as DatasetItem, d as EvalResult, i as RefineStrategy, g as RefineLoopOptions, H as HarnessGraph, h as RefineStatus } from '../../spawnable-tttFz2Nh.js';
+export { A as AnalyzeEvent, B as BlindVariationContext, a as BlindVariationOptions, C as ConvergenceOptions, b as DecideEvent, E as ErrorCritiqueContext, c as ErrorCritiqueOptions, e as EvaluateEvent, F as Feedback, G as GenerateEvent, I as Iteration, R as RefineLoopGraph, S as SpawnPayload, j as SpawnRejection, k as SpawnableBundle, l as SpawnableGraph, m as SpawnableOpts, n as blindVariation, o as defaultLlmExecutor, p as defaultLlmVerifier, q as errorCritique, r as harnessLoop, s as refineLoop, t as spawnable } from '../../spawnable-tttFz2Nh.js';
 import { TopicGraph } from '../../utils/messaging/index.js';
 import '../../types-BB5Lw-pB.js';
 import '../../utils/job-queue/index.js';
@@ -73,7 +73,12 @@ interface ActorHandle<T> {
 }
 interface ActorPoolOptions<T> {
     readonly name?: string;
-    /** Max recursion depth; `attachActor` with `depth > depthCap` throws. */
+    /**
+     * Max recursion depth; `attachActor` with `depth > depthCap` throws.
+     * Default: `8` (F-ACTOR, 2026-05-18 smell sweep — a finite default bounds
+     * runaway recursive fan-out; previously silently `Infinity`). Pass an
+     * explicit `Number.POSITIVE_INFINITY` to opt in to unbounded recursion.
+     */
     readonly depthCap?: number;
     /** Forwarded to the backing context pool. */
     readonly contextTopic?: string;
@@ -444,8 +449,13 @@ declare function harnessProfile(harness: HarnessGraph, opts?: GraphProfileOption
 
 /** Terminal-run snapshot passed to a custom `toOutput` mapper. */
 interface RefineExecutorResult<T> {
-    /** Best candidate the inner loop converged on. `null` if no candidates were scored. */
-    readonly best: T | null;
+    /**
+     * Best candidate the inner loop converged on. `undefined` (SENTINEL) if the
+     * inner loop never produced a best — e.g. it `errored` before any iteration
+     * settled. (`loop.best` is a SENTINEL `Node<T>` post the 2026-05-18
+     * anti-pattern sweep — no `null` placeholder.)
+     */
+    readonly best: T | undefined;
     /** Aggregate score at termination. `-Infinity` if the batch was empty. */
     readonly score: number;
     /** Reason the loop terminated. */

package/dist/presets/harness/index.js

@@ -7,8 +7,8 @@ import {
   harnessTrace,
   ownershipController,
   refineExecutor
-} from "../../chunk-VNXAF2KE.js";
-import "../../chunk-VP3TIUDF.js";
+} from "../../chunk-TPTZZV25.js";
+import "../../chunk-DVTDF5OI.js";
 import {
   HarnessGraph,
   RefineLoopGraph,
@@ -20,33 +20,33 @@ import {
   harnessLoop,
   refineLoop,
   spawnable
-} from "../../chunk-PTWADEH3.js";
-import "../../chunk-FQSQONOU.js";
+} from "../../chunk-YBJVKMTM.js";
+import "../../chunk-65OM4XLQ.js";
 import "../../chunk-OIWU3NYV.js";
-import "../../chunk-PKPO3JTZ.js";
-import "../../chunk-KRFGO5QH.js";
-import "../../chunk-6MRSX3YK.js";
-import "../../chunk-DDTS7F5O.js";
-import "../../chunk-EP4WVQLX.js";
-import "../../chunk-T7SP3EYR.js";
+import "../../chunk-AQAKDE7F.js";
+import "../../chunk-MQMTRKY3.js";
+import "../../chunk-B5Y5GPD5.js";
+import "../../chunk-LTSI7ULC.js";
+import "../../chunk-ZW32BPXV.js";
+import "../../chunk-T2U6N3FV.js";
+import "../../chunk-T5URUIIY.js";
 import "../../chunk-GUNIRPEJ.js";
-import "../../chunk-N65E26UL.js";
-import "../../chunk-QFE5BQH7.js";
-import "../../chunk-MS3WPRJR.js";
-import "../../chunk-7AVQIGF6.js";
-import "../../chunk-NPRP3MCV.js";
-import "../../chunk-QMBYUVRL.js";
-import "../../chunk-FMPF42Q4.js";
-import "../../chunk-BXGZFGZ4.js";
-import "../../chunk-IOJDYUA7.js";
-import "../../chunk-OXD5LFQP.js";
-import "../../chunk-5GVURVIG.js";
-import "../../chunk-N6MNJNHB.js";
+import "../../chunk-XEWV254I.js";
+import "../../chunk-3REMCHSS.js";
+import "../../chunk-K4ZYJ4EM.js";
+import "../../chunk-DHDCOOJU.js";
 import "../../chunk-F7EKHR32.js";
 import "../../chunk-JA67ZQG2.js";
 import "../../chunk-KUFXLAEY.js";
 import "../../chunk-TSBFTJKM.js";
 import "../../chunk-P5LBT622.js";
+import "../../chunk-QMBYUVRL.js";
+import "../../chunk-FMPF42Q4.js";
+import "../../chunk-C5QD5DQX.js";
+import "../../chunk-V46JWFGV.js";
+import "../../chunk-G7H6PN7P.js";
+import "../../chunk-MMHGYX44.js";
+import "../../chunk-N6MNJNHB.js";
 import "../../chunk-AZDQPQ3V.js";
 export {
   HarnessGraph,

package/dist/presets/index.cjs

@@ -559,6 +559,26 @@ function createAuditLog(opts) {
   }
   return log;
 }
+function readonlyAuditLog(log) {
+  return Object.freeze({
+    get entries() {
+      return log.entries;
+    },
+    get size() {
+      return log.size;
+    },
+    get lastValue() {
+      return log.lastValue;
+    },
+    get mutationLog() {
+      return log.mutationLog;
+    },
+    at: log.at.bind(log),
+    withLatest: log.withLatest.bind(log),
+    view: log.view.bind(log),
+    scan: log.scan.bind(log)
+  });
+}
 function deepFreeze(value) {
   if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
   for (const k of Object.keys(value)) {
@@ -2027,6 +2047,11 @@ var AgentLoopGraph = class extends import_graph5.Graph {
           chat.append("assistant", response.content, {
             toolCalls: response.toolCalls
           });
+          if (capReached && hasToolCalls) {
+            for (const tc of response.toolCalls) {
+              chat.appendToolResult(tc.id, "[tool call denied: maxTurns reached]");
+            }
+          }
         });
       },
       { describeKind: "effect" }
@@ -2048,6 +2073,45 @@ var AgentLoopGraph = class extends import_graph5.Graph {
       },
       { describeKind: "effect" }
     );
+    const effFullDeny = gatedToolCallsNode !== toolCallsRaw ? (0, import_core11.node)(
+      [toolCallsRaw, gatedToolCallsNode],
+      (batchData) => {
+        if (latestAborted) return;
+        const rawBatch = batchData[0];
+        const gatedBatch = batchData[1];
+        const rawCalls = rawBatch != null && rawBatch.length > 0 ? rawBatch.at(-1) : null;
+        if (rawCalls == null || rawCalls.length === 0) return;
+        const gatedCalls = gatedBatch != null && gatedBatch.length > 0 ? gatedBatch.at(-1) : null;
+        const allowedIds = gatedCalls === null ? null : new Set(gatedCalls.map((c) => c.id));
+        const denied = allowedIds === null ? rawCalls : rawCalls.filter((c) => !allowedIds.has(c.id));
+        if (denied.length === 0) return;
+        const isFullDeny = gatedCalls === null;
+        (0, import_core11.batch)(() => {
+          if (isFullDeny) {
+            statusNode.emit(latestTurn >= maxTurns ? "done" : "thinking");
+          }
+          for (const c of denied)
+            chat.appendToolResult(c.id, "[tool call denied by interceptor]");
+        });
+      },
+      {
+        name: "fullDenyRecovery",
+        describeKind: "effect",
+        meta: aiMeta("agent_full_deny_recovery"),
+        // MUST be explicit: the core `node()` default is
+        // `partial: false` (node.ts `opts.partial ?? false`),
+        // and `gatedToolCallsNode` only ever emits RESOLVED on the
+        // full-deny path (never DATA/terminal). Spec R2.7.0
+        // (DS-2.7.A, 2026-05-19) holds the `partial: false`
+        // first-run gate until every dep has contributed real
+        // DATA, so a `partial: false` effFullDeny would hold the
+        // fn FOREVER. Spec R2.7.2 = `partial: true` disables the
+        // gate; the fn body's `denied`-subtraction guard above
+        // covers the SENTINEL slot per the R2.7.2 author
+        // contract.
+        partial: true
+      }
+    ) : null;
     let latestStatus = statusNode.cache ?? "idle";
     const statusSub = statusNode.subscribe((msgs) => {
       for (const m of msgs) if (m[0] === import_core11.DATA) latestStatus = m[1];
@@ -2067,6 +2131,7 @@ var AgentLoopGraph = class extends import_graph5.Graph {
     );
     const kaResponse = (0, import_extra7.keepalive)(effResponse);
     const kaResults = (0, import_extra7.keepalive)(effResults);
+    const kaFullDeny = effFullDeny ? (0, import_extra7.keepalive)(effFullDeny) : null;
     const kaAbort = (0, import_extra7.keepalive)(effAbort);
     this._terminalResult = (0, import_core11.node)(
       [statusNode, lastResponseState],
@@ -2119,6 +2184,7 @@ var AgentLoopGraph = class extends import_graph5.Graph {
     this.addDisposer(statusSub);
     this.addDisposer(kaResponse);
     this.addDisposer(kaResults);
+    if (kaFullDeny) this.addDisposer(kaFullDeny);
     this.addDisposer(kaAbort);
     this._disposeRunWiring = () => {
     };
@@ -4768,7 +4834,7 @@ function actorPool(parent, opts = {}) {
   const name = opts.name ?? `actorPool-${++_actorPoolSeq}`;
   const graph = new import_graph12.Graph(name);
   parent.mount(name, graph);
-  const depthCap = opts.depthCap ?? Number.POSITIVE_INFINITY;
+  const depthCap = opts.depthCap ?? 8;
   let autoActor = 0;
   const liveHandles = /* @__PURE__ */ new Set();
   const contextPool = taggedContextPool(graph, {
@@ -4872,6 +4938,16 @@ var import_core23 = require("@graphrefly/pure-ts/core");
 var import_extra20 = require("@graphrefly/pure-ts/extra");
 var import_graph13 = require("@graphrefly/pure-ts/graph");
 var RefineLoopGraph = class extends import_graph13.Graph {
+  /**
+   * Best candidate so far. **SENTINEL until the first iteration settles** —
+   * `loop.best.cache` is `undefined` (not `null`) before any iteration
+   * produces a best, and a degenerate empty-candidate iteration leaves the
+   * prior best in place rather than wiping it. Consumers guard with
+   * `=== undefined` (spec §3 SENTINEL), not `== null`. (Anti-pattern sweep
+   * 2026-05-18: dropped the `initial: null` eager-placeholder; `null` is
+   * reserved for the per-iteration {@link Iteration.best} data field where an
+   * empty batch is a valid domain value.)
+   */
   best;
   /**
    * Best score so far. Pseudo-private (`_score`) to avoid colliding with any
@@ -4922,8 +4998,7 @@ var RefineLoopGraph = class extends import_graph13.Graph {
     });
     this.add(strategyNode, { name: "strategy" });
     const lastFeedbackState = (0, import_core23.node)([], {
-      name: "lastFeedback",
-      initial: null
+      name: "lastFeedback"
     });
     this.add(lastFeedbackState, { name: "lastFeedback" });
     const prevCandidatesState = (0, import_core23.node)([], {
@@ -4942,7 +5017,7 @@ var RefineLoopGraph = class extends import_graph13.Graph {
       // append-style; reactive consumers want every push
     });
     this.add(historyState, { name: "history" });
-    const bestState = (0, import_core23.node)([], { name: "best", initial: null });
+    const bestState = (0, import_core23.node)([], { name: "best" });
     this.add(bestState, { name: "best" });
     const scoreState = (0, import_core23.node)([], { name: "score", initial: Number.NEGATIVE_INFINITY });
     this.add(scoreState, { name: "score" });
@@ -4966,7 +5041,7 @@ var RefineLoopGraph = class extends import_graph13.Graph {
     this.decide = hubDecideTopic;
     this._pauseState = pauseState;
     let latestStrategy = initialStrategy;
-    let latestFeedback = null;
+    let latestFeedback;
     let latestPrevCandidates = [];
     this.addDisposer(
       strategyNode.subscribe((msgs) => {
@@ -4987,7 +5062,7 @@ var RefineLoopGraph = class extends import_graph13.Graph {
       iterationTrigger,
       (iter) => {
         const strat = latestStrategy;
-        const isSeed = iter === 0 || latestFeedback == null;
+        const isSeed = iter === 0 || latestFeedback === void 0;
         return (0, import_core23.node)(
           [],
           (_data, actions) => {
@@ -5379,7 +5454,7 @@ var RefineLoopGraph = class extends import_graph13.Graph {
           decision = "paused";
         }
         (0, import_core23.batch)(() => {
-          bestState.emit(best);
+          if (best !== null) bestState.emit(best);
           scoreState.emit(fb.score);
           historyState.emit(nextHistory);
           budgetState.emit(nextBudget);
@@ -5619,7 +5694,7 @@ function errorCritique(opts) {
 function defaultToOutput(result) {
   const { best, score, status } = result;
   const scoreStr = Number.isFinite(score) ? score.toFixed(3) : String(score);
-  const artifact = best ?? void 0;
+  const artifact = best;
   if (status === "converged") {
     return {
       outcome: "success",
@@ -6441,31 +6516,40 @@ var RATE_LIMITER_INITIAL_STATE = Object.freeze({
   pendingCount: 0,
   paused: false
 });
+function validateRateLimiterOpts(o) {
+  if (o.maxEvents <= 0) throw new RangeError("maxEvents must be > 0");
+  if (o.windowNs <= 0) throw new RangeError("windowNs must be > 0");
+  if (o.maxBuffer === void 0) {
+    throw new RangeError(
+      "rateLimiter requires explicit maxBuffer (use Infinity to opt in to unbounded)"
+    );
+  }
+  const isUnbounded = o.maxBuffer === Infinity;
+  if (!isUnbounded && (!Number.isInteger(o.maxBuffer) || o.maxBuffer < 1)) {
+    throw new RangeError("maxBuffer must be a positive integer (or Infinity for unbounded)");
+  }
+}
+function resolveInitialReactiveOpts(optsNode) {
+  const cached = optsNode.cache;
+  if (cached === void 0) {
+    throw new RangeError(
+      "rateLimiter: reactive (Node-form) opts must carry a cached value at construction \u2014 seed the opts Node with `initial`. Mode (bounded vs unbounded) and the initial cap are LOCKED from `.cache` at construction and the swap handler rejects mode toggles; an un-seeded Node would silently lock bounded `maxBuffer: 1` (D4)."
+    );
+  }
+  return cached;
+}
 function rateLimiter(source, opts) {
   const isReactive = isNode(opts);
-  if (!isReactive) {
-    const o = opts;
-    if (o.maxEvents <= 0) throw new RangeError("maxEvents must be > 0");
-    if (o.windowNs <= 0) throw new RangeError("windowNs must be > 0");
-    if (o.maxBuffer === void 0) {
-      throw new RangeError(
-        "rateLimiter requires explicit maxBuffer (use Infinity to opt in to unbounded)"
-      );
-    }
-    const isUnbounded0 = o.maxBuffer === Infinity;
-    if (!isUnbounded0 && (!Number.isInteger(o.maxBuffer) || o.maxBuffer < 1)) {
-      throw new RangeError("maxBuffer must be a positive integer (or Infinity for unbounded)");
-    }
-  }
-  const initialOpts = isReactive ? opts.cache : opts;
-  const initialMaxBuffer = initialOpts?.maxBuffer;
+  const initialOpts = isReactive ? resolveInitialReactiveOpts(opts) : opts;
+  validateRateLimiterOpts(initialOpts);
+  const initialMaxBuffer = initialOpts.maxBuffer;
   const isUnbounded = initialMaxBuffer === Infinity;
   const out = (0, import_core30.node)(
     (_data, a) => {
-      let maxEvents = initialOpts?.maxEvents ?? 1;
-      let windowNs = initialOpts?.windowNs ?? NS_PER_SEC;
-      let maxBuffer = initialMaxBuffer ?? 1;
-      let onOverflow = initialOpts?.onOverflow ?? "drop-newest";
+      let maxEvents = initialOpts.maxEvents;
+      let windowNs = initialOpts.windowNs;
+      let maxBuffer = initialMaxBuffer;
+      let onOverflow = initialOpts.onOverflow ?? "drop-newest";
       let refillPerSec = maxEvents * NS_PER_SEC / windowNs;
       let tokenTimeNs = NS_PER_SEC / refillPerSec;
       let bucket = tokenBucket(maxEvents, refillPerSec);
@@ -6836,6 +6920,10 @@ var PipelineGraph = class extends import_graph15.Graph {
       {
         name,
         describeKind: "derived",
+        // Spec §2.7 R2.7.1 (DS-2.7.A). fn must fire on
+        // upstream-COMPLETE/ERROR-only-without-DATA so the
+        // teardown-decision record + downstream terminal forward run.
+        terminalAsRealInput: true,
         meta: meta("approval_gate", opts.meta)
       }
     );
@@ -7053,6 +7141,11 @@ var PipelineGraph = class extends import_graph15.Graph {
         describeKind: "derived",
         completeWhenDepsComplete: opts.completeWhenDepsComplete ?? !(mode === "completed" || mode === "terminal"),
         errorWhenDepsError: !(mode === "errored" || mode === "terminal"),
+        // Spec §2.7 R2.7.1 (DS-2.7.A). `catch` exists to fire on a
+        // source terminal — its whole job is `recover(cause, …)` on a
+        // terminal-only wave. Without this opt-in the gate holds and
+        // the recover branch never runs.
+        terminalAsRealInput: true,
         meta: meta("catch", opts.meta)
       }
     );
@@ -7255,7 +7348,10 @@ var JobQueueGraph = class extends import_graph17.Graph {
   depth;
   /** Audit log of every queue mutation (Audit 2). */
   events;
-  /** Alias for {@link JobQueueGraph.events} — Audit 2 `.audit` duplication. */
+  /**
+   * Read-only view of {@link JobQueueGraph.events} — Audit 2 `.audit`
+   * duplication; M7 (cannot mutate the canonical log via the alias).
+   */
   audit;
   // Tier 8 / COMPOSITION-GUIDE §35: mutate wrappers for the four
   // single-record mutation methods. Assigned in the constructor (NOT via
@@ -7296,7 +7392,7 @@ var JobQueueGraph = class extends import_graph17.Graph {
       retainedLimit: 1024,
       graph: this
     });
-    this.audit = this.events;
+    this.audit = readonlyAuditLog(this.events);
     this._seqCursor = registerCursor(this, "seq", 0);
     this._enqueueImpl = mutate(
       (payload, enqueueOpts) => {
@@ -7349,7 +7445,7 @@ var JobQueueGraph = class extends import_graph17.Graph {
       }
     );
     this._nackImpl = mutate(
-      (id, job, requeue) => {
+      (id, job, requeue, _error) => {
         if (requeue) {
           this._jobs.set(id, { ...job, state: "queued" });
           this._pending.append(id);
@@ -7362,12 +7458,16 @@ var JobQueueGraph = class extends import_graph17.Graph {
         log: this.events,
         seq: this._seqCursor,
         freeze: false,
-        onSuccessRecord: ([id, job], _r, { t_ns, seq }) => ({
+        onSuccessRecord: ([id, job, requeue, error], _r, { t_ns, seq }) => ({
           action: "nack",
           id,
           attempts: job.attempts,
           t_ns,
-          seq: seq ?? 0
+          seq: seq ?? 0,
+          // F-CATCH D-3: surface the failure cause on the no-requeue
+          // (terminal-failure) nack only. A requeue nack is a retry,
+          // not a failure, so it carries no error.
+          ...!requeue && error !== void 0 ? { error } : {}
         })
       }
     );
@@ -7439,10 +7539,20 @@ var JobQueueGraph = class extends import_graph17.Graph {
     this._ackImpl(id, job);
     return true;
   }
+  /**
+   * Negatively-acknowledge an inflight job.
+   *
+   * @param opts.requeue - `true` (default) returns the job to the queue for
+   *   retry; `false` drops it permanently (terminal failure).
+   * @param opts.error - Optional failure cause for a `requeue: false` nack.
+   *   Recorded on the emitted `"nack"` {@link JobEvent} as `error` so the
+   *   reason a job failed is recoverable from the event stream (F-CATCH
+   *   D-3). Ignored when `requeue` is `true` (a retry is not a failure).
+   */
   nack(id, opts = {}) {
     const job = this._jobs.get(id);
     if (!job || job.state !== "inflight") return false;
-    this._nackImpl(id, job, opts.requeue ?? true);
+    this._nackImpl(id, job, opts.requeue ?? true, opts.error);
     return true;
   }
   /**
@@ -7608,10 +7718,10 @@ var JobFlowGraph = class extends import_graph17.Graph {
               let result;
               try {
                 result = workFn(job, { signal: ac.signal });
-              } catch {
+              } catch (err) {
                 inflight.delete(entry);
                 inflightCounter?.emit(inflight.size);
-                current.nack(job.id, { requeue: false });
+                current.nack(job.id, { requeue: false, error: err });
                 processed += 1;
                 continue;
               }
@@ -7662,7 +7772,7 @@ var JobFlowGraph = class extends import_graph17.Graph {
                   } else if (m[0] === import_core33.ERROR) {
                     settled = true;
                     cleanupSub();
-                    current.nack(job.id, { requeue: false });
+                    current.nack(job.id, { requeue: false, error: m[1] });
                     return;
                   }
                 }
@@ -7918,7 +8028,18 @@ var HarnessGraph = class extends import_graph18.Graph {
    * (use {@link unrouted}), and the internal `triage-output` fan-in.
    */
   queueTopics;
-  /** Strategy model — `auditedSuccessTracker` keyed by `StrategyKey`. */
+  /**
+   * Strategy model — `auditedSuccessTracker` keyed by `StrategyKey`.
+   *
+   * **Ownership (EC10/EC15).** Owned by the harness: it is mounted as a
+   * child subgraph (`harness.mount("strategy", strategy)`), so its disposal
+   * cascades from `harness.destroy()` via the mount lifecycle. Do **not**
+   * call `strategy.destroy()` independently — the harness's `triage-input`
+   * node and (when `opts.priority` is set) `buildPriorityScores` hold
+   * cross-graph deps on `strategy.entries`; destroying the strategy out of
+   * band staleness those nodes while the rest of the loop keeps running.
+   * Read/subscribe freely; let the harness own the lifecycle.
+   */
   strategy;
   /** Global retry count across all items (circuit breaker). Reactive — subscribable. */
   totalRetries;
@@ -9218,7 +9339,11 @@ function healthReportEqual(a, b) {
   }
   return true;
 }
-function graphLens(target) {
+function graphLens(target, opts = {}) {
+  const mutLogOpt = opts.mutations;
+  const mutationsEnabled = mutLogOpt != null;
+  const pendingFlowChanges = [];
+  let disposed = false;
   const topologyHandle = target.describe({
     reactive: true,
     detail: "standard",
@@ -9261,17 +9386,26 @@ function graphLens(target) {
           const path = event.path;
           if (path == null || path === "") continue;
           const prior = flowMap.get(path);
+          const count = (prior?.count ?? 0) + 1;
           flowMap.set(path, {
             path,
-            count: (prior?.count ?? 0) + 1,
+            count,
             lastUpdate_ns: c.flushedAt_ns
           });
+          if (mutationsEnabled && !disposed) {
+            pendingFlowChanges.push({ kind: "tick", path, count });
+          }
         }
       }
       if (desc != null && flowMap.size > 0) {
         const valid = new Set(Object.keys(desc.nodes));
         for (const k of [...flowMap.keys()]) {
-          if (!valid.has(k)) flowMap.delete(k);
+          if (!valid.has(k)) {
+            flowMap.delete(k);
+            if (mutationsEnabled && !disposed) {
+              pendingFlowChanges.push({ kind: "evict", path: k });
+            }
+          }
         }
       }
       actions.emit(new Map(flowMap));
@@ -9282,15 +9416,50 @@ function graphLens(target) {
       meta: domainMeta("lens", "flow")
     }
   );
+  let flowMutations;
+  let stopFlowMutKeep;
+  if (mutLogOpt != null) {
+    const log = (0, import_extra30.reactiveLog)(void 0, {
+      name: mutLogOpt === true ? "graphLens.flowMutations" : mutLogOpt.name ?? "graphLens.flowMutations",
+      maxSize: mutLogOpt === true ? void 0 : mutLogOpt.maxSize
+    });
+    flowMutations = log;
+    let mutVersion = 0;
+    const flowMutationsDrain = (0, import_core39.node)(
+      [flow],
+      (_batchData, _actions, _ctx) => {
+        if (pendingFlowChanges.length === 0) return;
+        const drained = pendingFlowChanges.splice(0);
+        for (const change of drained) {
+          log.append({
+            structure: "lensFlow",
+            version: ++mutVersion,
+            t_ns: (0, import_core39.wallClockNs)(),
+            lifecycle: "data",
+            change
+          });
+        }
+      },
+      {
+        name: "graphLens.flowMutationsDrain",
+        describeKind: "effect",
+        meta: domainMeta("lens", "flowMutations")
+      }
+    );
+    stopFlowMutKeep = (0, import_extra30.keepalive)(flowMutationsDrain);
+  }
   const stopFlowKeep = (0, import_extra30.keepalive)(flow);
-  let disposed = false;
   return {
     topology,
     health,
     flow,
+    ...flowMutations ? { flowMutations } : {},
     dispose() {
       if (disposed) return;
       disposed = true;
+      stopFlowMutKeep?.();
+      flowMutations?.dispose();
+      pendingFlowChanges.length = 0;
       stopFlowKeep();
       stopHealthKeep();
       topologyHandle.dispose();
@@ -9509,11 +9678,12 @@ var GuardedExecutionGraph = class extends import_graph26.Graph {
     this.addDisposer((0, import_extra31.keepalive)(this.scope));
     const scopedHandle = target.describe({
       reactive: true,
-      // F8 (Tier 5.2): `_actorNode` is `Node<Actor | null>`. The cast is
-      // safe at runtime per the `resolveActorOption` null-tolerance
-      // contract — `null` / `undefined` cache is treated as "no scoping"
-      // (full visibility). See `scopedDescribeNode` for the matching
-      // per-call site and graph.ts § "Cache-undefined semantics".
+      // F8 (resolved 2026-05-18): `GraphDescribeOptions.actor` is now
+      // `Actor | Node<Actor | null>`, so `_actorNode` (a
+      // `Node<Actor | null>`) passes without a cast. A `null`/`undefined`
+      // cache resolves to "no scoping" (full visibility) per
+      // `resolveActorOption`. See graph.ts § "Cache-undefined/null
+      // semantics".
       actor: this._actorNode,
       reactiveName: "scopedDescribe"
     });
@@ -9559,11 +9729,11 @@ var GuardedExecutionGraph = class extends import_graph26.Graph {
     const actorNode = actorOverride == null ? this._actorNode : isNode4(actorOverride) ? actorOverride : (0, import_core41.node)([], { name: "actor_override", initial: actorOverride });
     const handle = this._target.describe({
       reactive: true,
-      // `_actorNode` is `Node<Actor | null>`. The `as Node<Actor>` cast is
-      // safe at runtime: `_describeReactive` resolves the actor via
-      // `resolveActorOption`, which treats `null`/`undefined` cache as
-      // "no scoping" (full visibility). Documented in graph.ts §
-      // "Cache-undefined semantics."
+      // F8 (resolved 2026-05-18): `actor` accepts `Node<Actor | null>`
+      // directly. `actorNode` is `_actorNode` (`Node<Actor | null>`) or
+      // an override (`Node<Actor>`/`Node<Actor | null>`); both assign
+      // without a cast. `_describeReactive` resolves via
+      // `resolveActorOption` (null/undefined cache → no scoping).
       actor: actorNode,
       ...opts ?? {}
     });
@@ -9664,7 +9834,6 @@ var ResilientPipelineGraph = class extends import_graph27.Graph {
       } else {
         const rateOpts = {
           ...opts.rateLimit,
-          maxBuffer: opts.rateLimit.maxBuffer ?? Infinity,
           meta: domainMeta("resilient", "rate-limit")
         };
         const bundle = rateLimiter(current, rateOpts);