@xandreed/core 0.4.0 → 0.11.0

package/dist/turn/turn-run.js

@@ -0,0 +1,105 @@
+import { Context, Effect, Option } from "effect";
+import { LanguageModel } from "effect/ai";
+import { toolParametersSchema } from "../loop/toolSchema.js";
+import { HarnessError } from "../harness/plugin.entity.js";
+import { canonicalJson, estimateTokens, fingerprintOf } from "../memory/memory-log.entity.functions.js";
+import { StepLoop } from "../ports/step-loop.port.js";
+import { TurnEvents, TurnTasks } from "../ports/turn-events.port.js";
+import { TurnMemory, TurnPrompt, TurnToolbox } from "../ports/turn-scope.port.js";
+import { CurrentModelCallPolicy } from "../loop/modelPolicy.js";
+import {
+  checkModelRequest,
+  modelRequestDescriptorOf,
+  modelRequestHeaderOf,
+  modelRequestTools,
+  reconstructModelRequest,
+  resolveModelRequest
+} from "./model-request.entity.functions.js";
+const defaultLimits = { maxSteps: 50, toolConcurrency: 1, streaming: !0, requireCompletion: !1 }, defaultBudgetTokens = 64000, incomplete = { complete: !1, awaiting: [], facts: {} }, noDirective = { context: Option.none(), toolChoice: Option.none() };
+export const schemaTokens = (tools, active) => active.reduce((sum, name) => {
+  const tool = tools.toolkit.tools[name];
+  return tool === void 0 ? sum : sum + estimateTokens(`${tool.description ?? ""}${canonicalJson(toolParametersSchema(tool))}`);
+}, 0), cacheKeyOf = (prefix, conversation) => Option.map(Option.filter(Option.some(prefix), (value) => value.length > 0), (value) => `${value}:${conversation}`), stepRequestOf = (policy, options = {}) => Effect.gen(function* () {
+  const runServices = yield* Effect.context(), inRun = (effect) => effect.pipe(Effect.provide(runServices)), memory = yield* TurnMemory, prompt = yield* TurnPrompt, events = yield* TurnEvents, tasks = yield* TurnTasks, tools = yield* (yield* TurnToolbox).tools, session = memory.session, runId = (yield* session.renderRecipe("none")).currentRun, defaultModel = Context.getOption(runServices, LanguageModel.LanguageModel), number = yield* memory.number, limits = { ...defaultLimits, ...options.limits, ...policy.limits }, budget = policy.budgetTokens ?? options.budgetTokens ?? defaultBudgetTokens, stepContext = policy.stepContext ?? "tail";
+  yield* Option.match(Option.fromNullishOr(policy.initial), {
+    onNone: () => Effect.void,
+    onSome: (batch) => batch.skills.length === 0 ? Effect.void : tools.activate(batch.skills, "host").pipe(Effect.asVoid)
+  });
+  yield* inRun(prompt.turnSections);
+  yield* session.maintain({ phase: "turn-start", lastUsage: Option.none(), budgetTokens: budget, views: tools.views });
+  const plan = (info) => Effect.gen(function* () {
+    const choice = policy.model === void 0 ? Option.none() : yield* inRun(policy.model(info)), system = yield* inRun(prompt.system(Option.flatMap(choice, (value) => value.variant))), directive = policy.step === void 0 ? noDirective : yield* inRun(policy.step(info));
+    yield* Option.match(directive.context, {
+      onNone: () => Effect.void,
+      onSome: (text) => session.record([{ _tag: "StepContext", step: info.stepIndex, text }], info.stepIndex).pipe(Effect.asVoid)
+    });
+    const reserved = estimateTokens(system) + schemaTokens(tools, info.activeTools);
+    yield* session.maintain({ phase: "step", lastUsage: info.lastUsage, budgetTokens: Math.max(1, budget - reserved), views: tools.views });
+    const built = yield* session.build({ stepContext: stepContext === "tail" ? "tail" : "none" }), render = yield* session.renderRecipe(stepContext === "tail" ? "tail" : "none");
+    yield* events.publish({
+      _tag: "context.built",
+      step: info.stepIndex,
+      turn: number,
+      strategy: session.strategy.id,
+      strategyVersion: session.strategy.version,
+      fingerprint: built.fingerprint,
+      systemFingerprint: fingerprintOf(system),
+      estimatedTokens: built.estimatedTokens,
+      reservedTokens: reserved,
+      compactions: built.compactions.length,
+      activeTools: info.activeTools
+    });
+    const stepText = stepContext === "system" ? Option.getOrElse(directive.context, () => "") : "", finalSystem = [system, stepText].filter((part) => part.length > 0).join(`
+
+`), model = yield* Option.match(Option.orElse(Option.map(choice, (value) => value.model), () => defaultModel), {
+      onNone: () => Effect.succeed(Option.none()),
+      onSome: (chosen) => resolveModelRequest(chosen).pipe(Effect.map(Option.some))
+    });
+    yield* memory.prepareRequest({
+      version: 1,
+      runId,
+      step: info.stepIndex,
+      strategyVersion: session.strategy.version,
+      system: finalSystem,
+      render,
+      through: built.through,
+      contextFingerprint: built.fingerprint,
+      tools: modelRequestTools(info.activeTools.flatMap((name) => tools.toolkit.tools[name] === void 0 ? [] : [tools.toolkit.tools[name]])),
+      toolChoice: Option.getOrElse(directive.toolChoice, () => "auto"),
+      model: yield* Option.match(model, { onNone: () => Effect.succeed(Option.none()), onSome: modelRequestDescriptorOf }),
+      cacheKey: options.cacheKey ?? Option.none(),
+      callPolicy: yield* Effect.service(CurrentModelCallPolicy)
+    });
+    return {
+      model,
+      system: finalSystem,
+      messages: built.messages,
+      toolChoice: directive.toolChoice
+    };
+  });
+  return {
+    tools,
+    handlers: Context.merge(runServices, tools.handlers),
+    limits,
+    initial: Option.fromNullishOr(policy.initial),
+    plan,
+    dispatch: (step, actual) => Effect.gen(function* () {
+      const stored = yield* memory.requestSnapshot, header = yield* modelRequestHeaderOf(stored.requests, runId, step), expected = yield* reconstructModelRequest(header, stored.entries);
+      yield* checkModelRequest(expected, {
+        prompt: actual.prompt,
+        tools: modelRequestTools(actual.tools),
+        toolChoice: actual.toolChoice,
+        model: yield* modelRequestDescriptorOf(actual.model),
+        cacheKey: options.cacheKey ?? Option.none(),
+        callPolicy: yield* Effect.service(CurrentModelCallPolicy)
+      });
+    }),
+    record: (step, tail) => session.recordTail(tail, tools.views, step),
+    completion: (info) => policy.completion === void 0 ? Effect.succeed(incomplete) : inRun(policy.completion(info)),
+    steering: options.steering ?? Effect.succeed(Option.none()),
+    correctives: Option.fromNullishOr(policy.correctives),
+    events,
+    tasks,
+    cacheKey: options.cacheKey ?? Option.none()
+  };
+}), runTurnLoop = (policy, options = {}) => stepRequestOf(policy, options).pipe(Effect.flatMap((request) => StepLoop.pipe(Effect.flatMap((loop) => loop.run(request)))));

