@lloyal-labs/lloyal-agents 1.7.0 → 2.1.0

package/dist/orchestrators.d.ts

@@ -0,0 +1,161 @@
+import type { Operation } from 'effection';
+import type { Branch } from '@lloyal-labs/sdk';
+import type { Agent } from './Agent';
+/**
+ * Spec for spawning a single agent under a {@link PoolContext}.
+ * `parent` defaults to `ctx.spine`.
+ *
+ * @category Agents
+ */
+export interface SpawnSpec {
+    /** User message content — the agent's task. */
+    content: string;
+    /** Per-agent system prompt. */
+    systemPrompt: string;
+    /** PRNG seed for sampler diversity. */
+    seed?: number;
+    /** Parent branch to fork from. Falls back to ctx.spine. */
+    parent?: Branch;
+}
+/**
+ * Orchestrator-facing API surface exposed by {@link useAgentPool}.
+ *
+ * The orchestrator drives task spawning, waiting, and spine extension
+ * through this object. The pool's tick loop runs concurrently and batches
+ * decode across whatever agents are currently active.
+ *
+ * @category Agents
+ */
+export interface PoolContext {
+    /** The pool's spine branch. Orchestrator-provided spawns fork from here by default. */
+    readonly spine: Branch;
+    /** Fork an agent branch, prefill its suffix, transition to active. Tick loop picks it up. */
+    spawn(spec: SpawnSpec): Operation<Agent>;
+    /** Suspend until agent.status becomes 'idle' | 'disposed'. Returns agent for chaining. */
+    waitFor(agent: Agent): Operation<Agent>;
+    /**
+     * Serialize a user+assistant turn and prefill it into the spine, advancing spine.position.
+     * No-op (returns 0) when assistantContent is empty.
+     */
+    extendSpine(userContent: string, assistantContent: string): Operation<number>;
+    /** Whether another spawn with this suffix size would fit under current pressure. */
+    canFit(estimatedSuffixTokens: number): boolean;
+}
+/**
+ * An orchestrator is a generator that drives a pool via {@link PoolContext}.
+ * Returned by the factory functions in this module.
+ *
+ * @category Agents
+ */
+export type Orchestrator = (ctx: PoolContext) => Operation<void>;
+/**
+ * Parallel orchestrator — spawn all tasks upfront, wait for all to complete.
+ * This is the default shape that `useAgentPool` used to provide implicitly.
+ *
+ * @example
+ * ```ts
+ * yield* agentPool({
+ *   tools: [...],
+ *   orchestrate: parallel(questions.map(q => ({ content: q, systemPrompt: RESEARCH_PROMPT }))),
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+export declare const parallel: (tasks: SpawnSpec[]) => Orchestrator;
+/**
+ * One step of a {@link chain} orchestrator. Declares the task, optional user
+ * content for spine extension after the task reports, and optional observability
+ * hooks that fire before the spawn and after the spine extension.
+ *
+ * The hooks let harnesses emit streaming events (per-task progress, completion
+ * telemetry) without dropping down to an inline orchestrator — the factory
+ * stays declarative while the hook bodies stay co-located with the step they
+ * instrument.
+ *
+ * @category Agents
+ */
+export interface ChainStep {
+    task: SpawnSpec;
+    /** User content recorded on the spine (e.g., "Research task: ..."). Omit to skip extension. */
+    userContent?: string;
+    /** Fires BEFORE `ctx.spawn` for this step. Use for "task starting" events. */
+    beforeSpawn?: () => Operation<void>;
+    /**
+     * Fires AFTER `ctx.extendSpine` for this step (or immediately after waitFor
+     * if no extension happened). Receives the number of tokens added to the
+     * spine (0 when no extension) and the root's position after any extension.
+     * Use for "task done" events with spine telemetry.
+     */
+    afterExtend?: (delta: number, position: number) => Operation<void>;
+}
+/**
+ * Chain orchestrator — sequential execution. Each step may extend the shared
+ * root with its findings before the next step forks from the extended position.
+ *
+ * The second argument maps each item to a ChainStep, so callers can compute
+ * per-task prompts and spine labels from their own data model without
+ * coupling the factory to a particular task type.
+ *
+ * @example
+ * ```ts
+ * yield* agentPool({
+ *   tools: [...],
+ *   parent: querySpine,
+ *   orchestrate: chain(researchTasks, (task, i) => ({
+ *     task: { content: taskToContent(task), systemPrompt: renderWorker({ taskIndex: i }) },
+ *     userContent: `Research task: ${task.description}`,
+ *   })),
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+export declare const chain: <T>(items: T[], toStep: (item: T, index: number) => ChainStep) => Orchestrator;
+/**
+ * Fanout orchestrator — landscape task first (optionally extending the spine),
+ * then N independent domain tasks in parallel. Domain tasks fork from the
+ * post-landscape root and do NOT see each other's findings.
+ *
+ * The canonical shape for multi-domain queries: one landscape survey that
+ * loads vocabulary into the spine, then one task per independent domain.
+ *
+ * @example
+ * ```ts
+ * yield* agentPool({
+ *   orchestrate: fanout(
+ *     { task: { content: landscapeQuery, systemPrompt: WORKER }, userContent: 'Landscape survey' },
+ *     domainQueries.map(q => ({ content: q, systemPrompt: WORKER })),
+ *   ),
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+export declare const fanout: (landscape: ChainStep, domains: SpawnSpec[]) => Orchestrator;
+/**
+ * A node in a {@link dag} orchestrator. Dependencies are referenced by id.
+ *
+ * @category Agents
+ */
+export interface DAGNode {
+    id: string;
+    task: SpawnSpec;
+    /** Ids of nodes that must complete before this node spawns. */
+    dependsOn?: string[];
+    /** User content for spine extension when this node reports. Omit to skip extension. */
+    userContent?: string;
+}
+/**
+ * DAG orchestrator — lazy spawn on dependency resolution. Independent nodes
+ * run in parallel; dependent nodes wait until their dependencies complete
+ * (and their findings extend the spine) before forking.
+ *
+ * Subsumes the design in `docs/dag-pool.md` — DAG is an orchestration
+ * pattern expressed on top of the general primitive, not a pool internals
+ * change.
+ *
+ * @category Agents
+ */
+export declare const dag: (nodes: DAGNode[]) => Orchestrator;
+//# sourceMappingURL=orchestrators.d.ts.map

