@xandreed/sdk 0.11.0 → 0.13.0

package/README.md

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

package/dist/index.d.ts

@@ -1,6 +1,3 @@
 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

@@ -1,5 +1,2 @@
 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/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@xandreed/sdk",
-  "version": "0.11.0",
+  "version": "0.13.0",
+  "engines": {
+    "node": ">=24",
+    "bun": ">=1.3.0"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -10,11 +14,9 @@
     }
   },
   "dependencies": {
-    "@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"
+    "@xandreed/core": "0.13.0",
+    "effect": "4.0.7",
+    "@xandreed/runtime": "0.13.0"
   },
   "private": false,
   "types": "./dist/index.d.ts",
@@ -25,9 +27,5 @@
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "node": ">=24",
-    "bun": ">=1.3.0"
-  },
   "license": "MIT"
 }

package/dist/approval.adapter.d.ts

@@ -1,5 +0,0 @@
-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").TypedPlugin<{}, {}, Approval, never, never>;

package/dist/approval.adapter.js

@@ -1,11 +0,0 @@
-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.11.0",
-  scope: "runtime",
-  config: Schema.Struct({}),
-  defaults: {},
-  provides: [Approval],
-  layer: () => Layer.succeed(Approval, { request })
-});

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

@@ -1,27 +0,0 @@
-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.
- * 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: {
-    readonly create: (id: ConversationId) => Effect.Effect<Session<E>, never, R>;
-    readonly snapshot?: (id: ConversationId) => Effect.Effect<Readonly<Record<string, unknown>>, HarnessError, R>;
-    readonly restore?: (id: ConversationId, data: Readonly<Record<string, unknown>>) => Effect.Effect<void, HarnessError, R>;
-    readonly result: (event: E) => Option.Option<{
-        readonly text: string;
-        readonly outcome: "completed" | "partial";
-    }>;
-}) => Effect.Effect<{
-    readonly run: (input: import("@xandreed/core").LoopInput) => Effect.Effect<{
-        readonly text: string;
-        readonly outcome: "completed" | "partial";
-    }, HarnessError>;
-}, HarnessError, import("effect/Scope").Scope | SessionStore | R>;
-/** Preserve a domain host's public stream vocabulary while the SDK owns lifecycle. */
-export declare const domainSession: <E>(handle: SessionHandle, decode: (value: unknown) => Option.Option<E>, onError: (message: string) => E) => Session<E>;

package/dist/domain-session.adapter.js

@@ -1,56 +0,0 @@
-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), 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));
-    }
-    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.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.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 {
-    conversationId: handle.record.id,
-    send: (text) => handle.send(text).pipe(Effect.ignore),
-    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(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/domain-session.adapter.test.d.ts

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

package/dist/harness.d.ts

@@ -1,43 +0,0 @@
-import { Effect, Scope } from "effect";
-import { HarnessError } from "@xandreed/core";
-import type { ConversationId, HarnessConfig, Plugin, SessionHandle } from "@xandreed/core";
-import type { PluginGraph } from "@xandreed/runtime";
-export declare const makeHarness: (options: {
-    readonly config: HarnessConfig;
-    readonly plugins: ReadonlyArray<Plugin>;
-    readonly workspace: string;
-}) => Effect.Effect<{
-    create: () => Effect.Effect<SessionHandle, HarnessError, never>;
-    resume: (id: ConversationId) => Effect.Effect<SessionHandle, HarnessError, never>;
-    fork: (id: ConversationId, through: number) => Effect.Effect<SessionHandle, HarnessError, never>;
-    list: Effect.Effect<readonly {
-        readonly createdAt: number;
-        readonly id: string & import("effect/Brand").Brand<"ConversationId">;
-        readonly profile: string;
-        readonly workspace: string;
-        readonly parent?: (string & import("effect/Brand").Brand<"ConversationId">) | undefined;
-    }[], HarnessError, never>;
-    graph: Effect.Effect<PluginGraph, never, never>;
-    reconfigure: (config: HarnessConfig, plugins?: ReadonlyArray<Plugin>) => Effect.Effect<"applied" | "restart-required", HarnessError, never>;
-}, HarnessError, Scope.Scope>;
-export declare const Harness: {
-    make: (options: {
-        readonly config: HarnessConfig;
-        readonly plugins: ReadonlyArray<Plugin>;
-        readonly workspace: string;
-    }) => Effect.Effect<{
-        create: () => Effect.Effect<SessionHandle, HarnessError, never>;
-        resume: (id: ConversationId) => Effect.Effect<SessionHandle, HarnessError, never>;
-        fork: (id: ConversationId, through: number) => Effect.Effect<SessionHandle, HarnessError, never>;
-        list: Effect.Effect<readonly {
-            readonly createdAt: number;
-            readonly id: string & import("effect/Brand").Brand<"ConversationId">;
-            readonly profile: string;
-            readonly workspace: string;
-            readonly parent?: (string & import("effect/Brand").Brand<"ConversationId">) | undefined;
-        }[], HarnessError, never>;
-        graph: Effect.Effect<PluginGraph, never, never>;
-        reconfigure: (config: HarnessConfig, plugins?: ReadonlyArray<Plugin>) => Effect.Effect<"applied" | "restart-required", HarnessError, never>;
-    }, HarnessError, Scope.Scope>;
-};
-export type Harness = Effect.Success<ReturnType<typeof makeHarness>>;

package/dist/harness.js

@@ -1,186 +0,0 @@
-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 }), 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.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), 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.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))), 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);
-      if (graphFingerprint(graph) === previous.fingerprint)
-        return;
-      const next = yield* acquire(graph);
-      yield* Ref.set(mounted, next);
-      yield* Scope.close(previous.scope, Exit.void);
-      yield* publish({ name: "config.applied", data: { fingerprint: next.fingerprint } });
-    }), 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.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(), 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);
-      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,
-        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,
-        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, 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());
-      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`
-      });
-      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 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* 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))));
-      yield* PubSub.shutdown(notifications);
-      yield* PubSub.shutdown(transientHub);
-      yield* Ref.update(handles, (all) => new Map([...all].filter(([id]) => id !== record.id)));
-    }))), handle = {
-      record,
-      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).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.unwrap(Effect.gen(function* () {
-        const subscription = yield* PubSub.subscribe(notifications), cursor = yield* Ref.make(after);
-        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* 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.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* () {
-      const registry = plugins ?? (yield* Ref.get(registryRef)), next = yield* resolveGraph(config, registry, [SessionEnvironment.key]);
-      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.makeUnsafe(seed.mapUnsafe), scope);
-        yield* service(context, AgentLoop);
-      })));
-      yield* Ref.set(registryRef, registry);
-      yield* Ref.set(graphRef, next);
-      yield* Effect.forEach([...(yield* Ref.get(handles)).values()], (handle) => handle.busy.pipe(Effect.flatMap((active) => active ? Effect.void : handle.refresh)));
-      return "applied";
-    })
-  };
-}), Harness = { make: makeHarness };

package/dist/harness.test.d.ts

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