package/dist/turn/turn.adapter.d.ts

@@ -0,0 +1,21 @@
+import { Layer } from "effect";
+import { HarnessError } from "../harness/plugin.entity.js";
+import { ConversationMemory } from "../ports/memory.port.js";
+import { RunContext } from "../ports/run-context.port.js";
+import { ToolRegistry } from "../ports/tool-registry.port.js";
+import { TurnEvents, TurnTasks } from "../ports/turn-events.port.js";
+import { TurnMemory, TurnPrompt, TurnToolbox } from "../ports/turn-scope.port.js";
+import type { TurnLiveInput } from "../ports/turn-scope.port.js";
+/**
+ * One admitted turn's services, over the turn's writer, built in this order:
+ * the event bus and the tasks, with the writer as the bus's FIRST
+ * subscriber (every stored event is queued before any reaction runs); then
+ * the memory session, opened over the session's earlier memory events where
+ * this layer is built (a digester or summarizer there is used), and
+ * RunContext. It also holds the tools slot (`TurnToolbox`) and the prompt
+ * state (`TurnPrompt`). The message was stored when the turn began; memory
+ * takes it at `TurnMemory.persistMessage`, and records nothing before it
+ * (`TurnMemory.context` waits for it). Tasks run in the layer's scope:
+ * they are interrupted when it closes.
+ */
+export declare const TurnLive: (input: TurnLiveInput) => Layer.Layer<RunContext | TurnEvents | TurnTasks | TurnMemory | TurnToolbox | TurnPrompt, HarnessError, ConversationMemory | ToolRegistry>;

