@xandreed/sdk 0.4.0 → 0.11.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/sdk
 
-Efferent composable agent framework, 0.4.0. Bun on Linux.
+Efferent composable agent framework, 0.11.0. Node 24 or Bun.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/agent.adapter.d.ts

@@ -0,0 +1,58 @@
+import { Context, Effect } from "effect";
+import type { Scope } from "effect";
+import { HarnessError } from "@xandreed/core";
+import type { Capability, LoopLimits, Plugin, Turn, TurnInput, TurnOutcome, TurnServices } from "@xandreed/core";
+/** One plugin instance of an agent: the definition, its options and (optionally) an instance id. */
+export interface AgentPluginEntry {
+    readonly plugin: Plugin;
+    /** Defaults to the plugin id. */
+    readonly id?: string;
+    readonly options?: Readonly<Record<string, unknown>>;
+}
+/** Everything an agent is made of. Swapping a strategy is swapping one entry. */
+export interface AgentConfig {
+    /** Memory log and strategy, tool registry, step loop, and any capability plugins. */
+    readonly plugins: ReadonlyArray<Plugin | AgentPluginEntry>;
+    /** Which instance provides a service several plugins provide. */
+    readonly bindings?: Readonly<Record<string, string>>;
+    /** The host's own tools, views, skills and prompt sections. */
+    readonly capabilities?: ReadonlyArray<Capability>;
+    /** Process-lifetime host services plugins may require. */
+    readonly services?: Context.Context<never>;
+    /** Keys every turn's services must carry; session plugins may require them. */
+    readonly turnServices?: ReadonlyArray<{
+        readonly key: string;
+    }>;
+    /** The system prompt prefix, before the contributed sections. */
+    readonly system?: string;
+    /** The prompt-cache key is `<prefix>:<conversation>`; none is sent without a prefix. */
+    readonly cacheKeyPrefix?: string;
+    readonly workspace?: string;
+    /** Defaults for every run; a turn's policy overrides them. */
+    readonly limits?: Partial<LoopLimits>;
+    /** Input tokens one request may use (system, tool schemas and messages). */
+    readonly budgetTokens?: number;
+    /** How deep event reactions may nest before the bus fails the publisher. */
+    readonly maxEventDepth?: number;
+}
+/** A defined agent: its graph is built; each turn is composed by the host. */
+export interface Agent {
+    readonly fingerprint: string;
+    /**
+     * Run one turn: one the host began (its `TurnWriter`; the host ends it),
+     * or one begun and ended here through the `Sessions` in the turn's
+     * services. The turn is scoped: its subscriptions and tasks end with it.
+     * On success, tasks and background subscriptions settle as the scopes
+     * close in dependency order, before the reply is recorded exactly once.
+     * Failures and interruptions record a failed reply and cancel remaining
+     * scoped work; recorded events are stored before the turn returns. A turn closed
+     * elsewhere (cancelled, reaped) fails with `turn.closed`. `use` runs in
+     * the turn's scope with the turn's services (RunContext, TurnEvents,
+     * TurnTasks and the input's `layer`) provided: the same instances the
+     * tools, policy and subscriptions see.
+     */
+    readonly turn: <A = never, E = never, R = never>(input: TurnInput<A, E>, use: (turn: Turn) => Effect.Effect<TurnOutcome, HarnessError, R>) => Effect.Effect<TurnOutcome, HarnessError | E, Exclude<R, A | TurnServices | Scope.Scope>>;
+}
+export declare const Agent: {
+    define: (config: AgentConfig) => Effect.Effect<Agent, HarnessError, Scope.Scope>;
+};

package/dist/agent.adapter.js