package/dist/orchestrators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrators.d.ts","sourceRoot":"","sources":["../src/orchestrators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAQ,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,uFAAuF;IACvF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,6FAA6F;IAC7F,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAEzC,0FAA0F;IAC1F,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAExC;;;OAGG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAE9E,oFAAoF;IACpF,MAAM,CAAC,qBAAqB,EAAE,MAAM,GAAG,OAAO,CAAC;CAChD;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,WAAW,KAAK,SAAS,CAAC,IAAI,CAAC,CAAC;AAIjE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,SAAS,EAAE,KAAG,YAI3C,CAAC;AAEJ;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,+FAA+F;IAC/F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC;IACpC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAC,IAAI,CAAC,CAAC;CACpE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,OAAO,CAAC,EAAE,EACV,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,SAAS,KAC5C,YAaA,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,WAAW,SAAS,EAAE,SAAS,SAAS,EAAE,KAAG,YAajE,CAAC;AAEJ;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;IAChB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,EAAE,KAAG,YA0CtC,CAAC"}

package/dist/orchestrators.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dag = exports.fanout = exports.chain = exports.parallel = void 0;
+const effection_1 = require("effection");
+// ── Factories ──────────────────────────────────────────────────
+/**
+ * Parallel orchestrator — spawn all tasks upfront, wait for all to complete.
+ * This is the default shape that `useAgentPool` used to provide implicitly.
+ *
+ * @example
+ * ```ts
+ * yield* agentPool({
+ *   tools: [...],
+ *   orchestrate: parallel(questions.map(q => ({ content: q, systemPrompt: RESEARCH_PROMPT }))),
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+const parallel = (tasks) => function* (ctx) {
+    const agents = yield* (0, effection_1.all)(tasks.map(t => ctx.spawn({ ...t, parent: t.parent ?? ctx.spine })));
+    yield* (0, effection_1.all)(agents.map(a => ctx.waitFor(a)));
+};
+exports.parallel = parallel;
+/**
+ * Chain orchestrator — sequential execution. Each step may extend the shared
+ * root with its findings before the next step forks from the extended position.
+ *
+ * The second argument maps each item to a ChainStep, so callers can compute
+ * per-task prompts and spine labels from their own data model without
+ * coupling the factory to a particular task type.
+ *
+ * @example
+ * ```ts
+ * yield* agentPool({
+ *   tools: [...],
+ *   parent: querySpine,
+ *   orchestrate: chain(researchTasks, (task, i) => ({
+ *     task: { content: taskToContent(task), systemPrompt: renderWorker({ taskIndex: i }) },
+ *     userContent: `Research task: ${task.description}`,
+ *   })),
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+const chain = (items, toStep) => function* (ctx) {
+    for (const [i, item] of items.entries()) {
+        const step = toStep(item, i);
+        if (step.beforeSpawn)
+            yield* step.beforeSpawn();
+        const agent = yield* ctx.waitFor(yield* ctx.spawn({ ...step.task, parent: step.task.parent ?? ctx.spine }));
+        const delta = agent.result && step.userContent
+            ? yield* ctx.extendSpine(step.userContent, agent.result)
+            : 0;
+        if (step.afterExtend)
+            yield* step.afterExtend(delta, ctx.spine.position);
+    }
+};
+exports.chain = chain;
+/**
+ * Fanout orchestrator — landscape task first (optionally extending the spine),
+ * then N independent domain tasks in parallel. Domain tasks fork from the
+ * post-landscape root and do NOT see each other's findings.
+ *
+ * The canonical shape for multi-domain queries: one landscape survey that
+ * loads vocabulary into the spine, then one task per independent domain.
+ *
+ * @example
+ * ```ts
+ * yield* agentPool({
+ *   orchestrate: fanout(
+ *     { task: { content: landscapeQuery, systemPrompt: WORKER }, userContent: 'Landscape survey' },
+ *     domainQueries.map(q => ({ content: q, systemPrompt: WORKER })),
+ *   ),
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+const fanout = (landscape, domains) => function* (ctx) {
+    const l = yield* ctx.waitFor(yield* ctx.spawn({ ...landscape.task, parent: landscape.task.parent ?? ctx.spine }));
+    if (l.result && landscape.userContent) {
+        yield* ctx.extendSpine(landscape.userContent, l.result);
+    }
+    const agents = yield* (0, effection_1.all)(domains.map(d => ctx.spawn({ ...d, parent: d.parent ?? ctx.spine })));
+    yield* (0, effection_1.all)(agents.map(a => ctx.waitFor(a)));
+};
+exports.fanout = fanout;
+/**
+ * DAG orchestrator — lazy spawn on dependency resolution. Independent nodes
+ * run in parallel; dependent nodes wait until their dependencies complete
+ * (and their findings extend the spine) before forking.
+ *
+ * Subsumes the design in `docs/dag-pool.md` — DAG is an orchestration
+ * pattern expressed on top of the general primitive, not a pool internals
+ * change.
+ *
+ * @category Agents
+ */
+const dag = (nodes) => {
+    validateDAG(nodes);
+    return function* (ctx) {
+        // Each node runs as a child Task. Dependencies are expressed by
+        // awaiting the dep's Task (`yield* depTask`) — Task<T> extends
+        // Future<T> extends Operation<T>, so this is the canonical Effection
+        // cross-task rendezvous (see frontside.com/effection/api/v4/Task).
+        //
+        // Why this beats the older recursive-spawnNode-with-Sets approach:
+        //   - No mutable bookkeeping. The "node N is done" signal IS the
+        //     Task itself; the runtime tracks lifetimes for free.
+        //   - No race window for double-spawn. Each node spawns exactly
+        //     once, by definition (one entry per `tasks.set`).
+        //   - Failure propagates through the dependency edges automatically:
+        //     if node A throws, every task awaiting A's Task receives the
+        //     same error, and structured concurrency halts the rest.
+        const tasks = new Map();
+        function* runNode(n) {
+            // Gate: wait for every declared dep's task to complete. The map is
+            // fully populated before any node body runs (spawned tasks don't
+            // execute until the parent yields, and the spawn loop below is
+            // synchronous between iterations).
+            for (const depId of n.dependsOn ?? []) {
+                yield* tasks.get(depId);
+            }
+            const agent = yield* ctx.waitFor(yield* ctx.spawn({ ...n.task, parent: n.task.parent ?? ctx.spine }));
+            if (agent.result && n.userContent) {
+                yield* ctx.extendSpine(n.userContent, agent.result);
+            }
+        }
+        for (const n of nodes) {
+            tasks.set(n.id, yield* (0, effection_1.spawn)(() => runNode(n)));
+        }
+        // Await every task. Roots run first (no deps to await); descendants
+        // unblock as their deps complete. Any throw inside a node propagates
+        // here and halts the rest via structured concurrency.
+        for (const t of tasks.values())
+            yield* t;
+    };
+};
+exports.dag = dag;
+function validateDAG(nodes) {
+    const ids = new Set(nodes.map(n => n.id));
+    const duplicates = nodes.filter((n, i) => nodes.findIndex(m => m.id === n.id) !== i);
+    if (duplicates.length > 0) {
+        throw new Error(`dag: duplicate node ids: ${duplicates.map(n => n.id).join(', ')}`);
+    }
+    for (const n of nodes) {
+        for (const dep of n.dependsOn ?? []) {
+            if (!ids.has(dep))
+                throw new Error(`dag: node '${n.id}' depends on unknown node '${dep}'`);
+        }
+    }
+    // Cycle detection via DFS
+    const visiting = new Set();
+    const visited = new Set();
+    const byId = new Map(nodes.map(n => [n.id, n]));
+    function visit(id, path) {
+        if (visited.has(id))
+            return;
+        if (visiting.has(id))
+            throw new Error(`dag: cycle detected: ${[...path, id].join(' -> ')}`);
+        visiting.add(id);
+        const node = byId.get(id);
+        for (const dep of node?.dependsOn ?? [])
+            visit(dep, [...path, id]);
+        visiting.delete(id);
+        visited.add(id);
+    }
+    for (const n of nodes)
+        visit(n.id, []);
+}
+//# sourceMappingURL=orchestrators.js.map