package/dist/turn/turn.adapter.js

@@ -0,0 +1,126 @@
+import { Context, Effect, Layer, Option, Ref, Schema, Scope, Semaphore } from "effect";
+import { HarnessError } from "../harness/plugin.entity.js";
+import { fingerprintOf } from "../memory/memory-log.entity.functions.js";
+import { readerOf } from "../memory/memory-session.js";
+import { Capabilities } from "../ports/capability.port.js";
+import { ConversationMemory } from "../ports/memory.port.js";
+import { RunContext } from "../ports/run-context.port.js";
+import { draftOfTurnEvent, draftsOfEntries, entriesOfEvents } from "../session/session-event.entity.functions.js";
+import { MEMORY_KINDS, RESERVED_KINDS } from "../session/session-event.entity.js";
+import { ToolRegistry } from "../ports/tool-registry.port.js";
+import { TurnEvents, TurnTasks } from "../ports/turn-events.port.js";
+import { TurnMemory, TurnPrompt, TurnToolbox } from "../ports/turn-scope.port.js";
+import { renderSections } from "./prompt-sections.js";
+import { makeTurnEvents, makeTurnTasks } from "./turn-bus.js";
+import { ModelRequestHeader } from "./model-request.entity.js";
+const failure = (code, message) => new HarnessError({ code, message }), inCaller = (effect) => Effect.flatMap(Effect.context(), (context) => effect.pipe(Effect.provide(context))), storedDraft = (turn) => (event) => event._tag === "host" && RESERVED_KINDS.includes(event.name) ? Option.some(failure("events.reserved", `${event.name} is the framework's kind`)) : Option.map(draftOfTurnEvent(turn, event), (draft) => ({ kind: draft.kind, data: draft.data })), contextBody = (entry) => ({ _tag: "TurnContext", sectionId: entry.id, version: entry.version, text: entry.text });
+export const TurnLive = (input) => Layer.effectContext(Effect.gen(function* () {
+  const scope = yield* Effect.scope, memory = yield* ConversationMemory, registry = yield* ToolRegistry, sections = Option.getOrElse(yield* Effect.serviceOption(Capabilities), () => []).flatMap((capability) => capability.promptSections), writer = input.turn, admitted = writer.admitted, events = yield* makeTurnEvents({ maxDepth: input.maxEventDepth ?? 8 }), tasks = yield* makeTurnTasks(scope);
+  yield* events.subscribe(storedDraft(admitted.turn), (draft) => draft instanceof HarnessError ? Effect.fail(draft) : writer.append([draft]));
+  const message = yield* Ref.make({ _tag: "Waiting", early: [] }), history = yield* Ref.make(Option.none()), decoded = (stored) => entriesOfEvents(stored).pipe(Effect.mapError((error) => failure("memory.log", `undecodable memory events: ${error.message}`))), readHistory = writer.history(MEMORY_KINDS).pipe(Effect.flatMap(decoded)), log = {
+    read: readHistory.pipe(Effect.tap((entries) => Ref.set(history, Option.some(entries)))),
+    append: (entries) => Effect.gen(function* () {
+      if ((yield* Ref.get(message))._tag === "Waiting" && entries.some((entry) => entry.body._tag !== "TurnStarted"))
+        return yield* Effect.fail(failure("turn.unstarted", "memory records nothing before the turn's message is taken (persistMessage); TurnMemory.context waits for it"));
+      const started = entries.filter((entry) => entry.body._tag === "TurnStarted");
+      if (started.some((entry) => entry.turn !== admitted.turn || entry.id !== writer.started.data.entry))
+        return yield* Effect.fail(failure("turn.numbering", `memory took the message as ${started.map((entry) => `${entry.id} of turn ${entry.turn}`).join()}, the session stored ${String(writer.started.data.entry)} of turn ${admitted.turn}`));
+      const drafts = yield* draftsOfEntries(entries).pipe(Effect.mapError((error) => failure("memory.log", error.message)));
+      yield* writer.append(drafts.map((draft) => ({ kind: draft.kind, data: draft.data })));
+    })
+  }, session = yield* memory.open({ conversation: admitted.session.id, runId: admitted.runId, log }), reader = readerOf(session), slot = yield* Ref.make(Option.none()), openTools = Ref.get(slot).pipe(Effect.flatMap(Option.match({
+    onNone: () => Effect.fail(failure("tools.unavailable", "Tools are not open yet")),
+    onSome: (tools) => Effect.succeed(tools)
+  }))), run = RunContext.of({
+    conversation: admitted.session.id,
+    session: admitted.session,
+    runId: admitted.runId,
+    userMessage: admitted.userMessage,
+    memory: reader,
+    events,
+    tasks,
+    activate: (skills) => openTools.pipe(Effect.flatMap((tools) => tools.activate(skills, "host"))),
+    flush: writer.flush,
+    write: writer.write
+  }), requestKinds = [...MEMORY_KINDS, "request.prepared"], snapshots = yield* Semaphore.make(1), snapshot = yield* Ref.make(Option.none()), requestSnapshot = snapshots.withPermits(1)(Effect.gen(function* () {
+    const known = yield* Option.match(yield* Ref.get(snapshot), {
+      onNone: () => Ref.get(history).pipe(Effect.flatMap(Option.match({ onNone: () => readHistory, onSome: Effect.succeed })), Effect.map((entries) => ({ entries, requests: [], cursor: writer.started.seq - 1 }))),
+      onSome: Effect.succeed
+    }), stored = yield* writer.snapshot(requestKinds, known.cursor), next = {
+      entries: [...known.entries, ...yield* decoded(stored.filter((event) => MEMORY_KINDS.includes(event.kind)))],
+      requests: [...known.requests, ...stored.filter((event) => event.kind === "request.prepared" && event.data.runId === admitted.runId)],
+      cursor: stored.reduce((last, event) => Math.max(last, event.seq), known.cursor)
+    };
+    yield* Ref.set(snapshot, Option.some(next));
+    return { entries: next.entries, requests: next.requests };
+  })), claimed = yield* Ref.make(!1), replied = yield* Ref.make(!1), taken = Ref.get(message).pipe(Effect.map((state) => state._tag === "Taken" ? Option.some(state.number) : Option.none())), turnMemory = TurnMemory.of({
+    ...reader,
+    strategy: session.strategy,
+    session,
+    prepareRequest: (header) => Schema.encodeEffect(ModelRequestHeader)(header).pipe(Effect.mapError((error) => failure("request.encode", error.message)), Effect.flatMap((data) => writer.append([{ kind: "request.prepared", data }])), Effect.andThen(writer.flush)),
+    requestSnapshot,
+    number: taken.pipe(Effect.flatMap(Option.match({
+      onNone: () => Effect.fail(failure("turn.unstarted", "The user's message is not persisted yet")),
+      onSome: (number) => Effect.succeed(number)
+    }))),
+    persistMessage: Effect.gen(function* () {
+      if (yield* Ref.getAndSet(claimed, !0))
+        return yield* Effect.fail(failure("turn.persisted", "The user's message is already persisted"));
+      const number = admitted.turn;
+      yield* session.record([{ _tag: "TurnStarted", userMessage: admitted.userMessage }], 0);
+      const early = yield* Ref.modify(message, (state) => [state._tag === "Waiting" ? state.early : [], { _tag: "Taken", number }]);
+      yield* early.length === 0 ? Effect.void : session.record(early.map(contextBody), 0);
+      yield* events.publish({ _tag: "turn.started", runId: admitted.runId, turn: number, userMessage: admitted.userMessage });
+      return number;
+    }),
+    context: (entry) => Ref.modify(message, (state) => state._tag === "Waiting" ? [!1, { _tag: "Waiting", early: [...state.early, entry] }] : [!0, state]).pipe(Effect.flatMap((now) => now ? session.record([contextBody(entry)], 0).pipe(Effect.asVoid) : Effect.void)),
+    persistReply: (outcome) => Effect.gen(function* () {
+      const number = yield* taken;
+      if (Option.isNone(number) || (yield* Ref.getAndSet(replied, !0)))
+        return;
+      yield* session.record([{ _tag: "TurnEnded", outcome: outcome.outcome, reply: outcome.reply }], 0);
+      yield* events.publish({ _tag: "turn.ended", runId: admitted.runId, turn: number.value, outcome: outcome.outcome, reply: outcome.reply });
+    })
+  }), opened = yield* Ref.make(!1), toolbox = TurnToolbox.of({
+    open: Effect.gen(function* () {
+      if (yield* Ref.getAndSet(opened, !0))
+        return yield* Effect.fail(failure("tools.opened", "The turn's tools are already open"));
+      const tools = yield* registry.open(session).pipe(Effect.provideService(RunContext, run), Scope.provide(scope));
+      yield* Ref.set(slot, Option.some(tools));
+      return tools;
+    }),
+    tools: openTools
+  }), promptContext = (tools, variant) => tools.active.pipe(Effect.map((active) => ({ variant, active, skills: tools.skills }))), rendered = (tools, variant, tiers) => inCaller(promptContext(tools, variant).pipe(Effect.flatMap((context) => renderSections(sections.filter(tiers), context)))), lastSystem = yield* Ref.make(Option.fromNullishOr((yield* session.entries).flatMap((entry) => entry.body._tag === "SystemPrepared" ? [entry.body.fingerprint] : []).at(-1))), systems = yield* Ref.make(new Map), turnSections = yield* Ref.make(!1), prompt = TurnPrompt.of({
+    system: (variant) => Effect.gen(function* () {
+      const key = Option.getOrElse(variant, () => ""), known = (yield* Ref.get(systems)).get(key);
+      if (known !== void 0)
+        return known;
+      const parts = yield* rendered(yield* openTools, variant, (section) => section.tier !== "turn"), text = [input.system ?? "", ...parts.map((part) => part.text)].filter((part) => part.trim().length > 0).join(`
+
+`), fingerprint = fingerprintOf(text);
+      if (!Option.contains(yield* Ref.get(lastSystem), fingerprint)) {
+        yield* session.record([{
+          _tag: "SystemPrepared",
+          fingerprint,
+          text,
+          sections: parts.map((part) => ({ id: part.section.id, version: part.section.version, fingerprint: fingerprintOf(part.text) }))
+        }], 0);
+        yield* Ref.set(lastSystem, Option.some(fingerprint));
+      }
+      yield* Ref.update(systems, (all) => new Map([...all, [key, text]]));
+      return text;
+    }),
+    turnSections: Effect.gen(function* () {
+      if (yield* Ref.getAndSet(turnSections, !0))
+        return;
+      const parts = yield* rendered(yield* openTools, Option.none(), (section) => section.tier === "turn");
+      yield* parts.length === 0 ? Effect.void : session.record(parts.map(({ section, text }) => ({
+        _tag: "TurnContext",
+        sectionId: section.id,
+        version: section.version,
+        text
+      })), 0);
+    })
+  });
+  return Context.make(RunContext, run).pipe(Context.add(TurnEvents, events), Context.add(TurnTasks, tasks), Context.add(TurnMemory, turnMemory), Context.add(TurnToolbox, toolbox), Context.add(TurnPrompt, prompt));
+}));

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

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

