@lloyal-labs/lloyal-agents 1.5.8 → 1.7.0

package/dist/agent-pool.js

@@ -115,6 +115,9 @@ function* recoverInline(agent, policy, ctx, store, tw, parentTraceId, events) {
             agent.branch.pruneSync();
         return false;
     }
+    // Build the nudge prompt — a minimal turn injection that triggers
+    // report behavior. The agent's KV already contains the full
+    // conversation context; the prompt is just a nudge.
     const { prompt } = ctx.formatChatSync(JSON.stringify([
         { role: 'system', content: recovery.prompt.system },
         { role: 'user', content: recovery.prompt.user },
@@ -122,23 +125,14 @@ function* recoverInline(agent, policy, ctx, store, tw, parentTraceId, events) {
     const sep = ctx.getTurnSeparator();
     const delta = ctx.tokenizeSync(prompt, false);
     const tokens = [...sep, ...delta];
-    // Check if extraction prompt fits
-    const pressure = new ContextPressure(ctx);
-    if (pressure.remaining < tokens.length) {
-        if (!agent.branch.disposed)
-            agent.branch.pruneSync();
-        return false;
-    }
-    // Eager report grammar
+    // Eager report grammar — forces { result: string } output
     const reportGrammar = yield* (0, effection_1.call)(() => ctx.jsonSchemaToGrammar(JSON.stringify({
         type: 'object',
         properties: { result: { type: 'string' } },
         required: ['result'],
     })));
-    // Recovery runs in its own scope — if decode fails (KV exhaustion),
-    // the scope tears down cleanly without propagating to the pool.
-    // Mirrors the old prepare()-based recovery which used try/catch around
-    // a Resource with its own ensure().
+    // Recovery runs in its own scope — if prefill or decode fails
+    // (KV exhaustion), the scope tears down cleanly.
     let reported = false;
     try {
         yield* (0, effection_1.scoped)(function* () {
@@ -149,7 +143,6 @@ function* recoverInline(agent, policy, ctx, store, tw, parentTraceId, events) {
                 type: 'branch:prefill', branchHandle: agent.id,
                 tokenCount: tokens.length, role: 'recovery',
             });
-            yield* events.send({ type: 'agent:spawn', agentId: agent.id, parentAgentId: agent.parentId });
             // Single-agent produce/commit loop
             let output = '';
             let tokenCount = 0;
@@ -171,8 +164,8 @@ function* recoverInline(agent, policy, ctx, store, tw, parentTraceId, events) {
             }
         });
     }
-    catch { /* decode failure or malformed JSON — non-fatal, prune below */ }
-    // Always prune after scope exits (success or decode failure)
+    catch { /* prefill overflow, decode failure, or malformed JSON — non-fatal */ }
+    // Always prune after scope exits (success or failure)
     if (!agent.branch.disposed)
         agent.branch.pruneSync();
     // Emit tick so TUI updates pressure percentage after prune
@@ -206,7 +199,7 @@ function* handleNudge(a, message, tc, ctx, tools) {
     const prefillTokens = (0, sdk_2.buildToolResultDelta)(ctx, JSON.stringify(nudgeResult), callId);
     const probe = tools?.get(tc?.name || '')?.probe(nudgeResult) ?? undefined;
     a.resetTurn();
-    return { agentId: a.id, prefillTokens, toolName: tc?.name || '', callId, probe };
+    return { agentId: a.id, prefillTokens, toolName: tc?.name || '', callId, args: tc?.arguments || '', probe };
 }
 function* handleReport(a, result, tc, terminalTool, pruneOnReport, events) {
     a.reportResult(result, 'report_tool');
@@ -322,13 +315,13 @@ function useAgentPool(opts) {
     return (0, effection_1.resource)(function* (provide) {
         const ctx = yield* context_1.Ctx.expect();
         const store = yield* context_1.Store.expect();
-        const events = yield* context_1.Events.expect();
+        const poolChannel = (0, effection_1.createChannel)();
         // Bridge for onProgress callbacks — Signal is correct here (external callback).
-        // A spawned forwarder drains the bridge into the Channel with proper scope context.
+        // A spawned forwarder drains the bridge into the poolChannel with proper scope context.
         const progressBridge = (0, effection_1.createSignal)();
         yield* (0, effection_1.spawn)(function* () {
             for (const ev of yield* (0, effection_1.each)(progressBridge)) {
-                yield* events.send(ev);
+                yield* poolChannel.send(ev);
                 yield* effection_1.each.next();
             }
         });
@@ -421,11 +414,6 @@ function useAgentPool(opts) {
             taskSuffixTokens: prefillSetup.map(([, t]) => t.length),
             pressure: { remaining: initPressure.remaining, softLimit: initPressure.softLimit, headroom: initPressure.headroom },
         });
-        // Emit spawn events and activate agents
-        for (const a of agents) {
-            a.transition('active');
-            yield* events.send({ type: 'agent:spawn', agentId: a.id, parentAgentId: a.parentId });
-        }
         // ── Lazy grammar setup ───────────────────────────────────
         const applyLazyGrammar = (a) => {
             if (a.fmt.grammar && a.fmt.grammarLazy && a.fmt.grammarTriggers.length > 0) {
@@ -444,324 +432,359 @@ function useAgentPool(opts) {
         for (const a of agents)
             applyLazyGrammar(a);
         const agentById = new Map(agents.map(a => [a.id, a]));
-        let steps = 0;
-        let totalToolCalls = 0;
-        const counters = { warmPrefillCalls: 0, warmPrefillBranches: 0 };
-        // ── Phase operations (close over pool scope) ────────────
-        /** SETTLE: prefill tool results that fit, defer oversized items for next tick */
-        function* settle(items) {
-            const settlePressure = new ContextPressure(ctx, pressureOpts);
-            let headroom = settlePressure.headroom;
-            if (trace) {
-                const desc = items.map(s => `${s.toolName}:${s.prefillTokens.length}`).join(', ');
-                try {
-                    process.stderr.write(`[SETTLE] remaining=${settlePressure.remaining} headroom=${headroom} cellsUsed=${settlePressure.cellsUsed} nCtx=${settlePressure.nCtx} items=[${desc}]\n`);
+        // Subscribe BEFORE spawning tick loop — no events missed
+        const subscription = yield* poolChannel;
+        // Spawn tick loop — runs concurrently with Subscription consumption.
+        // scoped() creates an error boundary: if llama_decode fails (KV exhaustion),
+        // the scope tears down and the channel closes with whatever results exist.
+        yield* (0, effection_1.spawn)(function* () {
+            let steps = 0;
+            let totalToolCalls = 0;
+            const counters = { warmPrefillCalls: 0, warmPrefillBranches: 0 };
+            try {
+                // Emit spawn events and activate agents
+                for (const a of agents) {
+                    a.transition('active');
+                    yield* poolChannel.send({ type: 'agent:spawn', agentId: a.id, parentAgentId: a.parentId });
                 }
-                catch { }
-            }
-            const prefillPairs = [];
-            const settledAgents = [];
-            const deferred = [];
-            for (const item of items) {
-                const a = agentById.get(item.agentId);
-                if (!a || a.status === 'idle')
-                    continue;
-                if (item.prefillTokens.length > headroom) {
+                // ── Phase operations (close over pool scope) ────────────
+                /** SETTLE: prefill tool results that fit, defer oversized items for next tick */
+                function* settle(items) {
+                    const settlePressure = new ContextPressure(ctx, pressureOpts);
+                    let headroom = settlePressure.headroom;
                     if (trace) {
+                        const desc = items.map(s => `${s.toolName}:${s.prefillTokens.length}`).join(', ');
                         try {
-                            process.stderr.write(`[SETTLE] DEFER ${item.toolName}:${item.prefillTokens.length} > headroom=${headroom}\n`);
+                            process.stderr.write(`[SETTLE] remaining=${settlePressure.remaining} headroom=${headroom} cellsUsed=${settlePressure.cellsUsed} nCtx=${settlePressure.nCtx} items=[${desc}]\n`);
                         }
                         catch { }
                     }
-                    deferred.push(item);
-                    continue;
-                }
-                prefillPairs.push([a.branch, item.prefillTokens]);
-                settledAgents.push(a);
-                headroom -= item.prefillTokens.length;
-                const postSettle = new ContextPressure(ctx, pressureOpts);
-                a.recordToolResult({
-                    name: item.toolName, args: item.callId,
-                    resultTokenCount: item.prefillTokens.length,
-                    contextAfterPercent: postSettle.percentAvailable,
-                    timestamp: performance.now(),
-                });
-                tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
-                    type: 'branch:prefill', branchHandle: a.id,
-                    tokenCount: item.prefillTokens.length, role: 'toolResult' });
-            }
-            if (prefillPairs.length > 0) {
-                if (trace) {
-                    const total = prefillPairs.reduce((s, [, t]) => s + t.length, 0);
-                    try {
-                        process.stderr.write(`[SETTLE] PREFILL ${prefillPairs.length} branches, ${total} tokens, headroom_after=${headroom}\n`);
-                    }
-                    catch { }
-                }
-                yield* (0, effection_1.call)(() => store.prefill(prefillPairs));
-                counters.warmPrefillCalls++;
-                counters.warmPrefillBranches += prefillPairs.length;
-                // Probe prefill from DISPATCH
-                const probePairs = [];
-                for (const a of settledAgents) {
-                    const probe = items.find(s => s.agentId === a.id)?.probe;
-                    if (probe) {
-                        const probeTokens = ctx.tokenizeSync(probe, false);
-                        probePairs.push([a.branch, probeTokens]);
+                    const prefillPairs = [];
+                    const settledAgents = [];
+                    const deferred = [];
+                    for (const item of items) {
+                        const a = agentById.get(item.agentId);
+                        if (!a || a.status === 'idle')
+                            continue;
+                        if (item.prefillTokens.length > headroom) {
+                            if (trace) {
+                                try {
+                                    process.stderr.write(`[SETTLE] DEFER ${item.toolName}:${item.prefillTokens.length} > headroom=${headroom}\n`);
+                                }
+                                catch { }
+                            }
+                            deferred.push(item);
+                            continue;
+                        }
+                        prefillPairs.push([a.branch, item.prefillTokens]);
+                        settledAgents.push(a);
+                        headroom -= item.prefillTokens.length;
+                        const postSettle = new ContextPressure(ctx, pressureOpts);
+                        a.recordToolResult({
+                            name: item.toolName, args: item.args,
+                            resultTokenCount: item.prefillTokens.length,
+                            contextAfterPercent: postSettle.percentAvailable,
+                            timestamp: performance.now(),
+                        });
                         tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
                             type: 'branch:prefill', branchHandle: a.id,
-                            tokenCount: probeTokens.length, role: 'probe', probeText: probe });
+                            tokenCount: item.prefillTokens.length, role: 'toolResult' });
                     }
-                }
-                if (probePairs.length > 0) {
-                    yield* (0, effection_1.call)(() => store.prefill(probePairs));
-                }
-                for (const a of settledAgents) {
-                    a.transition('active');
-                    a.resetTurn();
-                    applyLazyGrammar(a);
-                }
-            }
-            return deferred;
-        }
-        /** DISPATCH: execute tool calls sequentially, return settled items for next tick */
-        function* dispatch(calls) {
-            const results = [];
-            for (const { agent, tc } of calls) {
-                let toolArgs;
-                try {
-                    toolArgs = JSON.parse(tc.arguments);
-                }
-                catch {
-                    toolArgs = {};
-                }
-                const callId = tc.id || `call_${agent.toolCallCount}`;
-                agent.incrementToolCalls();
-                totalToolCalls++;
-                agent.incrementTurns();
-                yield* events.send({ type: 'agent:tool_call', agentId: agent.id, tool: tc.name, args: tc.arguments });
-                const tool = tools.get(tc.name);
-                const dispatchPressure = new ContextPressure(ctx, pressureOpts);
-                const explore = policy.shouldExplore?.(agent, dispatchPressure) ?? true;
-                const dispatchTraceId = tw.nextId();
-                const toolT0 = performance.now();
-                tw.write({
-                    traceId: dispatchTraceId, parentTraceId: poolScope.traceId, ts: toolT0,
-                    type: 'tool:dispatch', agentId: agent.id, tool: tc.name,
-                    toolIndex: toolIndexMap.get(tc.name) ?? -1, toolkitSize,
-                    args: toolArgs, callId,
-                    explore, percentAvailable: dispatchPressure.percentAvailable,
-                });
-                const toolContext = {
-                    agentId: agent.id, branch: agent.branch,
-                    onProgress: (p) => {
-                        progressBridge.send({ type: 'agent:tool_progress', agentId: agent.id, tool: tc.name, filled: p.filled, total: p.total });
-                    },
-                    scorer: opts.scorer, explore,
-                    pressurePercentAvailable: dispatchPressure.percentAvailable,
-                };
-                try {
-                    yield* context_1.TraceParent.set(dispatchTraceId);
-                    yield* context_1.CallingAgent.set(agent);
-                    const result = yield* (0, effection_1.scoped)(function* () {
-                        return yield* (0, effection_1.call)(() => tool ? tool.execute(toolArgs, toolContext) : Promise.resolve({ error: `Unknown tool: ${tc.name}` }));
-                    });
-                    const postToolPressure = new ContextPressure(ctx, pressureOpts);
-                    const contextAvailablePercent = postToolPressure.percentAvailable;
-                    if (result && typeof result === 'object' && !Array.isArray(result)) {
-                        result._contextAvailablePercent = contextAvailablePercent;
-                        const resultObj = result;
-                        if (Array.isArray(resultObj.results)) {
-                            agent.addNestedResults(resultObj.results.filter((f) => typeof f === 'string'));
+                    if (prefillPairs.length > 0) {
+                        if (trace) {
+                            const total = prefillPairs.reduce((s, [, t]) => s + t.length, 0);
+                            try {
+                                process.stderr.write(`[SETTLE] PREFILL ${prefillPairs.length} branches, ${total} tokens, headroom_after=${headroom}\n`);
+                            }
+                            catch { }
+                        }
+                        yield* (0, effection_1.call)(() => store.prefill(prefillPairs));
+                        counters.warmPrefillCalls++;
+                        counters.warmPrefillBranches += prefillPairs.length;
+                        // Probe prefill from DISPATCH
+                        const probePairs = [];
+                        for (const a of settledAgents) {
+                            const probe = items.find(s => s.agentId === a.id)?.probe;
+                            if (probe) {
+                                const probeTokens = ctx.tokenizeSync(probe, false);
+                                probePairs.push([a.branch, probeTokens]);
+                                tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
+                                    type: 'branch:prefill', branchHandle: a.id,
+                                    tokenCount: probeTokens.length, role: 'probe', probeText: probe });
+                            }
                         }
-                        if (Array.isArray(resultObj.nestedResults)) {
-                            agent.addNestedResults(resultObj.nestedResults.filter((f) => typeof f === 'string'));
+                        if (probePairs.length > 0) {
+                            yield* (0, effection_1.call)(() => store.prefill(probePairs));
+                        }
+                        for (const a of settledAgents) {
+                            a.transition('active');
+                            a.resetTurn();
+                            applyLazyGrammar(a);
                         }
                     }
-                    const resultStr = JSON.stringify(result);
-                    yield* events.send({ type: 'agent:tool_result', agentId: agent.id, tool: tc.name, result: resultStr, contextAvailablePercent });
-                    const prefillTokens = (0, sdk_2.buildToolResultDelta)(ctx, resultStr, callId);
-                    const probe = tool?.probe(result) ?? undefined;
-                    results.push({ agentId: agent.id, prefillTokens, toolName: tc.name, callId, probe });
-                    tw.write({ traceId: tw.nextId(), parentTraceId: dispatchTraceId, ts: performance.now(),
-                        type: 'tool:result', agentId: agent.id, tool: tc.name,
-                        result, prefillTokenCount: prefillTokens.length,
-                        durationMs: performance.now() - toolT0 });
+                    return deferred;
                 }
-                catch (err) {
-                    agent.transition('idle');
-                    agent.reportResult(`Tool error: ${err.message}`, 'tool_error');
-                    tw.write({ traceId: tw.nextId(), parentTraceId: dispatchTraceId, ts: performance.now(),
-                        type: 'tool:error', agentId: agent.id, tool: tc.name,
-                        error: err.message });
-                }
-            }
-            return results;
-        }
-        // ── Four-phase tick loop ─────────────────────────────────
-        let pendingSettled = [];
-        // ── Four-phase tick loop ─────────────────────────────────
-        let recoveryAttempted = false;
-        for (;;) {
-            // -- Phase 1: PRODUCE -- sample from active agents, collect tool calls
-            policy.resetTick?.();
-            const pressure = new ContextPressure(ctx, pressureOpts);
-            if (trace && (pressure.critical || pressure.headroom < 0)) {
-                try {
-                    process.stderr.write(`[PRODUCE] ${pressure.critical ? 'CRITICAL' : 'SOFT_LIMIT'} remaining=${pressure.remaining} headroom=${pressure.headroom} cellsUsed=${pressure.cellsUsed} nCtx=${pressure.nCtx}\n`);
-                }
-                catch { }
-            }
-            const entries = [];
-            const toolCalls = [];
-            const nudges = [];
-            for (const a of agents) {
-                if (a.status !== 'active')
-                    continue;
-                const policyExit = policy.shouldExit?.(a, pressure);
-                if (policyExit ?? pressure.critical) {
-                    a.transition('idle');
-                    const exitReason = pressure.critical ? 'pressure_critical'
-                        : policyExit ? 'policy_exit'
-                            : 'pressure_critical';
-                    tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
-                        type: 'pool:agentDrop', agentId: a.id, reason: exitReason });
-                    yield* events.send({ type: 'agent:done', agentId: a.id });
-                    // Trailing stop: extract findings inline, free KV for remaining agents
-                    yield* recoverInline(a, policy, ctx, store, tw, poolScope.traceId, events);
-                    continue;
+                /** DISPATCH: execute tool calls sequentially, return settled items for next tick */
+                function* dispatch(calls) {
+                    const results = [];
+                    for (const { agent, tc } of calls) {
+                        let toolArgs;
+                        try {
+                            toolArgs = JSON.parse(tc.arguments);
+                        }
+                        catch {
+                            toolArgs = {};
+                        }
+                        const callId = tc.id || `call_${agent.toolCallCount}`;
+                        agent.incrementToolCalls();
+                        totalToolCalls++;
+                        agent.incrementTurns();
+                        yield* poolChannel.send({ type: 'agent:tool_call', agentId: agent.id, tool: tc.name, args: tc.arguments });
+                        const tool = tools.get(tc.name);
+                        const dispatchPressure = new ContextPressure(ctx, pressureOpts);
+                        const explore = policy.shouldExplore?.(agent, dispatchPressure) ?? true;
+                        const dispatchTraceId = tw.nextId();
+                        const toolT0 = performance.now();
+                        tw.write({
+                            traceId: dispatchTraceId, parentTraceId: poolScope.traceId, ts: toolT0,
+                            type: 'tool:dispatch', agentId: agent.id, tool: tc.name,
+                            toolIndex: toolIndexMap.get(tc.name) ?? -1, toolkitSize,
+                            args: toolArgs, callId,
+                            explore, percentAvailable: dispatchPressure.percentAvailable,
+                        });
+                        const peerHistory = agents
+                            .filter(a => a.id !== agent.id)
+                            .flatMap(a => a.toolHistory);
+                        const toolContext = {
+                            agentId: agent.id, branch: agent.branch,
+                            onProgress: (p) => {
+                                progressBridge.send({ type: 'agent:tool_progress', agentId: agent.id, tool: tc.name, filled: p.filled, total: p.total });
+                            },
+                            scorer: opts.scorer, explore,
+                            pressurePercentAvailable: dispatchPressure.percentAvailable,
+                            peerHistory,
+                        };
+                        try {
+                            yield* context_1.TraceParent.set(dispatchTraceId);
+                            yield* context_1.CallingAgent.set(agent);
+                            const result = yield* (0, effection_1.scoped)(function* () {
+                                return yield* (0, effection_1.call)(() => tool ? tool.execute(toolArgs, toolContext) : Promise.resolve({ error: `Unknown tool: ${tc.name}` }));
+                            });
+                            const postToolPressure = new ContextPressure(ctx, pressureOpts);
+                            const contextAvailablePercent = postToolPressure.percentAvailable;
+                            if (result && typeof result === 'object' && !Array.isArray(result)) {
+                                result._contextAvailablePercent = contextAvailablePercent;
+                                const resultObj = result;
+                                if (Array.isArray(resultObj.results)) {
+                                    agent.addNestedResults(resultObj.results.filter((f) => typeof f === 'string'));
+                                }
+                                if (Array.isArray(resultObj.nestedResults)) {
+                                    agent.addNestedResults(resultObj.nestedResults.filter((f) => typeof f === 'string'));
+                                }
+                            }
+                            const resultStr = JSON.stringify(result);
+                            yield* poolChannel.send({ type: 'agent:tool_result', agentId: agent.id, tool: tc.name, result: resultStr, contextAvailablePercent });
+                            const prefillTokens = (0, sdk_2.buildToolResultDelta)(ctx, resultStr, callId);
+                            const probe = tool?.probe(result) ?? undefined;
+                            results.push({ agentId: agent.id, prefillTokens, toolName: tc.name, callId, args: tc.arguments, probe });
+                            tw.write({ traceId: tw.nextId(), parentTraceId: dispatchTraceId, ts: performance.now(),
+                                type: 'tool:result', agentId: agent.id, tool: tc.name,
+                                result, prefillTokenCount: prefillTokens.length,
+                                durationMs: performance.now() - toolT0 });
+                        }
+                        catch (err) {
+                            agent.transition('idle');
+                            agent.reportResult(`Tool error: ${err.message}`, 'tool_error');
+                            tw.write({ traceId: tw.nextId(), parentTraceId: dispatchTraceId, ts: performance.now(),
+                                type: 'tool:error', agentId: agent.id, tool: tc.name,
+                                error: err.message });
+                        }
+                    }
+                    return results;
                 }
-                const { token, text, isStop } = a.branch.produceSync();
-                if (isStop) {
-                    const parsed = ctx.parseChatOutput(a.rawOutput, a.fmt.format, {
-                        reasoningFormat: a.fmt.reasoningFormat,
-                        generationPrompt: a.fmt.generationPrompt,
-                        parser: a.fmt.parser,
-                    });
-                    tw.write({
-                        traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
-                        type: 'agent:turn', agentId: a.id, turn: a.turns,
-                        rawOutput: a.rawOutput,
-                        parsedContent: parsed.content || null,
-                        parsedToolCalls: parsed.toolCalls.map(tc => ({ name: tc.name, arguments: tc.arguments })),
-                    });
-                    // Policy decides what to do with the parsed output
-                    const action = policy.onProduced(a, parsed, pressure, policyConfig);
-                    switch (action.type) {
-                        case 'free_text_report':
-                            yield* handleFreeTextReport(a, action.content, events);
-                            continue;
-                        case 'idle':
-                            yield* handleIdleDrop(a, action.reason, events, tw, poolScope.traceId);
+                // ── Four-phase tick loop ─────────────────────────────────
+                let pendingSettled = [];
+                // ── Four-phase tick loop ─────────────────────────────────
+                let recoveryAttempted = false;
+                for (;;) {
+                    // -- Phase 1: PRODUCE -- sample from active agents, collect tool calls
+                    policy.resetTick?.();
+                    const pressure = new ContextPressure(ctx, pressureOpts);
+                    if (trace && (pressure.critical || pressure.headroom < 0)) {
+                        try {
+                            process.stderr.write(`[PRODUCE] ${pressure.critical ? 'CRITICAL' : 'SOFT_LIMIT'} remaining=${pressure.remaining} headroom=${pressure.headroom} cellsUsed=${pressure.cellsUsed} nCtx=${pressure.nCtx}\n`);
+                        }
+                        catch { }
+                    }
+                    const entries = [];
+                    const toolCalls = [];
+                    const nudges = [];
+                    for (const a of agents) {
+                        if (a.status !== 'active')
                             continue;
-                        case 'nudge':
-                            nudges.push(yield* handleNudge(a, action.message, parsed.toolCalls[0], ctx, tools));
+                        const policyExit = policy.shouldExit?.(a, pressure);
+                        if (policyExit ?? pressure.critical) {
+                            a.transition('idle');
+                            const exitReason = pressure.critical ? 'pressure_critical'
+                                : policyExit ? 'policy_exit'
+                                    : 'pressure_critical';
                             tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
-                                type: 'pool:agentNudge', agentId: a.id, reason: 'pressure_softcut' });
-                            continue;
-                        case 'report':
-                            yield* handleReport(a, action.result, parsed.toolCalls[0], terminalTool, pruneOnReport, events);
-                            totalToolCalls++;
-                            continue;
-                        case 'tool_call':
-                            a.transition('awaiting_tool');
-                            toolCalls.push({ agent: a, tc: action.tc });
-                            a.resetTurn();
+                                type: 'pool:agentDrop', agentId: a.id, reason: exitReason });
+                            yield* poolChannel.send({ type: 'agent:done', agentId: a.id });
+                            // Trailing stop: extract findings inline, free KV for remaining agents
+                            yield* recoverInline(a, policy, ctx, store, tw, poolScope.traceId, poolChannel);
                             continue;
+                        }
+                        const { token, text, isStop } = a.branch.produceSync();
+                        if (isStop) {
+                            const parsed = a.finalize(ctx);
+                            tw.write({
+                                traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
+                                type: 'agent:turn', agentId: a.id, turn: a.turns,
+                                rawOutput: a.rawOutput,
+                                parsedContent: parsed.content || null,
+                                parsedToolCalls: parsed.toolCalls.map(tc => ({ name: tc.name, arguments: tc.arguments })),
+                            });
+                            // Policy decides what to do with the parsed output
+                            const action = policy.onProduced(a, parsed, pressure, policyConfig);
+                            switch (action.type) {
+                                case 'free_text_report':
+                                    yield* handleFreeTextReport(a, action.content, poolChannel);
+                                    continue;
+                                case 'idle':
+                                    yield* handleIdleDrop(a, action.reason, poolChannel, tw, poolScope.traceId);
+                                    continue;
+                                case 'nudge':
+                                    nudges.push(yield* handleNudge(a, action.message, parsed.toolCalls[0], ctx, tools));
+                                    tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
+                                        type: 'pool:agentNudge', agentId: a.id, reason: 'nudge', message: action.message });
+                                    continue;
+                                case 'report':
+                                    yield* handleReport(a, action.result, parsed.toolCalls[0], terminalTool, pruneOnReport, poolChannel);
+                                    totalToolCalls++;
+                                    continue;
+                                case 'tool_call':
+                                    a.transition('awaiting_tool');
+                                    toolCalls.push({ agent: a, tc: action.tc });
+                                    a.resetTurn();
+                                    continue;
+                            }
+                        }
+                        entries.push([a.branch, token]);
+                        if (trace) {
+                            const entropy = a.branch.modelEntropy();
+                            const surprisal = a.branch.modelSurprisal(token);
+                            a.accumulateTokenWithTrace(text, entropy, surprisal);
+                            a.observe(ctx);
+                            yield* poolChannel.send({
+                                type: 'agent:produce', agentId: a.id, text, tokenCount: a.tokenCount,
+                                entropy, surprisal,
+                            });
+                        }
+                        else {
+                            a.accumulateToken(text);
+                            a.observe(ctx);
+                            yield* poolChannel.send({ type: 'agent:produce', agentId: a.id, text, tokenCount: a.tokenCount });
+                        }
                     }
-                }
-                entries.push([a.branch, token]);
-                if (trace) {
-                    const entropy = a.branch.modelEntropy();
-                    const surprisal = a.branch.modelSurprisal(token);
-                    a.accumulateTokenWithTrace(text, entropy, surprisal);
-                    yield* events.send({
-                        type: 'agent:produce', agentId: a.id, text, tokenCount: a.tokenCount,
-                        entropy, surprisal,
-                    });
-                }
-                else {
-                    a.accumulateToken(text);
-                    yield* events.send({ type: 'agent:produce', agentId: a.id, text, tokenCount: a.tokenCount });
-                }
-            }
-            // -- Phase 2: COMMIT -- batch-decode produced tokens
-            if (entries.length > 0) {
-                yield* (0, effection_1.call)(() => store.commit(entries));
-                steps++;
-                const commitPressure = new ContextPressure(ctx, pressureOpts);
-                yield* events.send({ type: 'agent:tick', cellsUsed: commitPressure.cellsUsed, nCtx: commitPressure.nCtx });
-            }
-            // -- Phase 3: SETTLE (settle what fits, defer what doesn't)
-            const toSettle = [...pendingSettled, ...nudges];
-            const deferred = toSettle.length > 0 ? yield* settle(toSettle) : [];
-            // Stall-breaker: if items are deferred and no active agents remain,
-            // sacrifice an awaiting_tool agent to free KV. Without this, agents
-            // with oversized results stay awaiting_tool indefinitely — PRODUCE
-            // skips them, headroom never recovers, the pool loops forever.
-            if (deferred.length > 0 && !agents.some(a => a.status === 'active')) {
-                const victim = agents.find(a => a.status === 'awaiting_tool' && !a.branch.disposed);
-                if (victim) {
-                    victim.transition('idle');
-                    tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
-                        type: 'pool:agentDrop', agentId: victim.id, reason: 'pressure_settle_reject' });
-                    yield* events.send({ type: 'agent:done', agentId: victim.id });
-                    yield* recoverInline(victim, policy, ctx, store, tw, poolScope.traceId, events);
-                }
-            }
-            // -- Phase 4: DISPATCH
-            const dispatched = yield* dispatch(toolCalls);
-            // Deferred + new dispatch results → next tick's SETTLE
-            pendingSettled = [...deferred, ...dispatched];
-            // -- Termination + recovery
-            if (agents.every(a => a.status === 'idle' || a.status === 'disposed')) {
-                if (!recoveryAttempted) {
-                    recoveryAttempted = true;
-                    // Recover any idle agents that weren't handled by inline recovery
-                    // (e.g., killed by max_turns, time budget, or free_text_stop)
-                    for (const a of agents) {
-                        if (a.status === 'idle' && !a.result && !a.branch.disposed) {
-                            yield* recoverInline(a, policy, ctx, store, tw, poolScope.traceId, events);
+                    // -- Phase 2: COMMIT -- batch-decode produced tokens
+                    if (entries.length > 0) {
+                        yield* (0, effection_1.call)(() => store.commit(entries));
+                        steps++;
+                        const commitPressure = new ContextPressure(ctx, pressureOpts);
+                        yield* poolChannel.send({ type: 'agent:tick', cellsUsed: commitPressure.cellsUsed, nCtx: commitPressure.nCtx });
+                    }
+                    // -- Phase 3: SETTLE (settle what fits, defer what doesn't)
+                    const toSettle = [...pendingSettled, ...nudges];
+                    const deferred = toSettle.length > 0 ? yield* settle(toSettle) : [];
+                    // Stall-breaker: if items are deferred and no active agents remain,
+                    // sacrifice an awaiting_tool agent to free KV. Without this, agents
+                    // with oversized results stay awaiting_tool indefinitely — PRODUCE
+                    // skips them, headroom never recovers, the pool loops forever.
+                    if (deferred.length > 0 && !agents.some(a => a.status === 'active')) {
+                        const victim = agents.find(a => a.status === 'awaiting_tool' && !a.branch.disposed);
+                        if (victim) {
+                            victim.transition('idle');
+                            tw.write({ traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
+                                type: 'pool:agentDrop', agentId: victim.id, reason: 'pressure_settle_reject' });
+                            yield* poolChannel.send({ type: 'agent:done', agentId: victim.id });
+                            yield* recoverInline(victim, policy, ctx, store, tw, poolScope.traceId, poolChannel);
+                        }
+                    }
+                    // -- Phase 4: DISPATCH
+                    const dispatched = yield* dispatch(toolCalls);
+                    // Deferred + new dispatch results → next tick's SETTLE
+                    pendingSettled = [...deferred, ...dispatched];
+                    // -- Termination + recovery
+                    if (agents.every(a => a.status === 'idle' || a.status === 'disposed')) {
+                        if (!recoveryAttempted) {
+                            recoveryAttempted = true;
+                            // Recover any idle agents that weren't handled by inline recovery
+                            // (e.g., killed by max_turns, time budget, or free_text_stop)
+                            for (const a of agents) {
+                                if (a.status === 'idle' && !a.result && !a.branch.disposed) {
+                                    yield* recoverInline(a, policy, ctx, store, tw, poolScope.traceId, poolChannel);
+                                }
+                            }
                         }
+                        break;
                     }
                 }
-                break;
+                // ── Close channel with result — consumers get AgentPoolResult as close value ───────
+                // Branch cleanup is handled by each branch's ensure() from setupAgent —
+                // when this resource's scope exits, all ensure() callbacks fire.
+                tw.write({
+                    traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
+                    type: 'pool:close',
+                    agents: agents.map(a => ({
+                        agentId: a.id, tokenCount: a.tokenCount,
+                        toolCallCount: a.toolCallCount, result: a.result,
+                        ppl: a.branch.disposed ? 0 : a.branch.perplexity,
+                    })),
+                    totalTokens: agents.reduce((s, a) => s + a.tokenCount, 0),
+                    steps, durationMs: performance.now() - poolT0,
+                });
+                poolScope.close();
+                const result = {
+                    agents: agents.map(a => ({
+                        agentId: a.id,
+                        parentAgentId: a.parentId,
+                        branch: a.branch,
+                        agent: a,
+                        result: a.result,
+                        toolCallCount: a.toolCallCount,
+                        tokenCount: a.tokenCount,
+                        ppl: a.branch.disposed ? 0 : a.branch.perplexity,
+                        samplingPpl: a.branch.disposed ? 0 : a.branch.samplingPerplexity,
+                        trace: trace ? a.traceBuffer : undefined,
+                        nestedResults: [...a.nestedResults],
+                    })),
+                    totalTokens: agents.reduce((s, a) => s + a.tokenCount, 0),
+                    totalToolCalls,
+                    steps,
+                    counters,
+                };
+                yield* poolChannel.close(result);
             }
-        }
-        // ── Provide result — suspends, branches stay alive ───────
-        // Branch cleanup is handled by each branch's ensure() from setupAgent —
-        // when this resource's scope exits, all ensure() callbacks fire.
-        tw.write({
-            traceId: tw.nextId(), parentTraceId: poolScope.traceId, ts: performance.now(),
-            type: 'pool:close',
-            agents: agents.map(a => ({
-                agentId: a.id, tokenCount: a.tokenCount,
-                toolCallCount: a.toolCallCount, result: a.result,
-                ppl: a.branch.disposed ? 0 : a.branch.perplexity,
-            })),
-            totalTokens: agents.reduce((s, a) => s + a.tokenCount, 0),
-            steps, durationMs: performance.now() - poolT0,
-        });
-        poolScope.close();
-        const result = {
-            agents: agents.map(a => ({
-                agentId: a.id,
-                parentAgentId: a.parentId,
-                branch: a.branch,
-                result: a.result,
-                toolCallCount: a.toolCallCount,
-                tokenCount: a.tokenCount,
-                ppl: a.branch.disposed ? 0 : a.branch.perplexity,
-                samplingPpl: a.branch.disposed ? 0 : a.branch.samplingPerplexity,
-                trace: trace ? a.traceBuffer : undefined,
-                nestedResults: [...a.nestedResults],
-            })),
-            totalTokens: agents.reduce((s, a) => s + a.tokenCount, 0),
-            totalToolCalls,
-            steps,
-            counters,
-        };
-        yield* provide(result);
+            catch {
+                // KV exhaustion or other decode failure — close with partial results
+                poolScope.close();
+                const partial = {
+                    agents: agents.map(a => ({
+                        agentId: a.id, parentAgentId: a.parentId, branch: a.branch, agent: a,
+                        result: a.result, toolCallCount: a.toolCallCount, tokenCount: a.tokenCount,
+                        ppl: a.branch.disposed ? 0 : a.branch.perplexity,
+                        samplingPpl: a.branch.disposed ? 0 : a.branch.samplingPerplexity,
+                        trace: trace ? a.traceBuffer : undefined,
+                        nestedResults: [...a.nestedResults],
+                    })),
+                    totalTokens: agents.reduce((s, a) => s + a.tokenCount, 0),
+                    totalToolCalls, steps, counters,
+                };
+                yield* poolChannel.close(partial);
+            }
+        }); // end spawn — tick loop
+        yield* provide(subscription);
     });
 }
 //# sourceMappingURL=agent-pool.js.map