@@ -0,0 +1,94 @@
+import { Context, Effect, Option, Schema } from "effect";
+import {
+  cacheKeyOf,
+  CapabilitiesLive,
+  Capabilities,
+  ConversationMemory,
+  definePlugin,
+  guardTurn,
+  harnessDefectsAsFailures,
+  HarnessError,
+  openTurnTools,
+  SessionEnvironment,
+  Sessions,
+  StepLoop,
+  ToolRegistry,
+  RunContext,
+  settleTurn,
+  TurnEvents,
+  TurnTasks,
+  TurnLive,
+  TurnMemory,
+  TurnPrompt,
+  TurnToolbox,
+  turnOf
+} from "@xandreed/core";
+import { activateGraph, graphFingerprint, resolveGraph } from "@xandreed/runtime";
+const failure = (code, message) => new HarnessError({ code, message }), missing = (key) => failure("service.missing", `The agent's plugins do not provide ${key}`), entryOf = (item) => ("plugin" in item) ? item : { plugin: item }, isWriter = (turn) => ("admitted" in turn), beginCodes = {
+  SessionBusy: "session.busy",
+  TurnDuplicate: "turn.duplicate",
+  KeyConflict: "turn.key-conflict",
+  NothingPending: "session.nothing-pending",
+  TurnRefused: "turn.refused",
+  SessionMissing: "session.missing",
+  SessionLogError: "session.log"
+}, beginTurn = (context, turn) => required(context, Sessions).pipe(Effect.flatMap((sessions) => sessions.begin(turn.session, {
+  _tag: "User",
+  userMessage: turn.userMessage,
+  runId: turn.runId,
+  key: turn.key ?? turn.runId,
+  command: turn.command ?? {}
+})), Effect.mapError((error) => error instanceof HarnessError ? error : failure(beginCodes[error._tag], `the turn could not begin (${error._tag}) in session ${turn.session.id}`))), untilClosed = (writer) => (body) => Effect.raceFirst(body, writer.closed.pipe(Effect.flatMap((closed) => Effect.fail(failure("turn.closed", `turn ${closed.turn} was ${closed.reason}`))))), required = (context, tag) => Option.match(Context.getOption(context, tag), { onNone: () => Effect.fail(missing(tag.key)), onSome: Effect.succeed }), provideHostLayer = (layer) => (effect) => Option.match(layer, { onNone: () => effect, onSome: (hostLayer) => effect.pipe(Effect.provide(hostLayer, { local: !0 })) }), hostCapabilities = (capabilities) => definePlugin({
+  id: "@xandreed/sdk/host-contributions",
+  version: "1",
+  scope: "runtime",
+  config: Schema.Struct({}),
+  defaults: {},
+  provides: [],
+  contributes: [Capabilities],
+  layer: () => CapabilitiesLive(...capabilities)
+}), builtInTurnKeys = [RunContext, TurnEvents, TurnTasks, TurnMemory, TurnPrompt, TurnToolbox].map((tag) => tag.key), turnDependentNodes = (graph) => graph.nodes.reduce((late, node) => {
+  return [...node.plugin.requires, ...node.plugin.optional ?? []].some((key) => builtInTurnKeys.includes(key) || late.some((source) => source.plugin.provides.includes(key) || (source.plugin.contributes ?? []).includes(key))) ? [...late, node] : late;
+}, []), makeAgent = (config) => Effect.gen(function* () {
+  const parent = yield* Effect.scope, entries = config.plugins.map(entryOf), hosted = config.capabilities ?? [], host = hostCapabilities(hosted), withHost = hosted.length > 0, plugins = [...withHost ? [host] : [], ...entries.map((entry) => entry.plugin)], harness = {
+    version: 1,
+    plugins: [
+      ...withHost ? [{ id: host.id, use: host.id }] : [],
+      ...entries.map((entry) => ({ id: entry.id ?? entry.plugin.id, use: entry.plugin.id, options: { ...entry.options } }))
+    ],
+    ...config.bindings === void 0 ? {} : { bindings: { ...config.bindings } },
+    system: config.system ?? ""
+  }, services = config.services ?? Context.empty(), turnKeys = (config.turnServices ?? []).map((tag) => tag.key), external = [SessionEnvironment.key, ...services.mapUnsafe.keys(), ...turnKeys, ...builtInTurnKeys], graph = yield* resolveGraph(harness, plugins, external), late = turnDependentNodes(graph), invalidLate = late.find((node) => node.plugin.scope === "runtime" || node.plugin.provides.some((key) => [ConversationMemory.key, ToolRegistry.key, StepLoop.key].includes(key)));
+  if (invalidLate !== void 0)
+    return yield* Effect.fail(failure("config.graph", `${invalidLate.entry.id}: a plugin requiring turn services must be session-scoped and cannot supply the turn's memory, registry or loop`));
+  const beforeTurn = { ...graph, nodes: graph.nodes.filter((node) => !late.includes(node)) }, afterTurn = { ...graph, nodes: late }, workspace = config.workspace ?? ".", seed = Context.add(services, SessionEnvironment, { workspace }), runtime = yield* activateGraph(beforeTurn, "runtime", Context.makeUnsafe(seed.mapUnsafe), parent), perTurn = beforeTurn.nodes.some((node) => node.plugin.scope === "session"), turn = (input, use) => harnessDefectsAsFailures(Effect.scoped(Effect.gen(function* () {
+    const scope = yield* Effect.scope, absent = turnKeys.filter((key) => !input.services.mapUnsafe.has(key));
+    if (absent.length > 0)
+      return yield* Effect.fail(failure("service.missing", `The turn does not provide ${absent.join(", ")}`));
+    const merged = Context.merge(runtime, input.services), context = perTurn ? yield* activateGraph(beforeTurn, "session", merged, scope) : merged, memory = yield* required(context, ConversationMemory), registry = yield* required(context, ToolRegistry), loop = yield* required(context, StepLoop), own = !isWriter(input.turn), writer = isWriter(input.turn) ? input.turn : yield* beginTurn(context, input.turn), system = input.system ?? config.system, live = {
+      turn: writer,
+      ...system === void 0 ? {} : { system },
+      ...config.maxEventDepth === void 0 ? {} : { maxEventDepth: config.maxEventDepth }
+    }, runOptions = {
+      ...config.limits === void 0 ? {} : { limits: config.limits },
+      ...config.budgetTokens === void 0 ? {} : { budgetTokens: config.budgetTokens },
+      cacheKey: Option.orElse(Option.fromNullishOr(input.cacheKey), () => cacheKeyOf(config.cacheKeyPrefix ?? "", writer.admitted.session.id)),
+      ...input.steering === void 0 ? {} : { steering: input.steering }
+    }, body = Effect.gen(function* () {
+      yield* (yield* TurnMemory).persistMessage;
+      yield* openTurnTools;
+      return yield* use(yield* turnOf(runOptions));
+    }), provideTurnPlugins = (effect) => late.length === 0 ? effect : Effect.gen(function* () {
+      const liveContext = yield* Effect.context();
+      return yield* Effect.scoped(Effect.gen(function* () {
+        const activated = yield* activateGraph(afterTurn, "session", Context.merge(context, liveContext), yield* Effect.scope);
+        return yield* effect.pipe(Effect.provide(activated));
+      }));
+    }), outcome = yield* body.pipe(Effect.tap(() => settleTurn), Effect.scoped, Effect.tap(() => settleTurn), provideHostLayer(Option.fromNullishOr(input.layer)), Effect.tap(() => settleTurn), provideTurnPlugins, guardTurn, Effect.provide(TurnLive(live), { local: !0 }), Effect.provideService(ConversationMemory, memory), Effect.provideService(ToolRegistry, registry), Effect.provideService(StepLoop, loop), Effect.provide(context), untilClosed(writer));
+    if (own)
+      yield* writer.end({ reason: outcome.outcome, failure: Option.none() });
+    return outcome;
+  })));
+  return { fingerprint: graphFingerprint(graph), turn };
+});
+export const Agent = { define: makeAgent };

package/dist/agent.adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent.backends.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent.golden.test.d.ts