package/dist/turn/turn.conformance.d.ts

@@ -0,0 +1,20 @@
+import { Context, Effect } from "effect";
+import type { Scope } from "effect";
+import type { ConformanceCheck } from "../conformance.entity.js";
+import { HarnessError } from "../harness/plugin.entity.js";
+import type { TurnRunner } from "../ports/turn.port.js";
+/**
+ * The turn contract, as checks any composition of the turn must pass (an
+ * `Agent`, or a host's own composition of `TurnLive` and the lifecycle):
+ * the session's writer is the bus's first subscriber; the user's message
+ * is in memory before the matcher reads the history; the reply is recorded
+ * and the turn ended exactly once on success, failure and interrupt; tasks
+ * are joined before the reply; and the host layer sees only earlier turns.
+ *
+ * `runner` is acquired afresh for each check. `services` are merged into
+ * every turn's services (the model, the `Sessions` the turns begin with, and
+ * whatever else the runner requires); each check makes its own session, and
+ * the kit adds its own IntentMatcher, which the runner's tools must consult
+ * (plugin-tool-discovery does).
+ */
+export declare const turnConformance: (runner: Effect.Effect<TurnRunner, HarnessError, Scope.Scope>, services?: Context.Context<never>) => ReadonlyArray<ConformanceCheck>;