package/dist/orchestrators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrators.js","sourceRoot":"","sources":["../src/orchestrators.ts"],"names":[],"mappings":"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"}

package/dist/replay.d.ts

@@ -0,0 +1,96 @@
+import type { Operation } from 'effection';
+import { Branch } from '@lloyal-labs/sdk';
+import type { TraceEvent } from './trace-types';
+/**
+ * Serialized state needed to reconstruct a Branch deterministically.
+ *
+ * `seedPrompt` is the tokenized prompt that initialized a spine — the
+ * full formatted chat template including system prompt and any tool schemas.
+ * Captured from `prompt:format` events with `role: 'spine'`.
+ *
+ * `turns` is an ordered list of user/assistant turn pairs that were prefilled
+ * on top of the spine via {@link extendSpine}. Empty for pool-start replay
+ * (any orchestration shape that doesn't extend the spine — e.g. `parallel`);
+ * populated for spine-extending orchestrations (`chain`, `fanout`, `dag`).
+ *
+ * @category Agents
+ */
+export interface BranchCheckpoint {
+    seedPrompt: string;
+    turns: Array<{
+        userContent: string;
+        assistantContent: string;
+    }>;
+}
+/**
+ * Extract the spine seed prompt from a trace, with no spine extensions.
+ *
+ * Useful for replaying parallel orchestrations, or for forking a fresh
+ * agent off the same pool-start state for A/B experiments.
+ *
+ * @param events - parsed JSONL trace events, in emission order
+ * @throws If no `prompt:format` event with `role: 'spine'` is found.
+ *
+ * @category Agents
+ */
+export declare function extractSpineSeed(events: TraceEvent[]): BranchCheckpoint;
+/**
+ * Extract a full spine checkpoint — spine seed prompt plus every
+ * `spine:extend` event in emission order.
+ *
+ * When `opts.poolTraceId` is set, only spine extensions under that pool's
+ * scope are included (useful when a trace contains multiple nested or
+ * sequential pools with independent spines — typically the research pool
+ * vs. a later synthesis pool, both extending their own spines).
+ *
+ * @param events - parsed JSONL trace events, in emission order
+ * @param opts.poolTraceId - filter extensions to this pool's scope
+ * @throws If no spine seed prompt is found.
+ *
+ * @category Agents
+ */
+export declare function extractSpineCheckpoint(events: TraceEvent[], opts?: {
+    poolTraceId?: number;
+}): BranchCheckpoint;
+/**
+ * Materialize a Branch reflecting the checkpointed state.
+ *
+ * Creates a fresh spine at position 0 in the active `SessionContext`, prefills
+ * the tokenized seed prompt, then applies each turn delta via `buildTurnDelta`
+ * + `store.prefill`. Registers an `ensure()` so the subtree is pruned when
+ * the caller's scope exits — lifetime follows the enclosing `scoped()` or
+ * `resource()`, matching how `withSpine` manages its own spine.
+ *
+ * Pass the returned branch as `parent` to `agentPool` to run a replacement
+ * stage (synth re-run, single-agent replay with modified prompt, etc.) against
+ * the reconstructed KV state.
+ *
+ * @example Replay a pool-start (parallel orchestration) with a modified task
+ * ```ts
+ * const events = parseTrace(tracePath);
+ * const checkpoint = extractSpineSeed(events);
+ * const spine = yield* reconstructBranch(checkpoint);
+ * yield* agentPool({
+ *   parent: spine,
+ *   orchestrate: parallel([{ content: modifiedTask, systemPrompt: modifiedSys }]),
+ *   ...
+ * });
+ * ```
+ *
+ * @example Replay a spine-chain (research) state with a different synth prompt
+ * ```ts
+ * const events = parseTrace(tracePath);
+ * const checkpoint = extractSpineCheckpoint(events);
+ * const spine = yield* reconstructBranch(checkpoint);
+ * yield* agentPool({
+ *   parent: spine,
+ *   orchestrate: parallel([{ content: SYNTHESIZE.user }]),
+ *   systemPrompt: SYNTHESIZE.system,
+ *   ...
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+export declare function reconstructBranch(checkpoint: BranchCheckpoint): Operation<Branch>;
+//# sourceMappingURL=replay.d.ts.map

package/dist/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../src/replay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAkB,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,gBAAgB,CAWvE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,UAAU,EAAE,EACpB,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,gBAAgB,CASlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAiB,iBAAiB,CAAC,UAAU,EAAE,gBAAgB,GAAG,SAAS,CAAC,MAAM,CAAC,CAgBlF"}

package/dist/replay.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSpineSeed = extractSpineSeed;
+exports.extractSpineCheckpoint = extractSpineCheckpoint;
+exports.reconstructBranch = reconstructBranch;
+const effection_1 = require("effection");
+const sdk_1 = require("@lloyal-labs/sdk");
+const context_1 = require("./context");
+/**
+ * Extract the spine seed prompt from a trace, with no spine extensions.
+ *
+ * Useful for replaying parallel orchestrations, or for forking a fresh
+ * agent off the same pool-start state for A/B experiments.
+ *
+ * @param events - parsed JSONL trace events, in emission order
+ * @throws If no `prompt:format` event with `role: 'spine'` is found.
+ *
+ * @category Agents
+ */
+function extractSpineSeed(events) {
+    const seed = events.find((e) => e.type === 'prompt:format' && e.role === 'spine');
+    if (!seed) {
+        throw new Error('extractSpineSeed: no prompt:format event with role=spine found in trace');
+    }
+    return { seedPrompt: seed.promptText, turns: [] };
+}
+/**
+ * Extract a full spine checkpoint — spine seed prompt plus every
+ * `spine:extend` event in emission order.
+ *
+ * When `opts.poolTraceId` is set, only spine extensions under that pool's
+ * scope are included (useful when a trace contains multiple nested or
+ * sequential pools with independent spines — typically the research pool
+ * vs. a later synthesis pool, both extending their own spines).
+ *
+ * @param events - parsed JSONL trace events, in emission order
+ * @param opts.poolTraceId - filter extensions to this pool's scope
+ * @throws If no spine seed prompt is found.
+ *
+ * @category Agents
+ */
+function extractSpineCheckpoint(events, opts = {}) {
+    const seed = extractSpineSeed(events);
+    const turns = [];
+    for (const e of events) {
+        if (e.type !== 'spine:extend')
+            continue;
+        if (opts.poolTraceId != null && e.parentTraceId !== opts.poolTraceId)
+            continue;
+        turns.push({ userContent: e.userContent, assistantContent: e.assistantContent });
+    }
+    return { seedPrompt: seed.seedPrompt, turns };
+}
+/**
+ * Materialize a Branch reflecting the checkpointed state.
+ *
+ * Creates a fresh spine at position 0 in the active `SessionContext`, prefills
+ * the tokenized seed prompt, then applies each turn delta via `buildTurnDelta`
+ * + `store.prefill`. Registers an `ensure()` so the subtree is pruned when
+ * the caller's scope exits — lifetime follows the enclosing `scoped()` or
+ * `resource()`, matching how `withSpine` manages its own spine.
+ *
+ * Pass the returned branch as `parent` to `agentPool` to run a replacement
+ * stage (synth re-run, single-agent replay with modified prompt, etc.) against
+ * the reconstructed KV state.
+ *
+ * @example Replay a pool-start (parallel orchestration) with a modified task
+ * ```ts
+ * const events = parseTrace(tracePath);
+ * const checkpoint = extractSpineSeed(events);
+ * const spine = yield* reconstructBranch(checkpoint);
+ * yield* agentPool({
+ *   parent: spine,
+ *   orchestrate: parallel([{ content: modifiedTask, systemPrompt: modifiedSys }]),
+ *   ...
+ * });
+ * ```
+ *
+ * @example Replay a spine-chain (research) state with a different synth prompt
+ * ```ts
+ * const events = parseTrace(tracePath);
+ * const checkpoint = extractSpineCheckpoint(events);
+ * const spine = yield* reconstructBranch(checkpoint);
+ * yield* agentPool({
+ *   parent: spine,
+ *   orchestrate: parallel([{ content: SYNTHESIZE.user }]),
+ *   systemPrompt: SYNTHESIZE.system,
+ *   ...
+ * });
+ * ```
+ *
+ * @category Agents
+ */
+function* reconstructBranch(checkpoint) {
+    const ctx = yield* context_1.Ctx.expect();
+    const store = yield* context_1.Store.expect();
+    const spine = sdk_1.Branch.create(ctx, 0, {});
+    yield* (0, effection_1.ensure)(() => { if (!spine.disposed)
+        spine.pruneSubtreeSync(); });
+    const seedTokens = ctx.tokenizeSync(checkpoint.seedPrompt, false);
+    yield* (0, effection_1.call)(() => spine.prefill(seedTokens));
+    for (const turn of checkpoint.turns) {
+        const delta = (0, sdk_1.buildTurnDelta)(ctx, turn.userContent, turn.assistantContent);
+        yield* (0, effection_1.call)(() => store.prefill([[spine, delta]]));
+    }
+    return spine;
+}
+//# sourceMappingURL=replay.js.map