@@ -0,0 +1,190 @@
+import { Tool } from "effect/ai";
+import { Effect, Layer, Schema, Scope } from "effect";
+import { HarnessError, SessionLog } from "@xandreed/core";
+import { Agent } from "./agent.adapter.js";
+import type { AgentConfig } from "./agent.adapter.js";
+export declare const Lookup: Tool.Tool<"lookup", {
+    readonly parameters: Schema.Struct<{
+        readonly query: Schema.String;
+    }>;
+    readonly success: Schema.Struct<{
+        readonly items: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly detail: Schema.String;
+        }>>;
+    }>;
+    readonly failure: Schema.Struct<{
+        readonly error: Schema.String;
+        readonly message: Schema.String;
+    }>;
+    readonly failureMode: "return";
+}, never>;
+export declare const Deliver: Tool.Tool<"deliver", {
+    readonly parameters: Schema.Struct<{
+        readonly text: Schema.String;
+    }>;
+    readonly success: Schema.Boolean;
+    readonly failure: Schema.Struct<{
+        readonly error: Schema.String;
+        readonly message: Schema.String;
+    }>;
+    readonly failureMode: "return";
+}, never>;
+export declare const goldenHost: import("@xandreed/core").Capability;
+/** The agent every composition of the golden conversation reproduces. */
+export declare const goldenConfig: AgentConfig;
+/** What one turn left: its outcome (or failure), the events its host saw and what the memory held. */
+interface Observed {
+    readonly runId: string;
+    readonly outcome: unknown;
+    readonly events: ReadonlyArray<string>;
+    readonly contextBuilt: ReadonlyArray<unknown>;
+    readonly entries: number;
+}
+/**
+ * The golden conversation over `runner` — anything that runs a turn the way
+ * `Agent.turn` does, acquired in the conversation's scope — under the fixed
+ * clock, in one session of `log` (in memory unless given): every turn, then
+ * the session's events and the memory log they hold.
+ */
+export declare const runGolden: (runner: Effect.Effect<Pick<Agent, "turn">, HarnessError, Scope.Scope>, log?: Layer.Layer<SessionLog, unknown>) => Effect.Effect<{
+    turns: readonly Observed[];
+    journal: string[];
+    log: readonly {
+        readonly id: string;
+        readonly runId: string;
+        readonly turn: number;
+        readonly step: number;
+        readonly at: number;
+        readonly body: {
+            readonly _tag: "SystemPrepared";
+            readonly fingerprint: string;
+            readonly text: string;
+            readonly sections: readonly {
+                readonly id: string;
+                readonly version: string;
+                readonly fingerprint: string;
+            }[];
+        } | {
+            readonly _tag: "TurnStarted";
+            readonly prompt: string;
+        } | {
+            readonly _tag: "TurnContext";
+            readonly sectionId: string;
+            readonly version: string;
+            readonly text: string;
+        } | {
+            readonly _tag: "Message";
+            readonly message: {
+                readonly role: "user";
+                readonly content: string;
+                readonly providerOptions?: unknown;
+            } | {
+                readonly role: "assistant";
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly providerOptions?: unknown;
+                } | {
+                    readonly type: "reasoning";
+                    readonly text: string;
+                    readonly providerOptions?: unknown;
+                } | {
+                    readonly type: "tool-call";
+                    readonly toolCallId: string;
+                    readonly toolName: string;
+                    readonly input: unknown;
+                    readonly providerOptions?: unknown;
+                    readonly providerExecuted?: boolean | undefined;
+                })[];
+                readonly providerOptions?: unknown;
+            } | {
+                readonly role: "tool";
+                readonly content: readonly {
+                    readonly type: "tool-result";
+                    readonly toolCallId: string;
+                    readonly toolName: string;
+                    readonly output: unknown;
+                    readonly providerOptions?: unknown;
+                    readonly isError?: boolean | undefined;
+                }[];
+                readonly providerOptions?: unknown;
+            };
+        } | {
+            readonly _tag: "ToolResult";
+            readonly toolCallId: string;
+            readonly toolName: string;
+            readonly isError: boolean;
+            readonly encoded: unknown;
+            readonly view: string;
+            readonly viewVersion: string;
+            readonly subjects: readonly {
+                readonly kind: string;
+                readonly id: string;
+                readonly label: string | null;
+                readonly data: unknown;
+            }[];
+            readonly artifacts: readonly {
+                readonly id: string;
+                readonly kind: "image" | "file";
+                readonly mediaType: string;
+                readonly url: string;
+                readonly alt: string | null;
+            }[];
+            readonly pinned: boolean;
+        } | {
+            readonly _tag: "ToolDigest";
+            readonly entry: string;
+            readonly version: string;
+            readonly mode: "select" | "summarize";
+            readonly keep: readonly string[];
+            readonly text: string;
+            readonly digester: string;
+            readonly trigger: "write" | "compaction";
+        } | {
+            readonly _tag: "StepContext";
+            readonly step: number;
+            readonly text: string;
+        } | {
+            readonly _tag: "ToolsActivated";
+            readonly skills: readonly string[];
+            readonly tools: readonly string[];
+            readonly source: "always" | "matcher" | "load_skill" | "host";
+            readonly decision: string | null;
+        } | {
+            readonly _tag: "Compaction";
+            readonly strategy: string;
+            readonly version: string;
+            readonly action: {
+                readonly _tag: "CompactViews";
+                readonly entries: readonly string[];
+                readonly texts: readonly string[];
+            } | {
+                readonly _tag: "Spill";
+                readonly entry: string;
+                readonly preview: string;
+            } | {
+                readonly _tag: "DropTurns";
+                readonly throughTurn: number;
+                readonly ledger: string;
+            } | {
+                readonly _tag: "Summarize";
+                readonly keepFromTurn: number;
+                readonly summary: string;
+            };
+        } | {
+            readonly _tag: "TurnEnded";
+            readonly outcome: "partial" | "completed" | "failed";
+            readonly reply: string | null;
+        };
+    }[];
+    requests: readonly unknown[];
+}, unknown, never>;
+/** The golden conversation's two halves, each as the exact text of its file. */
+export declare const goldenTexts: (result: Effect.Success<ReturnType<typeof runGolden>>) => {
+    model: string;
+    journal: string;
+};
+/** Compare a run with both golden files (and rewrite the ones the environment asks for). */
+export declare const expectGolden: (result: Effect.Success<ReturnType<typeof runGolden>>) => Promise<void>;
+export {};

package/dist/approval.adapter.d.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { Approval } from "@xandreed/core";
 import type { HarnessError } from "@xandreed/core";
 /** A host supplies interaction; unattended hosts deny requests by default. */
-export declare const approvalPlugin: (request?: (description: string) => Effect.Effect<boolean, HarnessError>) => import("@xandreed/core").Plugin;
+export declare const approvalPlugin: (request?: (description: string) => Effect.Effect<boolean, HarnessError>) => import("@xandreed/core").TypedPlugin<{}, {}, Approval, never, never>;

package/dist/approval.adapter.js