package/dist/turn/turn.conformance.js

@@ -0,0 +1,74 @@
+import { Context, Deferred, Effect, Fiber, Layer, Option, Ref } from "effect";
+import { ConformanceFailure } from "../conformance.entity.js";
+import { HarnessError } from "../harness/plugin.entity.js";
+import { IntentMatcher } from "../ports/capability.port.js";
+import { RunContext } from "../ports/run-context.port.js";
+import { Sessions } from "../ports/sessions.port.js";
+import { UserMessage } from "./user-message.entity.js";
+const fail = (check) => (message) => Effect.fail(new ConformanceFailure({ check, message })), expect = (check, holds, message) => holds ? Effect.void : fail(check)(message), stored = (session) => session.sessions.read(session.address).pipe(Effect.mapError((error) => new HarnessError({ code: "conformance.session", message: error._tag }))), ofRun = (all, runId) => {
+  const turn = Option.flatMap(Option.fromNullishOr(all.find((event) => event.kind === "turn.started" && event.data.runId === runId)), (event) => event.turn);
+  return Option.match(turn, { onNone: () => [], onSome: (number) => all.filter((event) => Option.contains(event.turn, number)) });
+}, names = (session, runId) => stored(session).pipe(Effect.map((all) => ofRun(all, runId).map((event) => event.kind)));
+export const turnConformance = (runner, services = Context.empty()) => {
+  const check = (name, id, body) => ({
+    name,
+    run: Effect.scoped(Effect.gen(function* () {
+      const history = yield* Ref.make([]), matcher = Context.make(IntentMatcher, IntentMatcher.of({
+        id: "conformance",
+        version: "1",
+        match: (request) => Ref.update(history, (all) => [...all, request.history]).pipe(Effect.as({ skills: [], probabilities: Option.none(), abstained: !0 }))
+      })), sessions = yield* Option.match(Context.getOption(services, Sessions), {
+        onNone: () => fail(id)("the turn services hold no Sessions to begin turns with"),
+        onSome: (found) => Effect.succeed(found)
+      }), view = yield* sessions.create({ owner: "conformance" }).pipe(Effect.mapError((error) => new HarnessError({ code: "conformance.session", message: error._tag }))), acquired = yield* runner;
+      yield* body({
+        turn: (input, use) => acquired.turn({ ...input, services: Context.merge(Context.merge(services, matcher), input.services) }, use)
+      }, { sessions, address: { id: view.header.id, owner: "conformance" } }, history);
+    })).pipe(Effect.catchTag("HarnessError", (error) => fail(id)(`${error.code}: ${error.message}`)))
+  }), input = (session, runId) => ({
+    turn: { session: session.address, userMessage: new UserMessage({ text: `the message of ${runId}` }), runId },
+    services: Context.empty()
+  }), reply = (text) => Effect.succeed({ outcome: "completed", reply: Option.some(text) });
+  return [
+    check("the session's writer is the bus's first subscriber", "journal-first", (turns, session) => Effect.gen(function* () {
+      const outcome = yield* turns.turn(input(session, "run-1"), (turn) => Effect.gen(function* () {
+        const journaled = yield* Ref.make(!1);
+        yield* turn.events.subscribe((event) => event._tag === "host" && event.name === "conformance.probe" ? Option.some(event) : Option.none(), () => turn.flush.pipe(Effect.andThen(names(session, "run-1")), Effect.flatMap((kinds) => Ref.set(journaled, kinds.includes("conformance.probe")))));
+        yield* turn.events.publish({ _tag: "host", name: "conformance.probe", data: {} });
+        return yield* reply((yield* Ref.get(journaled)) ? "journaled first" : "not journaled");
+      }));
+      yield* expect("journal-first", Option.contains(outcome.reply, "journaled first"), "a subscriber ran before the session stored the event it received");
+    })),
+    check("the user's message is recorded before the matcher reads the history", "message-first", (turns, session, history) => Effect.gen(function* () {
+      yield* turns.turn(input(session, "run-1"), (turn) => turn.tools.match(turn.userMessage).pipe(Effect.andThen(reply("matched"))));
+      const seen = yield* Ref.get(history), last = Option.fromNullishOr(seen.at(-1)?.at(-1));
+      yield* expect("message-first", seen.length === 1, `the matcher was consulted ${seen.length} times, not once`);
+      yield* expect("message-first", Option.exists(last, (message) => message.role === "user" && JSON.stringify(message.content).includes("the message of run-1")), "the matcher's history does not end with the turn's own message");
+    })),
+    check("the reply is recorded and the turn ended exactly once, on success, failure and interrupt", "ended-once", (turns, session) => Effect.gen(function* () {
+      yield* turns.turn(input(session, "run-1"), () => reply("done"));
+      yield* Effect.result(turns.turn(input(session, "run-2"), () => Effect.fail(new HarnessError({ code: "conformance.host", message: "the host failed" }))));
+      const started = yield* Deferred.make(), fiber = yield* Effect.forkChild(turns.turn(input(session, "run-3"), () => Deferred.succeed(started, void 0).pipe(Effect.andThen(Effect.never))));
+      yield* Deferred.await(started);
+      yield* Fiber.interrupt(fiber);
+      const all = yield* stored(session), per = (runId, kind, field) => ofRun(all, runId).filter((event) => event.kind === kind).map(field).join("+"), replies = ["run-1", "run-2", "run-3"].map((runId) => `${runId}:${per(runId, "turn.reply", (event) => event.data.body?.outcome)}`), endings = ["run-1", "run-2", "run-3"].map((runId) => `${runId}:${per(runId, "turn.ended", (event) => event.data.reason)}`);
+      yield* expect("ended-once", replies.join() === "run-1:completed,run-2:failed,run-3:failed", `the replies were ${replies.join()}`);
+      yield* expect("ended-once", endings.join() === "run-1:completed,run-2:failed,run-3:interrupted", `the turns ended ${endings.join()}`);
+    })),
+    check("tasks are joined before the reply", "tasks-joined", (turns, session) => Effect.gen(function* () {
+      yield* turns.turn(input(session, "run-1"), (turn) => turn.tasks.fork("late", Effect.sleep("10 millis").pipe(Effect.andThen(turn.events.publish({ _tag: "host", name: "conformance.task", data: {} })))).pipe(Effect.andThen(reply("forked"))));
+      const kinds = yield* names(session, "run-1");
+      yield* expect("tasks-joined", kinds.includes("conformance.task") && kinds.indexOf("conformance.task") < kinds.indexOf("turn.reply"), `the task's event came ${kinds.includes("conformance.task") ? "after the reply" : "never"}`);
+    })),
+    check("the host layer is built before the message: it sees only earlier turns", "layer-before-message", (turns, session) => Effect.gen(function* () {
+      const seen = yield* Ref.make([]), layer = Layer.effectDiscard(Effect.gen(function* () {
+        const run = yield* RunContext, own = (yield* run.memory.entries).filter((entry) => entry.runId === run.runId).length, turn = yield* run.memory.turn;
+        yield* Ref.update(seen, (all) => [...all, `${run.runId}:turn ${turn}, own entries ${own}`]);
+      }));
+      yield* turns.turn({ ...input(session, "run-1"), layer }, () => reply("first"));
+      yield* turns.turn({ ...input(session, "run-2"), layer }, () => reply("second"));
+      const built = (yield* Ref.get(seen)).join("; ");
+      yield* expect("layer-before-message", built === "run-1:turn 0, own entries 0; run-2:turn 1, own entries 0", `the host layer saw ${built}`);
+    }))
+  ];
+};