package/dist/replay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.js","sourceRoot":"","sources":["../src/replay.ts"],"names":[],"mappings":";;AAoCA,4CAWC;AAiBD,wDAYC;AA0CD,8CAgBC;AAtID,yCAAyC;AAEzC,0CAA0D;AAC1D,uCAAuC;AAsBvC;;;;;;;;;;GAUG;AACH,SAAgB,gBAAgB,CAAC,MAAoB;IACnD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CACtB,CAAC,CAAC,EAAuD,EAAE,CACzD,CAAC,CAAC,IAAI,KAAK,eAAe,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,CACnD,CAAC;IACF,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CACb,yEAAyE,CAC1E,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,sBAAsB,CACpC,MAAoB,EACpB,OAAiC,EAAE;IAEnC,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,KAAK,GAA8B,EAAE,CAAC;IAC5C,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,CAAC,CAAC,IAAI,KAAK,cAAc;YAAE,SAAS;QACxC,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,CAAC,CAAC,aAAa,KAAK,IAAI,CAAC,WAAW;YAAE,SAAS;QAC/E,KAAK,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,gBAAgB,EAAE,CAAC,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACnF,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,QAAe,CAAC,CAAC,iBAAiB,CAAC,UAA4B;IAC7D,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,aAAG,CAAC,MAAM,EAAE,CAAC;IAChC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,eAAK,CAAC,MAAM,EAAE,CAAC;IAEpC,MAAM,KAAK,GAAG,YAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IACxC,KAAK,CAAC,CAAC,IAAA,kBAAM,EAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ;QAAE,KAAK,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAExE,MAAM,UAAU,GAAG,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAClE,KAAK,CAAC,CAAC,IAAA,gBAAI,EAAC,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAE7C,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,KAAK,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,IAAA,oBAAc,EAAC,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC3E,KAAK,CAAC,CAAC,IAAA,gBAAI,EAAC,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACrD,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/spine.d.ts