@@ -2,7 +2,7 @@ import { Effect, Layer, Schema } from "effect";
 import { Approval, definePlugin } from "@xandreed/core";
 export const approvalPlugin = (request = () => Effect.succeed(!1)) => definePlugin({
   id: "efferent/approval-host",
-  version: "0.4.0",
+  version: "0.11.0",
   scope: "runtime",
   config: Schema.Struct({}),
   defaults: {},

package/dist/domain-session.adapter.d.ts

@@ -1,7 +1,12 @@
 import { Effect, Option } from "effect";
 import { HarnessError, SessionStore } from "@xandreed/core";
 import type { ConversationId, Session, SessionHandle } from "@xandreed/core";
-/** Adapt a domain session's event protocol to the durable harness lifecycle. */
+/**
+ * Adapt a domain session's event protocol to the durable harness lifecycle.
+ * When the host provides a ConversationStore, the domain session's writes to
+ * its conversation are bound to the harness run (see `turnBound`). They are
+ * recorded beside the turn, not through its writer.
+ */
 export declare const domainLoop: <E extends {
     readonly type: string;
 }, R>(options: {

package/dist/domain-session.adapter.js

@@ -1,26 +1,47 @@
-import { Effect, Fiber, Option, Ref, Stream } from "effect";
-import { AgentLoop, HarnessError, SessionEnvironment, SessionStore } from "@xandreed/core";
+import { Context, Effect, Fiber, Filter, Option, Ref, Stream } from "effect";
+import { AgentLoop, ConversationStore, HarnessError, SessionEnvironment, SessionStore, StoreError } from "@xandreed/core";
+const turnBound = (store, id, active, current) => {
+  const guard = (target, write) => target !== id ? write : Effect.gen(function* () {
+    const origin = yield* current, running = yield* Ref.get(active);
+    return yield* Option.isSome(origin) && Option.contains(running, origin.value) ? write : Effect.fail(new StoreError({ message: `conversation ${id}: its turn is over, so the write is refused` }));
+  });
+  return ConversationStore.of({
+    ...store,
+    append: (target, message) => guard(target, store.append(target, message)),
+    appendAll: (target, messages) => guard(target, store.appendAll(target, messages)),
+    checkpoint: (target, summary) => guard(target, store.checkpoint(target, summary)),
+    checkpointAt: (target, summary, position) => guard(target, store.checkpointAt(target, summary, position)),
+    setTitle: (target, title) => guard(target, store.setTitle(target, title)),
+    recordOutcome: (target, outcome, reason) => guard(target, store.recordOutcome(target, outcome, reason))
+  });
+};
 export const domainLoop = (options) => Effect.gen(function* () {
-  const context = yield* Effect.context(), store = yield* SessionStore, environment = yield* Effect.serviceOption(SessionEnvironment), acquire = (id) => Effect.gen(function* () {
+  const context = yield* Effect.context(), store = yield* SessionStore, environment = yield* Effect.serviceOption(SessionEnvironment), conversations = yield* Effect.serviceOption(ConversationStore), currentDomainRun = Context.Reference(`@xandreed/sdk/domainRun/${yield* Effect.sync(() => crypto.randomUUID())}`, { defaultValue: () => Option.none() }), running = yield* Ref.make(Option.none()), acquire = (id) => Effect.gen(function* () {
     if (options.restore !== void 0) {
       const snapshot = (yield* store.read(id, -1)).filter((event) => event.name === "domain.snapshot").at(-1);
       if (snapshot !== void 0)
         yield* options.restore(id, snapshot.data).pipe(Effect.provide(context));
     }
-    return yield* options.create(id).pipe(Effect.provide(context));
+    const created = options.create(id);
+    return yield* Option.match(conversations, {
+      onNone: () => created,
+      onSome: (conversation) => created.pipe(Effect.provideService(ConversationStore, turnBound(conversation, id, running, currentDomainRun)))
+    }).pipe(Effect.provide(context));
   }), record = Option.isSome(environment) ? environment.value.session : void 0, active = yield* Ref.make(record === void 0 ? Option.none() : Option.some(yield* acquire(record.id)));
   yield* Effect.addFinalizer(() => Ref.get(active).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.void, onSome: (session) => session.shutdown }))));
   return AgentLoop.of({ run: (input) => Effect.scoped(Effect.gen(function* () {
+    const token = yield* Effect.sync(() => crypto.randomUUID());
+    yield* Ref.set(running, Option.some(token));
     const found = yield* Ref.get(active), session = Option.isSome(found) ? found.value : yield* acquire(input.session.id).pipe(Effect.tap((value) => Ref.set(active, Option.some(value)))), cursor = (yield* session.state).cursor, result = yield* Ref.make(Option.none()), collector = yield* Effect.forkScoped(session.subscribe(cursor).pipe(Stream.tap(({ event }) => input.publish({ name: "domain.event", runId: input.runId, data: { event } })), Stream.tap(({ event }) => Ref.update(result, (current) => Option.orElse(options.result(event), () => current))), Stream.takeUntil(({ event }) => Option.isSome(options.result(event))), Stream.runDrain));
     yield* Effect.forkScoped(session.transient.pipe(Stream.runForEach((event) => input.transient({ name: "domain.delta", runId: input.runId, data: { event } }))));
-    yield* session.send(input.prompt);
+    yield* session.send(input.userMessage.text).pipe(Effect.provideService(currentDomainRun, Option.some(token)));
     if (!(yield* session.state).log.filter((entry) => entry.seq >= cursor).some(({ event }) => Option.isSome(options.result(event))))
       return yield* Effect.fail(new HarnessError({ code: "domain.unsettled", message: "The domain turn ended without a terminal event" }));
     yield* Fiber.join(collector);
     if (options.snapshot !== void 0)
       yield* options.snapshot(input.session.id).pipe(Effect.provide(context), Effect.flatMap((data) => input.publish({ name: "domain.snapshot", runId: input.runId, data })));
     return yield* Ref.get(result).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.fail(new HarnessError({ code: "domain.result", message: "The domain session ended without a result" })), onSome: Effect.succeed })));
-  })).pipe(Effect.onInterrupt(() => Ref.get(active).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.void, onSome: (session) => session.interrupt }))))) });
+  })).pipe(Effect.ensuring(Ref.set(running, Option.none())), Effect.onInterrupt(() => Ref.get(active).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.void, onSome: (session) => session.interrupt }))))) });
 }), domainSession = (handle, decode, onError) => {
   const event = (name, data) => name === "domain.event" ? decode(data.event) : ["run.failed", "run.cancelled"].includes(name) ? Option.some(onError(String(data.message))) : Option.none();
   return {
@@ -29,7 +50,7 @@ export const domainLoop = (options) => Effect.gen(function* () {
     interrupt: handle.interrupt,
     shutdown: handle.close,
     state: handle.history.pipe(Effect.map((events) => ({ cursor: (events.at(-1)?.seq ?? -1) + 1, log: events.flatMap((entry) => Option.toArray(Option.map(event(entry.name, entry.data), (value) => ({ seq: entry.seq, event: value })))) })), Effect.orDie),
-    subscribe: (since) => handle.events(since - 1).pipe(Stream.map((entry) => Option.map(event(entry.name, entry.data), (value) => ({ seq: entry.seq, event: value }))), Stream.filterMap((value) => value), Stream.orDie),
-    transient: handle.transient.pipe(Stream.filterMap((entry) => entry.name === "domain.delta" ? decode(entry.data.event) : Option.none()))
+    subscribe: (since) => handle.events(since - 1).pipe(Stream.map((entry) => Option.map(event(entry.name, entry.data), (value) => ({ seq: entry.seq, event: value }))), Stream.filterMap(Filter.fromPredicateOption((value) => value)), Stream.orDie),
+    transient: handle.transient.pipe(Stream.filterMap(Filter.fromPredicateOption((entry) => entry.name === "domain.delta" ? decode(entry.data.event) : Option.none())))
   };
 };

package/dist/harness.d.ts

@@ -40,4 +40,4 @@ export declare const Harness: {
         reconfigure: (config: HarnessConfig, plugins?: ReadonlyArray<Plugin>) => Effect.Effect<"applied" | "restart-required", HarnessError, never>;
     }, HarnessError, Scope.Scope>;
 };
-export type Harness = Effect.Effect.Success<ReturnType<typeof makeHarness>>;
+export type Harness = Effect.Success<ReturnType<typeof makeHarness>>;

package/dist/harness.js

@@ -1,30 +1,44 @@
-import { Cause, Context, Effect, Exit, Fiber, Option, PubSub, Ref, Scope, Stream } from "effect";
-import { AgentLoop, HarnessError, SessionEnvironment, SessionStore, TurnHooks } from "@xandreed/core";
+import { Cause, Clock, Context, Effect, Exit, Fiber, Option, PubSub, Ref, Scope, Stream, Semaphore } from "effect";
+import { AgentLoop, HarnessError, SessionEnvironment, SessionStore, Sessions, TurnHooks, UserMessage } from "@xandreed/core";
 import { activateGraph, graphFingerprint, resolveGraph } from "@xandreed/runtime";
-const failure = (code, message) => new HarnessError({ code, message }), service = (context, tag) => Option.match(Context.getOption(context, tag), {
+const failure = (code, message) => new HarnessError({ code, message }), pendingAfter = (queue, events) => events.reduce((pending, event) => {
+  if (event.name === "input.queued" && typeof event.data.id === "string" && typeof event.data.text === "string") {
+    const id = event.data.id;
+    return pending.some((input) => input.id === id) ? pending : [...pending, { id, text: event.data.text, kind: event.data.kind === "steer" ? "steer" : "turn" }];
+  }
+  return event.name === "input.claimed" ? pending.filter((input) => input.id !== event.data.id) : pending;
+}, queue), advance = (state, events) => {
+  const fresh = events.filter((event) => event.seq > state.seen);
+  return fresh.length === 0 ? state : { seen: fresh.reduce((last, event) => Math.max(last, event.seq), state.seen), queue: pendingAfter(state.queue, fresh) };
+}, isClosed = (error) => error.code === "turn.closed", service = (context, tag) => Option.match(Context.getOption(context, tag), {
   onNone: () => Effect.fail(failure("service.missing", `The profile does not provide ${tag.key}`)),
   onSome: Effect.succeed
 });
 export const makeHarness = (options) => Effect.gen(function* () {
-  const parent = yield* Effect.scope, initial = yield* resolveGraph(options.config, options.plugins, [SessionEnvironment.key]), graphRef = yield* Ref.make(initial), registryRef = yield* Ref.make(options.plugins), seed = Context.make(SessionEnvironment, { workspace: options.workspace }), runtime = yield* activateGraph(initial, "runtime", Context.unsafeMake(seed.unsafeMap), parent), store = yield* service(runtime, SessionStore), handles = yield* Ref.make(new Map), open = (record) => Effect.gen(function* () {
+  const parent = yield* Effect.scope, initial = yield* resolveGraph(options.config, options.plugins, [SessionEnvironment.key]), graphRef = yield* Ref.make(initial), registryRef = yield* Ref.make(options.plugins), seed = Context.make(SessionEnvironment, { workspace: options.workspace }), runtime = yield* activateGraph(initial, "runtime", Context.makeUnsafe(seed.mapUnsafe), parent), store = yield* service(runtime, SessionStore), sessions = yield* Option.match(Context.getOption(runtime, Sessions), {
+    onNone: () => Effect.fail(failure("service.missing", `Harness requires ${Sessions.key}: add sessionsPlugin (@xandreed/plugin-sessions) to the configuration beside the session storage plugin`)),
+    onSome: Effect.succeed
+  }), handles = yield* Ref.make(new Map), open = (record) => Effect.gen(function* () {
     const existing = (yield* Ref.get(handles)).get(record.id);
     if (existing !== void 0)
       return existing;
-    const journal = yield* store.read(record.id, -1), abandoned = journal.reduce((runs, event) => {
+    const journal = yield* store.read(record.id, -1), durable = yield* sessions.get({ id: record.id, owner: options.workspace }).pipe(Effect.mapError((error) => failure("session.log", String(error)))), abandoned = journal.reduce((runs, event) => {
       if (event.runId === void 0)
         return runs;
       return event.name === "run.started" ? [...runs, event.runId] : ["run.completed", "run.cancelled", "run.failed"].includes(event.name) ? runs.filter((id) => id !== event.runId) : runs;
     }, []);
-    yield* Effect.forEach(abandoned, (runId) => store.append(record.id, { name: "run.cancelled", runId, data: { reason: "process interrupted before settlement; tool effects may be incomplete" } }));
-    const pending = yield* Ref.make(journal.reduce((queue, event) => {
-      if (event.name === "input.queued" && typeof event.data.id === "string" && typeof event.data.text === "string")
-        return [...queue, { id: event.data.id, text: event.data.text, kind: event.data.kind === "steer" ? "steer" : "turn" }];
-      return event.name === "input.claimed" ? queue.filter((input) => input.id !== event.data.id) : queue;
-    }, [])), notifications = yield* PubSub.sliding(1), transientHub = yield* PubSub.sliding(128), running = yield* Ref.make(Option.none()), busy = yield* Ref.make(!1), closed = yield* Ref.make(!1), gate = yield* Effect.makeSemaphore(1), acquire = (graph) => Effect.gen(function* () {
-      const scope = yield* Scope.make(), sessionSeed = Context.add(runtime, SessionEnvironment, { workspace: options.workspace, session: record }), context = yield* activateGraph(graph, "session", Context.unsafeMake(sessionSeed.unsafeMap), scope).pipe(Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))));
+    yield* Effect.forEach(abandoned.filter((runId) => !Option.exists(durable.open, (open) => open.runId === runId)), (runId) => store.append(record.id, { name: "run.cancelled", runId, data: { reason: "process interrupted before settlement; tool effects may be incomplete" } }));
+    const pending = yield* Ref.make(advance({ seen: -1, queue: [] }, journal)), notifications = yield* PubSub.sliding(1), transientHub = yield* PubSub.sliding(128), running = yield* Ref.make(Option.none()), busy = yield* Ref.make(!1), closed = yield* Ref.make(!1), writing = yield* Ref.make(Option.none()), position = yield* Ref.make(-1), publishing = yield* Semaphore.make(1), gate = yield* Semaphore.make(1), acquire = (graph) => Effect.gen(function* () {
+      const scope = yield* Scope.make(), sessionSeed = Context.add(runtime, SessionEnvironment, { workspace: options.workspace, session: record }), context = yield* activateGraph(graph, "session", Context.makeUnsafe(sessionSeed.mapUnsafe), scope).pipe(Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))));
       yield* service(context, AgentLoop).pipe(Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))));
       return { context, scope, graph, fingerprint: graphFingerprint(graph) };
-    }), mounted = yield* Ref.make(yield* acquire(yield* Ref.get(graphRef))), publish = (body) => store.append(record.id, body).pipe(Effect.tap(() => PubSub.publish(notifications, void 0))), assertOpen = Ref.get(closed).pipe(Effect.flatMap((value) => value ? Effect.fail(failure("session.closed", "Session is closed")) : Effect.void)), refresh = Effect.gen(function* () {
+    }), mounted = yield* Ref.make(yield* acquire(yield* Ref.get(graphRef))), publishUnlocked = (body, outside = !1) => Ref.get(writing).pipe(Effect.flatMap(Option.match({
+      onNone: () => store.append(record.id, body),
+      onSome: (writer) => writer.transact((foreign) => Effect.gen(function* () {
+        const foreignPosition = foreign.reduce((max, entry) => entry.kind === "harness.event" && typeof entry.data.event === "object" && entry.data.event !== null && ("seq" in entry.data.event) && typeof entry.data.event.seq === "number" ? Math.max(max, entry.data.event.seq) : max, -1), seq = Math.max(yield* Ref.get(position), foreignPosition) + 1, event = { ...body, version: 1, id: yield* Effect.sync(() => crypto.randomUUID()), sessionId: record.id, seq, at: yield* Clock.currentTimeMillis };
+        return { drafts: [{ kind: "harness.event", data: { event } }], result: event };
+      })).pipe(Effect.map((done) => done.result), Effect.tap((event) => Ref.set(position, event.seq)), Effect.catchTag("HarnessError", (error) => outside && isClosed(error) ? store.append(record.id, body) : Effect.fail(error)))
+    })), Effect.tap(() => PubSub.publish(notifications, void 0))), publish = (body) => publishing.withPermits(1)(publishUnlocked(body)), refreshPending = Ref.get(pending).pipe(Effect.flatMap((state) => store.read(record.id, state.seen)), Effect.flatMap((events) => Ref.update(pending, (state) => advance(state, events)))), assertOpen = Ref.get(closed).pipe(Effect.flatMap((value) => value ? Effect.fail(failure("session.closed", "Session is closed")) : Effect.void)), refresh = Effect.gen(function* () {
       if (yield* Ref.get(busy))
         return;
       const graph = yield* Ref.get(graphRef), previous = yield* Ref.get(mounted);
@@ -34,62 +48,93 @@ export const makeHarness = (options) => Effect.gen(function* () {
       yield* Ref.set(mounted, next);
       yield* Scope.close(previous.scope, Exit.void);
       yield* publish({ name: "config.applied", data: { fingerprint: next.fingerprint } });
-    }), claim = (input) => publish({ name: "input.claimed", data: { id: input.id } }).pipe(Effect.zipRight(Ref.update(pending, (queue) => queue.filter((item) => item.id !== input.id)))), steering = Effect.gen(function* () {
-      const inputs = (yield* Ref.get(pending)).filter((input) => input.kind === "steer");
+    }), endedElsewhere = (writer) => sessions.read({ id: record.id, owner: options.workspace }, { after: writer.started.seq, kinds: ["turn.ended"] }).pipe(Effect.map((events) => Option.map(Option.fromNullishOr(events.find((event) => Option.contains(event.turn, writer.admitted.turn))), (event) => event.data.reason === "cancelled" ? "cancelled" : "interrupted")), Effect.catchTag("SessionMissing", () => Effect.succeed(Option.some("removed"))), Effect.mapError((error) => failure("session.log", error.message))), claim = (input) => publish({ name: "input.claimed", data: { id: input.id } }).pipe(Effect.andThen(refreshPending)), steering = Effect.gen(function* () {
+      yield* refreshPending;
+      const inputs = (yield* Ref.get(pending)).queue.filter((input) => input.kind === "steer");
       yield* Effect.forEach(inputs, claim);
       return inputs.length === 0 ? Option.none() : Option.some(inputs.map((input) => input.text).join(`
 
 `));
-    }), run = (input) => Effect.gen(function* () {
+    }), run = (input) => Effect.scoped(Effect.gen(function* () {
       yield* refresh;
-      const current = yield* Ref.get(mounted), loop = yield* service(current.context, AgentLoop), hooks = Context.getOption(current.context, TurnHooks), runId = crypto.randomUUID();
+      const current = yield* Ref.get(mounted), loop = yield* service(current.context, AgentLoop), hooks = Context.getOption(current.context, TurnHooks), runId = crypto.randomUUID(), begun = yield* Effect.result(sessions.begin({ id: record.id, owner: options.workspace }, {
+        _tag: "User",
+        userMessage: new UserMessage({ text: input.text }),
+        runId,
+        key: input.id,
+        command: { kind: input.kind }
+      }));
+      if (begun._tag === "Failure") {
+        if (begun.failure._tag === "TurnDuplicate") {
+          yield* claim(input);
+          return !0;
+        }
+        return yield* Effect.fail(failure(begun.failure._tag === "SessionBusy" ? "session.busy" : "session.begin", `The turn could not begin (${begun.failure._tag})`));
+      }
+      const writer = begun.success;
+      yield* refreshPending;
+      if (!(yield* Ref.get(pending)).queue.some((item) => item.id === input.id)) {
+        yield* writer.end({ reason: "cancelled", failure: Option.some({ code: "input.consumed", message: "the input was consumed by an earlier turn" }) }).pipe(Effect.catchTag("HarnessError", (error) => isClosed(error) ? Effect.void : Effect.fail(error)));
+        return !0;
+      }
+      yield* Ref.set(position, (yield* Ref.get(pending)).seen);
+      yield* Ref.set(writing, Option.some(writer));
+      yield* Effect.addFinalizer(() => Ref.set(writing, Option.none()));
       yield* claim(input);
-      yield* publish({ name: "run.started", runId, data: { config: current.fingerprint } });
+      const started = yield* publish({ name: "run.started", runId, data: { config: current.fingerprint } });
+      if (!(yield* store.read(record.id, started.seq - 1)).some((event) => event.id === started.id))
+        return yield* Effect.fail(failure("session.store", "The SessionStore does not read the events Sessions writes: it must be the projection over the same SessionLog"));
       const args = {
         session: record,
         runId,
-        prompt: input.text,
+        userMessage: new UserMessage({ text: input.text }),
         system: current.graph.config.system ?? "You are a helpful agent.",
         publish,
         transient: (event) => PubSub.publish(transientHub, event).pipe(Effect.asVoid),
-        steering
+        steering,
+        history: (after, names) => store.read(record.id, after).pipe(Effect.map((events) => names.length === 0 ? events : events.filter((event) => names.includes(event.name)))),
+        services: Context.empty()
       }, task = Effect.gen(function* () {
         const prepared = Option.isSome(hooks) ? yield* hooks.value.before(args) : args, result = yield* loop.run(prepared);
         if (Option.isSome(hooks))
           yield* hooks.value.after(prepared);
         return result;
-      }).pipe(Effect.interruptible);
+      }).pipe(Effect.interruptible, Effect.raceFirst(writer.closed.pipe(Effect.flatMap((ended) => Effect.fail(failure("turn.closed", `The turn was ${ended.reason}`))))));
       yield* Ref.set(busy, !0);
+      yield* Effect.addFinalizer(() => Ref.set(busy, !1));
       const fiber = yield* Effect.forkIn(task, parent);
       yield* Ref.set(running, Option.some(fiber));
       const exit = yield* Fiber.await(fiber);
       yield* Ref.set(running, Option.none());
-      yield* Ref.set(busy, !1);
-      yield* Exit.isSuccess(exit) ? publish({ name: "run.completed", runId, data: { ...exit.value } }) : publish({
-        name: Cause.isInterruptedOnly(exit.cause) ? "run.cancelled" : "run.failed",
-        runId,
-        data: { message: Cause.isInterruptedOnly(exit.cause) ? "Cancelled; unfinished tool effects are not replayed" : Cause.pretty(exit.cause) }
+      const elsewhere = yield* endedElsewhere(writer), completed = Exit.isSuccess(exit) && Option.isNone(elsewhere), cancelled = Option.isSome(elsewhere) || Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause), message = Option.match(elsewhere, {
+        onNone: () => Exit.isFailure(exit) ? Cause.hasInterruptsOnly(exit.cause) ? "Cancelled; unfinished tool effects are not replayed" : Cause.pretty(exit.cause) : "",
+        onSome: (reason) => `The turn was ${reason} elsewhere; unfinished tool effects are not replayed`
       });
-      yield* Ref.set(running, Option.none());
-      yield* Ref.set(busy, !1);
-      if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause))
+      if (!Option.contains(elsewhere, "removed"))
+        yield* publishing.withPermits(1)(publishUnlocked(completed && Exit.isSuccess(exit) ? { name: "run.completed", runId, data: { ...exit.value } } : { name: cancelled ? "run.cancelled" : "run.failed", runId, data: { message } }, !0));
+      yield* writer.end({
+        reason: completed && Exit.isSuccess(exit) ? exit.value.outcome : cancelled ? "cancelled" : "failed",
+        failure: completed ? Option.none() : Option.some({ code: "run.failed", message })
+      }).pipe(Effect.catchTag("HarnessError", (error) => isClosed(error) ? Effect.void : Effect.fail(error)));
+      if (Option.isSome(elsewhere) && elsewhere.value !== "cancelled")
+        return yield* Effect.fail(failure("turn.closed", `The turn was ${elsewhere.value} elsewhere`));
+      if (Exit.isFailure(exit) && !cancelled)
         return yield* Effect.fail(failure("run.failed", Cause.pretty(exit.cause)));
-      return Exit.isSuccess(exit);
-    }).pipe(Effect.uninterruptible), drain = gate.withPermits(1)(Effect.gen(function* () {
-      yield* assertOpen;
-      yield* Effect.iterate(!0, { while: (more) => more, body: () => Effect.gen(function* () {
-        if (yield* Ref.get(closed))
-          return !1;
-        const next = (yield* Ref.get(pending))[0];
-        return next === void 0 ? !1 : yield* run(next);
-      }) });
-    })), enqueue = (text, kind) => Effect.gen(function* () {
+      return completed;
+    })).pipe(Effect.uninterruptible), runPending = () => Effect.gen(function* () {
+      if (yield* Ref.get(closed))
+        return;
+      yield* refreshPending;
+      const next = (yield* Ref.get(pending)).queue[0];
+      if (next !== void 0 && (yield* run(next)))
+        yield* runPending();
+    }), drain = gate.withPermits(1)(assertOpen.pipe(Effect.andThen(runPending()))), enqueue = (text, kind) => Effect.gen(function* () {
       yield* assertOpen;
       if (text.trim().length === 0)
         return yield* Effect.fail(failure("input.empty", "Enter a message"));
       const input = { id: crypto.randomUUID(), text, kind };
-      yield* publish({ name: "input.queued", data: input });
-      yield* Ref.update(pending, (queue) => [...queue, input]);
+      yield* publishing.withPermits(1)(publishUnlocked({ name: "input.queued", data: input }, !0));
+      yield* refreshPending;
     }), interrupt = Ref.get(running).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.void, onSome: (fiber) => Fiber.interrupt(fiber).pipe(Effect.asVoid) }))), close = Ref.getAndSet(closed, !0).pipe(Effect.flatMap((already) => already ? Effect.void : Effect.gen(function* () {
       yield* interrupt;
       yield* gate.withPermits(1)(Ref.get(mounted).pipe(Effect.flatMap((current) => Scope.close(current.scope, Exit.void))));
@@ -98,30 +143,30 @@ export const makeHarness = (options) => Effect.gen(function* () {
       yield* Ref.update(handles, (all) => new Map([...all].filter(([id]) => id !== record.id)));
     }))), handle = {
       record,
-      use: (tag, run) => gate.withPermits(1)(assertOpen.pipe(Effect.zipRight(Ref.get(mounted)), Effect.flatMap((current) => service(current.context, tag)), Effect.flatMap(run))),
-      send: (text) => enqueue(text, "turn").pipe(Effect.zipRight(drain)),
+      use: (tag, run) => gate.withPermits(1)(assertOpen.pipe(Effect.andThen(Ref.get(mounted)), Effect.flatMap((current) => service(current.context, tag)), Effect.flatMap(run))),
+      send: (text) => enqueue(text, "turn").pipe(Effect.andThen(drain)),
       steer: (text) => enqueue(text, "steer"),
       continue: drain,
       interrupt,
       close,
       busy: Ref.get(busy),
-      pending: Ref.get(pending),
+      pending: Ref.get(pending).pipe(Effect.map((state) => state.queue)),
       refresh: gate.withPermits(1)(refresh),
       history: store.read(record.id, -1),
       transient: Stream.fromPubSub(transientHub),
-      events: (after = -1) => Stream.unwrapScoped(Effect.gen(function* () {
+      events: (after = -1) => Stream.unwrap(Effect.gen(function* () {
         const subscription = yield* PubSub.subscribe(notifications), cursor = yield* Ref.make(after);
-        return Stream.concat(Stream.make(void 0), Stream.fromQueue(subscription)).pipe(Stream.mapEffect(() => Ref.get(cursor).pipe(Effect.flatMap((position) => store.read(record.id, position)), Effect.tap((events) => events.length === 0 ? Effect.void : Ref.set(cursor, events[events.length - 1].seq)))), Stream.flatMap(Stream.fromIterable));
+        return Stream.concat(Stream.make(void 0), Stream.fromSubscription(subscription)).pipe(Stream.mapEffect(() => Ref.get(cursor).pipe(Effect.flatMap((position) => store.read(record.id, position)), Effect.tap((events) => events.length === 0 ? Effect.void : Ref.set(cursor, events[events.length - 1].seq)))), Stream.flatMap(Stream.fromIterable));
       }))
     };
     yield* Scope.addFinalizer(parent, close);
     yield* Ref.update(handles, (all) => new Map([...all, [record.id, handle]]));
     return handle;
-  }), opening = yield* Effect.makeSemaphore(1), ownRecord = (id) => store.get(id).pipe(Effect.flatMap((record) => record.workspace !== options.workspace ? Effect.fail(failure("session.workspace", "This session belongs to a different workspace")) : Effect.succeed(record)));
+  }), opening = yield* Semaphore.make(1), ownRecord = (id) => store.get(id).pipe(Effect.flatMap((record) => record.workspace !== options.workspace ? Effect.fail(failure("session.workspace", "This session belongs to a different workspace")) : Effect.succeed(record)));
   return {
     create: () => Ref.get(graphRef).pipe(Effect.flatMap((graph) => store.create(options.workspace, graph.config.profile ?? "smith")), Effect.flatMap((record) => opening.withPermits(1)(open(record)))),
     resume: (id) => ownRecord(id).pipe(Effect.flatMap((record) => opening.withPermits(1)(open(record)))),
-    fork: (id, through) => ownRecord(id).pipe(Effect.zipRight(store.fork(id, through)), Effect.flatMap((record) => opening.withPermits(1)(open(record)))),
+    fork: (id, through) => ownRecord(id).pipe(Effect.andThen(store.fork(id, through)), Effect.flatMap((record) => opening.withPermits(1)(open(record)))),
     list: store.list(options.workspace),
     graph: Ref.get(graphRef),
     reconfigure: (config, plugins) => Effect.gen(function* () {
@@ -129,7 +174,7 @@ export const makeHarness = (options) => Effect.gen(function* () {
       if (graphFingerprint(next, "runtime") !== graphFingerprint(initial, "runtime"))
         return "restart-required";
       yield* Effect.forEach([...(yield* Ref.get(handles)).values()], (handle) => Effect.scoped(Effect.gen(function* () {
-        const scope = yield* Effect.scope, seed = Context.add(runtime, SessionEnvironment, { workspace: options.workspace, session: handle.record }), context = yield* activateGraph(next, "session", Context.unsafeMake(seed.unsafeMap), scope);
+        const scope = yield* Effect.scope, seed = Context.add(runtime, SessionEnvironment, { workspace: options.workspace, session: handle.record }), context = yield* activateGraph(next, "session", Context.makeUnsafe(seed.mapUnsafe), scope);
         yield* service(context, AgentLoop);
       })));
       yield* Ref.set(registryRef, registry);

package/dist/index.d.ts

@@ -2,3 +2,5 @@ export * from "@xandreed/core";
 export * from "./harness.js";
 export * from "./approval.adapter.js";
 export { domainLoop, domainSession } from "./domain-session.adapter.js";
+export { Agent } from "./agent.adapter.js";
+export type { AgentConfig, AgentPluginEntry } from "./agent.adapter.js";

package/dist/index.js

@@ -2,3 +2,4 @@ export * from "@xandreed/core";
 export * from "./harness.js";
 export * from "./approval.adapter.js";
 export { domainLoop, domainSession } from "./domain-session.adapter.js";
+export { Agent } from "./agent.adapter.js";

package/dist/memory.conformance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugin-stack.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/testing.port.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "effect";
+import type { Ref } from "effect";
+declare const Tally_base: Context.ServiceClass<Tally, "test/Tally", {
+    readonly runId: string;
+    readonly seen: Ref.Ref<ReadonlyArray<string>>;
+}>;
+/** A per-turn host service for the agent tests: built by the turn's layer, read by use, tools and subscriptions. */
+export declare class Tally extends Tally_base {
+}
+declare const Stamp_base: Context.ServiceClass<Stamp, "test/Stamp", {
+    readonly label: string;
+}>;
+/** A service a turn-dependent plugin provides in the agent tests, read by the host's layer. */
+export declare class Stamp extends Stamp_base {
+}
+export {};

package/dist/testing.port.js

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+
+export class Tally extends Context.Service()("test/Tally") {
+}
+
+export class Stamp extends Context.Service()("test/Stamp") {
+}

package/dist/turn-composition.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xandreed/sdk",
-  "version": "0.4.0",
+  "version": "0.11.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -10,11 +10,11 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.4.0",
-    "effect": "3.21.4",
-    "@xandreed/runtime": "0.4.0",
-    "@xandreed/plugin-memory": "0.4.0",
-    "@xandreed/plugin-session-sqlite": "0.4.0"
+    "@xandreed/core": "0.11.0",
+    "effect": "4.0.0-rc.118",
+    "@xandreed/runtime": "0.11.0",
+    "@xandreed/plugin-memory": "0.11.0",
+    "@xandreed/plugin-session-sqlite": "0.11.0"
   },
   "private": false,
   "types": "./dist/index.d.ts",
@@ -26,6 +26,7 @@
     "LICENSE"
   ],
   "engines": {
+    "node": ">=24",
     "bun": ">=1.3.0"
   },
   "license": "MIT"