package/dist/turn/user-message.entity.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+declare const UserMessage_base: Schema.Class<UserMessage, Schema.Struct<{
+    readonly text: Schema.NonEmptyString;
+}>, {}>;
+/**
+ * What the user said to start a turn. A prompt is text sent to a model; the
+ * user's message is a value of its own, and every field or parameter holding
+ * it is named `userMessage`. Attachments may join `text` later.
+ */
+export declare class UserMessage extends UserMessage_base {
+}
+/** A `UserMessage` stored as its plain text, for records that keep a string on the wire. */
+export declare const UserMessageFromString: Schema.decodeTo<typeof UserMessage, Schema.String, never, never>;
+export {};

package/dist/turn/user-message.entity.js

@@ -0,0 +1,10 @@
+import { Schema, SchemaTransformation } from "effect";
+
+export class UserMessage extends Schema.Class("UserMessage")({
+  text: Schema.NonEmptyString
+}) {
+}
+export const UserMessageFromString = Schema.String.pipe(Schema.decodeTo(UserMessage, SchemaTransformation.transform({
+  decode: (text) => ({ text }),
+  encode: (userMessage) => userMessage.text
+})));

package/dist/util/json.d.ts

@@ -1,4 +1,4 @@
-import { Effect, Either, Option } from "effect";
+import { Effect, Result, Option } from "effect";
 /**
  * Parse JSON with CORRUPT ≠ ABSENT semantics: malformed text logs a warning
  * naming the source and yields `None`. Config readers fall back to their
@@ -16,4 +16,4 @@ export declare const parseJsonOption: (text: string) => Option.Option<unknown>;
  *  `decode`; a corrupt or undecodable LINE is skipped (append-only files
  *  corrupt at a line boundary — one bad row must not brick the history).
  *  The shared machinery of the smith memory ledger and the social ledger. */