@@ -0,0 +1,106 @@
+import type { Operation } from "effection";
+import { Branch } from "@lloyal-labs/sdk";
+import type { Tool } from "./Tool";
+import type { SamplingParams } from "./types";
+/**
+ * Configuration for {@link withSpine}
+ *
+ * @category Agents
+ */
+export interface SpineOptions {
+    /** Sampling parameters for the spine branch */
+    params?: SamplingParams;
+    /**
+     * Set ScratchpadParent context so tools can fork from the spine
+     * for scratchpad extraction (fork-attend-extract-prune pattern).
+     * @default false
+     */
+    enableScratchpad?: boolean;
+    /**
+     * Fork the spine from this branch instead of creating at position 0.
+     *
+     * When provided, the spine inherits the parent's full KV state —
+     * every tool call, tool result, and generated token the parent
+     * accumulated. Sub-agents forking from this spine attend over the
+     * parent's complete attention state (Continuous Context).
+     *
+     * When omitted, creates a fresh spine at position 0 (cold start).
+     */
+    parent?: Branch;
+    /**
+     * When set, prefill the chat-format `[system + tools]` header onto the
+     * spine once at setup. Every agent forking from the spine inherits these
+     * tokens via `forkSync`'s metadata-only KV prefix-share — the role and
+     * tool schemas appear ONCE in physical KV regardless of how many agents
+     * the pool spawns.
+     *
+     * The resulting `FormatConfig` (parser/grammar/format/triggers) is set
+     * on the {@link SpineFmt} context so `setupAgent` can detect shared mode,
+     * skip its own system+tools formatting, and inherit the dispatch-side
+     * fmt from the spine.
+     *
+     * Use this for orchestrators where every agent shares the same role —
+     * chain-mode research pools, fanout-style same-role pools, etc. Mixed-
+     * role workflows (research → compare → synthesize) keep using per-spec
+     * `SpawnSpec.systemPrompt` and don't pass this option.
+     */
+    systemPrompt?: string;
+    /**
+     * Tools whose schemas embed into the chat-format header prefilled at setup.
+     * Their JSON schemas are decoded into the spine's KV ONCE; every agent
+     * forking from the spine inherits the schema tokens via fork prefix-share
+     * instead of re-emitting them in its own suffix.
+     *
+     * The same `Tool[]` is typically also passed to `agentPool` (where it
+     * becomes the dispatcher registry). Two roles, one input — schemas
+     * decoded once into the spine, instances registered for runtime
+     * `tool.execute()` dispatch.
+     *
+     * Only applied when `systemPrompt` is also set (shared mode); ignored
+     * otherwise.
+     */
+    tools?: Tool[];
+    /**
+     * Whether to enable thinking-mode tokens (e.g. `<think>` blocks) when
+     * formatting the spine's chat-format header. Threaded through to the
+     * chat-format call AND stored on the `SpineFmt` FormatConfig so
+     * `setupAgent`'s shared-mode shortcut copies a parser/grammar/triggers
+     * configuration consistent with the per-agent suffix formatting.
+     *
+     * Should match the `enableThinking` value the caller passes to the agent
+     * pool — divergent values produce inconsistent grammar between the
+     * prefilled spine and per-agent suffixes.
+     *
+     * @default false
+     */
+    enableThinking?: boolean;
+}
+/**
+ * Scoped spine branch with guaranteed cleanup
+ *
+ * Creates (or forks) the pool's spine — the shared KV line that agents
+ * fork from and that `ctx.extendSpine` writes onto between tasks. The
+ * spine is pruned via try/finally when the body returns or throws,
+ * regardless of whether children still exist.
+ *
+ * Each agent's chat format (system + user + generation prompt) is rendered
+ * fresh inside `setupAgent`, so this spine carries no chat context itself —
+ * it exists as the pool's branching point and as the line that
+ * `ctx.extendSpine` writes onto between tasks.
+ *
+ * **Cold path** (no `parent`): creates a spine at position 0 with no prefill.
+ * Agents fork at position 0; their full chat context lives in their own suffix.
+ *
+ * **Warm path** (`parent` provided): forks from parent and prefills a turn
+ * separator so subsequent agent suffixes land on a clean turn boundary.
+ * Sub-agents inherit the parent's full KV state via the fork.
+ *
+ * @param opts - Sampling parameters and optional parent branch
+ * @param body - Operation that receives the spine branch and prefix length.
+ *   Typically calls {@link useAgentPool} inside.
+ * @returns The body's return value
+ *
+ * @category Agents
+ */
+export declare function withSpine<T>(opts: SpineOptions, body: (spine: Branch, prefixLength: number) => Operation<T>): Operation<T>;
+//# sourceMappingURL=spine.d.ts.map

package/dist/spine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spine.d.ts","sourceRoot":"","sources":["../src/spine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAK1C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAiB,SAAS,CAAC,CAAC,EAC1B,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,GAC1D,SAAS,CAAC,CAAC,CAAC,CAwHd"}