-export declare const decodeJsonLines: <A, E>(text: string, decode: (value: unknown) => Either.Either<A, E>) => ReadonlyArray<A>;
+export declare const decodeJsonLines: <A, E>(text: string, decode: (value: unknown) => Result.Result<A, E>) => ReadonlyArray<A>;

package/dist/util/json.js

@@ -1,15 +1,15 @@
-import { Effect, Either, Option } from "effect";
-export const parseJsonWarn = (text, where) => Either.match(Either.try(() => JSON.parse(text)), {
-  onLeft: (error) => Effect.logWarning(`${where}: unreadable JSON \u2014 treating as empty: ${String(error)}`).pipe(Effect.as(Option.none())),
-  onRight: (value) => Effect.succeed(Option.some(value))
+import { Effect, Result, Option } from "effect";
+export const parseJsonWarn = (text, where) => Result.match(Result.try(() => JSON.parse(text)), {
+  onFailure: (error) => Effect.logWarning(`${where}: unreadable JSON \u2014 treating as empty: ${String(error)}`).pipe(Effect.as(Option.none())),
+  onSuccess: (value) => Effect.succeed(Option.some(value))
 }), asJsonRecord = (value) => Option.match(value, {
   onNone: () => ({}),
   onSome: (parsed) => typeof parsed === "object" && parsed !== null ? parsed : {}
-}), parseJsonOption = (text) => Either.getRight(Either.try(() => JSON.parse(text))), decodeJsonLines = (text, decode) => text.split(`
-`).filter((line) => line.trim().length > 0).flatMap((line) => Either.try(() => JSON.parse(line)).pipe(Either.match({
-  onLeft: () => [],
-  onRight: (parsed) => Either.match(decode(parsed), {
-    onLeft: () => [],
-    onRight: (decoded) => [decoded]
+}), parseJsonOption = (text) => Result.getSuccess(Result.try(() => JSON.parse(text))), decodeJsonLines = (text, decode) => text.split(`
+`).filter((line) => line.trim().length > 0).flatMap((line) => Result.try(() => JSON.parse(line)).pipe(Result.match({
+  onFailure: () => [],
+  onSuccess: (parsed) => Result.match(decode(parsed), {
+    onFailure: () => [],
+    onSuccess: (decoded) => [decoded]
   })
 })));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xandreed/core",
-  "version": "0.4.0",
+  "version": "0.11.0",
   "private": false,
   "type": "module",
   "description": "The agent kernel of the new line: entities, ports, the provider-agnostic agent loop, and the session chassis — pure Effect, no IO, no provider SDKs.",
@@ -12,8 +12,7 @@
     }
   },
   "dependencies": {
-    "@effect/ai": "0.35.0",
-    "effect": "3.21.4"
+    "effect": "4.0.0-rc.118"
   },
   "types": "./dist/index.d.ts",
   "files": [
@@ -24,6 +23,7 @@
     "LICENSE"
   ],
   "engines": {
+    "node": ">=24",
     "bun": ">=1.3.0"
   },
   "license": "MIT"