@xandreed/core 0.4.0 → 0.8.0-next.0

package/dist/harness/plugin.entity.d.ts

@@ -1,13 +1,13 @@
 import { Schema } from "effect";
-import type { Context, Effect, Scope } from "effect";
-export declare const PLUGIN_API_VERSION = 1;
-declare const HarnessError_base: Schema.TaggedErrorClass<HarnessError, "HarnessError", {
-    readonly _tag: Schema.tag<"HarnessError">;
-} & {
-    code: typeof Schema.String;
-    message: typeof Schema.String;
-    plugin: Schema.optional<typeof Schema.String>;
-}>;
+import type { Context, Effect, Layer, Scope } from "effect";
+export declare const PLUGIN_API_VERSION = 2;
+/** Version 1 plugins (no capabilities, no optional services) still load. */
+export declare const SUPPORTED_PLUGIN_API_VERSIONS: ReadonlyArray<number>;
+declare const HarnessError_base: Schema.Class<HarnessError, Schema.TaggedStruct<"HarnessError", {
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+    readonly plugin: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class HarnessError extends HarnessError_base {
 }
 /** The runtime consumes this erased boundary; authors use definePlugin. */
@@ -18,8 +18,24 @@ export interface Plugin {
     readonly scope: "runtime" | "session";
     readonly requires: ReadonlyArray<string>;
     readonly provides: ReadonlyArray<string>;
-    readonly schema: Schema.Schema.AnyNoContext;
+    /** Multi-provider keys: every contributor's array is concatenated in graph order. */
+    readonly contributes: ReadonlyArray<string>;
+    /** Used when present (ordering and dependencies), never required. */
+    readonly optional: ReadonlyArray<string>;
+    readonly schema: Schema.Codec<any, any>;
     readonly defaults: Readonly<Record<string, unknown>>;
     readonly build: (options: unknown, services: Context.Context<never>) => Effect.Effect<Context.Context<never>, HarnessError, Scope.Scope>;
 }
+/**
+ * A plugin as its author defined it (see `definePlugin`): the erased
+ * `Plugin` the runtime loads, plus its typed parts. `live` is the plugin's
+ * own layer, with the services it provides and requires in its type, for
+ * hosts that compose layers themselves (see `stackPlugins`).
+ */
+export interface TypedPlugin<A extends Readonly<Record<string, unknown>>, I, Out, E, In> extends Plugin {
+    readonly config: Schema.Codec<A, I>;
+    readonly defaults: A;
+    /** Options merged over the defaults and decoded (extra keys fail with config.options). */
+    readonly live: (options?: Partial<I>) => Layer.Layer<Out, E | HarnessError, In>;
+}
 export {};

package/dist/harness/plugin.entity.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-export const PLUGIN_API_VERSION = 1;
+export const PLUGIN_API_VERSION = 2, SUPPORTED_PLUGIN_API_VERSIONS = [1, 2];
 
 export class HarnessError extends Schema.TaggedError()("HarnessError", {
   code: Schema.String,

package/dist/harness/session.entity.d.ts

@@ -1,33 +1,33 @@
 import { Schema } from "effect";
 export declare const SessionRecord: Schema.Struct<{
-    id: Schema.brand<typeof Schema.UUID, "ConversationId">;
-    workspace: typeof Schema.String;
-    profile: typeof Schema.String;
-    createdAt: typeof Schema.Number;
-    parent: Schema.optional<Schema.brand<typeof Schema.UUID, "ConversationId">>;
+    readonly id: Schema.brand<Schema.String, "ConversationId">;
+    readonly workspace: Schema.String;
+    readonly profile: Schema.String;
+    readonly createdAt: Schema.Number;
+    readonly parent: Schema.optional<Schema.brand<Schema.String, "ConversationId">>;
 }>;
 export type SessionRecord = typeof SessionRecord.Type;
 export declare const EventBody: Schema.Struct<{
-    name: typeof Schema.NonEmptyString;
-    runId: Schema.optional<typeof Schema.String>;
-    data: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    readonly name: Schema.NonEmptyString;
+    readonly runId: Schema.optional<Schema.String>;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
 }>;
 export type EventBody = typeof EventBody.Type;
 export declare const SessionEvent: Schema.Struct<{
-    version: Schema.Literal<[1]>;
-    id: typeof Schema.String;
-    sessionId: Schema.brand<typeof Schema.UUID, "ConversationId">;
-    seq: typeof Schema.Int;
-    at: typeof Schema.Number;
-    name: typeof Schema.NonEmptyString;
-    runId: Schema.optional<typeof Schema.String>;
-    data: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    readonly version: Schema.Literal<1>;
+    readonly id: Schema.String;
+    readonly sessionId: Schema.brand<Schema.String, "ConversationId">;
+    readonly seq: Schema.Int;
+    readonly at: Schema.Number;
+    readonly name: Schema.NonEmptyString;
+    readonly runId: Schema.optional<Schema.String>;
+    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
 }>;
 export type SessionEvent = typeof SessionEvent.Type;
 export declare const MemoryEntry: Schema.Struct<{
-    id: typeof Schema.String;
-    workspace: typeof Schema.String;
-    text: typeof Schema.String;
-    createdAt: typeof Schema.Number;
+    readonly id: Schema.String;
+    readonly workspace: Schema.String;
+    readonly text: Schema.String;
+    readonly createdAt: Schema.Number;
 }>;
 export type MemoryEntry = typeof MemoryEntry.Type;

package/dist/harness/session.entity.js

@@ -9,7 +9,7 @@ export const SessionRecord = Schema.Struct({
 }), EventBody = Schema.Struct({
   name: Schema.NonEmptyString,
   runId: Schema.optional(Schema.String),
-  data: Schema.Record({ key: Schema.String, value: Schema.Unknown })
+  data: Schema.Record(Schema.String, Schema.Unknown)
 }), SessionEvent = Schema.Struct({
   ...EventBody.fields,
   version: Schema.Literal(1),

package/dist/harness/skill-files.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import { SkillDefinition } from "./capability.entity.js";
+import { HarnessError } from "./plugin.entity.js";
+/** One file of a skills tree, as the host read it. */
+export interface SkillFile {
+    /** Relative path, `/`-separated: `<skill>/SKILL.md` or `<skill>/references/<id>.md`. */
+    readonly path: string;
+    readonly text: string;
+}
+/**
+ * Skills from markdown files. `<skill>/SKILL.md` carries flat frontmatter —
+ * `summary` (required), `id` (defaults to the directory), `version`,
+ * `tools` and `permissions` (comma-separated), `always` (`true`) — and its
+ * body is the load_skill instructions. Each `<skill>/references/<id>.md` is
+ * one reference, titled by its `title` field or first heading.
+ */
+export declare const skillsFromFiles: (files: ReadonlyArray<SkillFile>) => Effect.Effect<ReadonlyArray<SkillDefinition>, HarnessError>;

package/dist/harness/skill-files.js

@@ -0,0 +1,25 @@
+import { Effect, Option, Schema } from "effect";
+import { parseFrontmatter } from "../spec/frontmatter.js";
+import { SkillDefinition } from "./capability.entity.js";
+import { HarnessError } from "./plugin.entity.js";
+const invalid = (path, message) => new HarnessError({ code: "skills.files", message: `${path}: ${message}` }), list = (value) => (value ?? "").split(",").map((item) => item.trim()).filter((item) => item.length > 0), headingOf = (body) => Option.fromNullishOr(body.split(`
+`).find((line) => line.startsWith("# "))).pipe(Option.map((line) => line.slice(2).trim()));
+export const skillsFromFiles = (files) => Effect.forEach(files.filter((file) => /^[^/]+\/SKILL\.md$/.test(file.path)), (file) => Effect.gen(function* () {
+  const directory = file.path.split("/")[0] ?? "", parsed = yield* Option.match(parseFrontmatter(file.text), {
+    onNone: () => Effect.fail(invalid(file.path, "missing frontmatter")),
+    onSome: Effect.succeed
+  }), references = yield* Effect.forEach(files.filter((candidate) => candidate.path.startsWith(`${directory}/references/`) && candidate.path.endsWith(".md")), (reference) => {
+    const id = reference.path.slice(`${directory}/references/`.length, -3), document = Option.getOrElse(parseFrontmatter(reference.text), () => ({ fields: {}, body: reference.text })), title = Option.getOrElse(Option.orElse(Option.fromNullishOr(document.fields.title), () => headingOf(document.body)), () => id);
+    return Effect.succeed({ id, title, text: document.body.trim() });
+  }), fields = parsed.fields;
+  return yield* Schema.decodeUnknownEffect(SkillDefinition)({
+    id: fields.id ?? directory,
+    version: fields.version ?? "1",
+    summary: fields.summary ?? "",
+    instructions: parsed.body.trim(),
+    tools: list(fields.tools),
+    always: fields.always === "true",
+    permissions: list(fields.permissions),
+    references
+  }).pipe(Effect.mapError((error) => invalid(file.path, error.message)));
+}));

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { AgentMessage, AgentResult, AssistantMessage, Checkpoint, ConversationId, ReasoningPart, TextPart, ToolCallId, ToolCallPart, ToolMessage, ToolResultPart, UserMessage, } from "./domain/message.entity.js";
+export { AgentMessage, AgentResult, AssistantMessage, Checkpoint, ConversationId, ReasoningPart, TextPart, ToolCallId, ToolCallPart, ToolMessage, ToolResultPart, UserRoleMessage, } from "./domain/message.entity.js";
 export { Failure } from "./domain/failure.entity.js";
 export { toFailure } from "./domain/failure.entity.functions.js";
 export { AgentFailure, AgentFailureCategory } from "./domain/agent-failure.entity.js";
@@ -28,25 +28,68 @@ export { assistantModel, assistantUsage, extractUsage, extractModel, handoffToMe
 export type { ToolResultSummary } from "./loop/mapping.js";
 export { CurrentPromptCacheKey } from "./loop/cacheKey.js";
 export { foldStreamParts } from "./loop/streamFold.js";
+export { strictJsonSchema, toolParametersSchema } from "./loop/toolSchema.js";
 export type { FoldedTurn, StreamDelta } from "./loop/streamFold.js";
 export { McpCallOutcome, McpClient, McpError, McpToolDescriptor } from "./ports/mcp-client.port.js";
 export { buildMcpBridge, emptyMcpBridge, McpCall, McpDescribe } from "./mcp/bridge.js";
 export type { McpBridge, McpBridgedTool } from "./mcp/bridge.js";
 export { makeSession } from "./session/chassis.js";
 export type { SeqEvent, Session } from "./session/chassis.js";
+export * from "./session/session-log.entity.js";
+export * from "./ports/session-log.port.js";
+export { SessionLogMemoryLive } from "./session/session-log.memory.adapter.js";
+export { sessionLogConformance } from "./session/session-log.conformance.js";
+export * from "./session/session-event.entity.js";
+export * from "./session/session-event.entity.functions.js";
+export * from "./session/sessions.entity.js";
+export * from "./ports/sessions.port.js";
+export * from "./ports/turn-admission.port.js";
+export { TurnAdmissionOpen } from "./session/turn-admission.open.adapter.js";
+export * from "./session/tasks.entity.js";
+export * from "./ports/tasks.port.js";
 export { DEFAULT_SPEC_LIMITS, renderSpecSection, SpecCheck, SpecDoc, SpecGates, SpecLimits, SpecSlug, SpecStatus, } from "./spec/SpecDoc.js";
 export { decodeSpecDocText, encodeSpecDocText, SpecDocParseError, specSlug, uniqueSlug, } from "./spec/codec.js";
 export { parseFrontmatter } from "./spec/frontmatter.js";
 export * from "./harness/plugin.entity.js";
 export * from "./harness/plugin.adapter.js";
+export * from "./harness/plugin-stack.adapter.js";
 export * from "./harness/config.entity.js";
 export * from "./harness/session.entity.js";
 export * from "./ports/harness.port.js";
 export { defineAgent, defineConfig } from "./harness/config.entity.functions.js";
-export * from "./harness/capability.entity.js";
-export * from "./harness/capability.entity.functions.js";
-export * from "./ports/capability.port.js";
 export * from "./domain/prompt-provenance.entity.js";
 export * from "./loop/promptProvenance.js";
 export { CurrentAgentStep } from "./loop/stepContext.js";
 export * from "./decision-record.entity.js";
+export * from "./memory/memory-log.entity.js";
+export * from "./memory/memory-log.entity.functions.js";
+export * from "./memory/memory-session.js";
+export * from "./ports/memory.port.js";
+export * from "./harness/capability.entity.js";
+export * from "./harness/capability.entity.functions.js";
+export * from "./ports/capability.port.js";
+export * from "./ports/permission.port.js";
+export * from "./ports/run-context.port.js";
+export * from "./ports/tool-registry.port.js";
+export * from "./turn/user-message.entity.js";
+export * from "./turn/turn-event.entity.js";
+export * from "./turn/turn-event.entity.functions.js";
+export * from "./turn/model-request.entity.js";
+export * from "./turn/model-request.entity.functions.js";
+export * from "./turn/turn-bus.js";
+export * from "./ports/turn-events.port.js";
+export * from "./ports/step-loop.port.js";
+export * from "./ports/turn.port.js";
+export * from "./ports/turn-scope.port.js";
+export * from "./turn/prompt-sections.js";
+export * from "./turn/turn.adapter.js";
+export * from "./turn/turn-run.js";
+export * from "./turn/turn-lifecycle.js";
+export * from "./decision-record.entity.functions.js";
+export { skillsFromFiles } from "./harness/skill-files.js";
+export type { SkillFile } from "./harness/skill-files.js";
+export { ConformanceFailure } from "./conformance.entity.js";
+export type { ConformanceCheck } from "./conformance.entity.js";
+export { probeCall, stepLoopConformance, textReply } from "./turn/step-loop.conformance.js";
+export { inMemoryLog, memoryConformance } from "./memory/memory.conformance.js";
+export { turnConformance } from "./turn/turn.conformance.js";

package/dist/index.js

@@ -10,7 +10,7 @@ export {
   ToolCallPart,
   ToolMessage,
   ToolResultPart,
-  UserMessage
+  UserRoleMessage
 } from "./domain/message.entity.js";
 export { Failure } from "./domain/failure.entity.js";
 export { toFailure } from "./domain/failure.entity.functions.js";
@@ -64,9 +64,22 @@ export {
 } from "./loop/mapping.js";
 export { CurrentPromptCacheKey } from "./loop/cacheKey.js";
 export { foldStreamParts } from "./loop/streamFold.js";
+export { strictJsonSchema, toolParametersSchema } from "./loop/toolSchema.js";
 export { McpCallOutcome, McpClient, McpError, McpToolDescriptor } from "./ports/mcp-client.port.js";
 export { buildMcpBridge, emptyMcpBridge, McpCall, McpDescribe } from "./mcp/bridge.js";
 export { makeSession } from "./session/chassis.js";
+export * from "./session/session-log.entity.js";
+export * from "./ports/session-log.port.js";
+export { SessionLogMemoryLive } from "./session/session-log.memory.adapter.js";
+export { sessionLogConformance } from "./session/session-log.conformance.js";
+export * from "./session/session-event.entity.js";
+export * from "./session/session-event.entity.functions.js";
+export * from "./session/sessions.entity.js";
+export * from "./ports/sessions.port.js";
+export * from "./ports/turn-admission.port.js";
+export { TurnAdmissionOpen } from "./session/turn-admission.open.adapter.js";
+export * from "./session/tasks.entity.js";
+export * from "./ports/tasks.port.js";
 export {
   DEFAULT_SPEC_LIMITS,
   renderSpecSection,
@@ -87,14 +100,42 @@ export {
 export { parseFrontmatter } from "./spec/frontmatter.js";
 export * from "./harness/plugin.entity.js";
 export * from "./harness/plugin.adapter.js";
+export * from "./harness/plugin-stack.adapter.js";
 export * from "./harness/config.entity.js";
 export * from "./harness/session.entity.js";
 export * from "./ports/harness.port.js";
 export { defineAgent, defineConfig } from "./harness/config.entity.functions.js";
-export * from "./harness/capability.entity.js";
-export * from "./harness/capability.entity.functions.js";
-export * from "./ports/capability.port.js";
 export * from "./domain/prompt-provenance.entity.js";
 export * from "./loop/promptProvenance.js";
 export { CurrentAgentStep } from "./loop/stepContext.js";
 export * from "./decision-record.entity.js";
+export * from "./memory/memory-log.entity.js";
+export * from "./memory/memory-log.entity.functions.js";
+export * from "./memory/memory-session.js";
+export * from "./ports/memory.port.js";
+export * from "./harness/capability.entity.js";
+export * from "./harness/capability.entity.functions.js";
+export * from "./ports/capability.port.js";
+export * from "./ports/permission.port.js";
+export * from "./ports/run-context.port.js";
+export * from "./ports/tool-registry.port.js";
+export * from "./turn/user-message.entity.js";
+export * from "./turn/turn-event.entity.js";
+export * from "./turn/turn-event.entity.functions.js";
+export * from "./turn/model-request.entity.js";
+export * from "./turn/model-request.entity.functions.js";
+export * from "./turn/turn-bus.js";
+export * from "./ports/turn-events.port.js";
+export * from "./ports/step-loop.port.js";
+export * from "./ports/turn.port.js";
+export * from "./ports/turn-scope.port.js";
+export * from "./turn/prompt-sections.js";
+export * from "./turn/turn.adapter.js";
+export * from "./turn/turn-run.js";
+export * from "./turn/turn-lifecycle.js";
+export * from "./decision-record.entity.functions.js";
+export { skillsFromFiles } from "./harness/skill-files.js";
+export { ConformanceFailure } from "./conformance.entity.js";
+export { probeCall, stepLoopConformance, textReply } from "./turn/step-loop.conformance.js";
+export { inMemoryLog, memoryConformance } from "./memory/memory.conformance.js";
+export { turnConformance } from "./turn/turn.conformance.js";

package/dist/loop/cacheKey.d.ts

@@ -1,4 +1,4 @@
-import { FiberRef, Option } from "effect";
+import { Context, Option } from "effect";
 /**
  * The CURRENT conversation's cache identity, stamped by `runAgent` for the
  * duration of a run. Adapters that can key server-side prompt caches on a
@@ -6,8 +6,8 @@ import { FiberRef, Option } from "effect";
  * one conversation, one cache lane, so parallel sessions stop evicting
  * each other's prefixes. `None` (the default) sends nothing.
  *
- * A FiberRef, not a port: it's ambient call metadata, not a capability —
+ * A context reference, not a port: it's ambient call metadata, not a capability —
  * and it must flow through the loop's fibers without threading a parameter
  * through every seam.
  */
-export declare const CurrentPromptCacheKey: FiberRef.FiberRef<Option.Option<string>>;
+export declare const CurrentPromptCacheKey: Context.Reference<Option.Option<string>>;

package/dist/loop/cacheKey.js

@@ -1,2 +1,4 @@
-import { FiberRef, GlobalValue, Option } from "effect";
-export const CurrentPromptCacheKey = GlobalValue.globalValue("@xandreed/core/CurrentPromptCacheKey", () => FiberRef.unsafeMake(Option.none()));
+import { Context, Option } from "effect";
+export const CurrentPromptCacheKey = Context.Reference("@xandreed/core/CurrentPromptCacheKey", {
+  defaultValue: () => Option.none()
+});

package/dist/loop/mapping.d.ts

@@ -57,11 +57,10 @@ export interface ToolResultSummary {
 /** Tool-result summaries; `id` matches the originating call's id. */
 export declare const responseToolResults: (content: ReadonlyArray<unknown>) => ReadonlyArray<ToolResultSummary>;
 /**
- * Token usage from a response's `usage` + the finish part's metadata. The
- * Anthropic fold matters: its `input_tokens` EXCLUDES cache reads/writes
- * (both ride only in the raw usage on the finish part's anthropic metadata),
- * so without folding them back a fully-cached turn reads ~0 input.
- * Gemini/OpenAI already include cached tokens in their prompt counts.
+ * Token usage from a response's `usage` + the finish part's. Effect's
+ * providers report the FULL input (cache reads and writes included, e.g.
+ * Anthropic's `input_tokens` plus both cache counts) with the cache reads
+ * beside it; Gemini's raw usage metadata is the last fallback.
  */
 export declare const extractUsage: (usage: unknown, content: ReadonlyArray<unknown>) => TokenUsage;
 /**

package/dist/loop/mapping.js

@@ -98,7 +98,7 @@ export const toPromptMessages = (messages) => messages.map((m) => {
       type: "tool-result",
       toolCallId: ToolCallId.make(p.id ?? ""),
       toolName: p.name ?? "",
-      output: p.result,
+      output: encodedOf(p),
       isError: p.isFailure ?? !1,
       ...withProviderOptions(p.metadata)
     }
@@ -107,25 +107,17 @@ export const toPromptMessages = (messages) => messages.map((m) => {
     ...assistantParts.length > 0 ? [{ role: "assistant", content: assistantParts }] : [],
     ...toolParts.length > 0 ? [{ role: "tool", content: toolParts }] : []
   ];
-}, responseText = (content) => content.filter((p) => p.type === "text").map((p) => p.text ?? "").join(""), responseReasoning = (content) => content.filter((p) => p.type === "reasoning").map((p) => p.text ?? "").join("").trim(), responseToolCalls = (content) => content.filter((p) => p.type === "tool-call").map((p) => ({ id: p.id ?? "", toolName: p.name ?? "", args: p.params ?? {} })), responseToolResults = (content) => content.filter((p) => p.type === "tool-result").map((p) => ({
+}, responseText = (content) => content.filter((p) => p.type === "text").map((p) => p.text ?? "").join(""), responseReasoning = (content) => content.filter((p) => p.type === "reasoning").map((p) => p.text ?? "").join("").trim(), responseToolCalls = (content) => content.filter((p) => p.type === "tool-call").map((p) => ({ id: p.id ?? "", toolName: p.name ?? "", args: p.params ?? {} }));
+const encodedOf = (p) => p.encodedResult !== void 0 ? p.encodedResult : p.result;
+export const responseToolResults = (content) => content.filter((p) => p.type === "tool-result").map((p) => ({
   id: p.id ?? "",
   toolName: p.name ?? "",
   ok: !(p.isFailure ?? !1),
   result: p.result
-})), extractUsage = (usage, content) => {
-  const u = usage ?? {}, finishes = content.filter((p) => p.type === "finish"), finish = finishes.find((p) => {
-    const fu = p.usage;
-    return fu?.inputTokens !== void 0 || fu?.outputTokens !== void 0;
-  }) ?? finishes[0], gm = finish?.metadata?.google?.usageMetadata, fu = finish?.usage, inputTokens = u.inputTokens ?? fu?.inputTokens ?? gm?.promptTokenCount ?? 0, outputTokens = u.outputTokens ?? fu?.outputTokens ?? gm?.candidatesTokenCount ?? 0, totalTokens = u.totalTokens ?? fu?.totalTokens ?? gm?.totalTokenCount ?? 0, cacheReadTokens = u.cachedInputTokens ?? fu?.cachedInputTokens ?? gm?.cachedContentTokenCount ?? 0, au = finish?.metadata?.anthropic?.usage;
-  if (au !== void 0 && au !== null && typeof au === "object") {
-    const cacheRead = au.cache_read_input_tokens ?? 0, cacheWrite = au.cache_creation_input_tokens ?? 0, fullInput = inputTokens + cacheRead + cacheWrite;
-    return {
-      inputTokens: fullInput,
-      outputTokens,
-      totalTokens: fullInput + outputTokens,
-      cacheReadTokens: cacheRead
-    };
-  }
+}));
+const carriesUsage = (usage) => usage?.inputTokens?.total !== void 0 || usage?.outputTokens?.total !== void 0;
+export const extractUsage = (usage, content) => {
+  const u = usage ?? {}, finishes = content.filter((p) => p.type === "finish"), finish = finishes.find((p) => carriesUsage(p.usage)) ?? finishes[0], gm = finish?.metadata?.google?.usageMetadata, fu = finish?.usage, inputTokens = u.inputTokens?.total ?? fu?.inputTokens?.total ?? gm?.promptTokenCount ?? 0, outputTokens = u.outputTokens?.total ?? fu?.outputTokens?.total ?? gm?.candidatesTokenCount ?? 0, totalTokens = carriesUsage(u) || carriesUsage(fu) ? inputTokens + outputTokens : gm?.totalTokenCount ?? 0, cacheReadTokens = u.inputTokens?.cacheRead ?? fu?.inputTokens?.cacheRead ?? gm?.cachedContentTokenCount ?? 0;
   return { inputTokens, outputTokens, totalTokens, cacheReadTokens };
 }, withUsageOnAssistant = (messages, usage, model = Option.none()) => {
   const at = messages.findIndex((m) => m.role === "assistant"), stamp = {

package/dist/loop/modelPolicy.d.ts

@@ -1,5 +1,5 @@
-import { FiberRef, Option } from "effect";
-export declare const CurrentModelCallPolicy: FiberRef.FiberRef<Option.Option<{
+import { Context, Option } from "effect";
+export declare const CurrentModelCallPolicy: Context.Reference<Option.Option<{
     readonly effort: "none" | "low" | "medium" | "high" | "xhigh" | "max";
     readonly maxOutputTokens?: number | undefined;
 }>>;
@@ -15,7 +15,7 @@ export declare const CurrentModelCallPolicy: FiberRef.FiberRef<Option.Option<{
  * deadlines, for work that finished in seconds).
  *
  * The LOOP sets this once the run has tool calls; adapters' empty-response
- * rejection consults it at call time. A FiberRef, not a port: ambient call
+ * rejection consults it at call time. A context reference, not a port: ambient call
  * metadata, exactly like {@link CurrentModelCallPolicy}.
  */
-export declare const CurrentEmptyResponseTolerance: FiberRef.FiberRef<boolean>;
+export declare const CurrentEmptyResponseTolerance: Context.Reference<boolean>;

package/dist/loop/modelPolicy.js

@@ -1,2 +1,2 @@
-import { FiberRef, GlobalValue, Option } from "effect";
-export const CurrentModelCallPolicy = GlobalValue.globalValue("@xandreed/core/CurrentModelCallPolicy", () => FiberRef.unsafeMake(Option.none())), CurrentEmptyResponseTolerance = GlobalValue.globalValue("@xandreed/core/CurrentEmptyResponseTolerance", () => FiberRef.unsafeMake(!1));
+import { Context, Option } from "effect";
+export const CurrentModelCallPolicy = Context.Reference("@xandreed/core/CurrentModelCallPolicy", { defaultValue: () => Option.none() }), CurrentEmptyResponseTolerance = Context.Reference("@xandreed/core/CurrentEmptyResponseTolerance", { defaultValue: () => !1 });

package/dist/loop/promptProvenance.d.ts

@@ -1,5 +1,5 @@
-import { FiberRef, Option } from "effect";
-export declare const CurrentPromptProvenance: FiberRef.FiberRef<Option.Option<{
+import { Context, Option } from "effect";
+export declare const CurrentPromptProvenance: Context.Reference<Option.Option<{
     readonly id: string & import("effect/Brand").Brand<"PromptId">;
     readonly version: string;
     readonly variant: string;

package/dist/loop/promptProvenance.js

@@ -1,2 +1,2 @@
-import { FiberRef, GlobalValue, Option } from "effect";
-export const CurrentPromptProvenance = GlobalValue.globalValue("@xandreed/core/CurrentPromptProvenance", () => FiberRef.unsafeMake(Option.none()));
+import { Context, Option } from "effect";
+export const CurrentPromptProvenance = Context.Reference("@xandreed/core/CurrentPromptProvenance", { defaultValue: () => Option.none() });

package/dist/loop/stepContext.d.ts

@@ -1,3 +1,3 @@
-import { FiberRef, Option } from "effect";
+import { Context, Option } from "effect";
 /** Correlation only; unset for work outside the agent loop. */
-export declare const CurrentAgentStep: FiberRef.FiberRef<Option.Option<number>>;
+export declare const CurrentAgentStep: Context.Reference<Option.Option<number>>;

package/dist/loop/stepContext.js

@@ -1,2 +1,2 @@
-import { FiberRef, GlobalValue, Option } from "effect";
-export const CurrentAgentStep = GlobalValue.globalValue("@xandreed/core/CurrentAgentStep", () => FiberRef.unsafeMake(Option.none()));
+import { Context, Option } from "effect";
+export const CurrentAgentStep = Context.Reference("@xandreed/core/CurrentAgentStep", { defaultValue: () => Option.none() });

package/dist/loop/streamFold.js

@@ -11,11 +11,11 @@ const CHANNEL_BY_TYPE = {
     return [entry.part];
   return entry.text.length > 0 ? [{ type: entry.channel, text: entry.text }] : [];
 };
-export const foldStreamParts = (parts, onDelta) => Stream.runFoldEffect(parts, {
+export const foldStreamParts = (parts, onDelta) => Stream.runFoldEffect(parts, () => ({
   entries: [],
   finishReason: Option.none(),
   usage: Option.none()
-}, (state, part) => {
+}), (state, part) => {
   const p = part, type = p.type ?? "";
   if (type === "tool-params-start" || type === "tool-params-delta") {
     const id = p.id ?? "tool-params-1";
@@ -40,7 +40,7 @@ export const foldStreamParts = (parts, onDelta) => Stream.runFoldEffect(parts, {
     return delta.length > 0 ? onDelta({ channel, id, delta }).pipe(Effect.as(next)) : Effect.succeed(next);
   }
   if (type === "finish") {
-    const usage = p.usage, carriesUsage = usage?.inputTokens !== void 0 || usage?.outputTokens !== void 0;
+    const usage = p.usage, carriesUsage = usage?.inputTokens?.total !== void 0 || usage?.outputTokens?.total !== void 0;
     return Effect.succeed({
       entries: [...state.entries, { kind: "part", part }],
       finishReason: Option.orElse(state.finishReason, () => Option.some(p.reason ?? "unknown")),

package/dist/loop/toolSchema.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+import type { JsonSchema } from "effect";
+import type { Tool } from "effect/ai";
+/**
+ * The JSON Schema a model sees for a schema: what it can write in JSON and the
+ * schema's decoder (the one a toolkit runs on tool calls) accepts.
+ *
+ * - Objects are closed: Effect's generator leaves them open by default.
+ * - An optional key may be absent, never `null`. Effect renders a schema
+ *   through its JSON codec, where `undefined` is `null`, which the plain
+ *   decoder rejects.
+ * - Numbers are finite, since JSON has no `NaN` or `Infinity`.
+ * - Definitions are inlined under `$defs`.
+ */
+export declare const strictJsonSchema: (schema: Schema.Top) => JsonSchema.JsonSchema;
+/** A tool's parameters as the model sees them. */
+export declare const toolParametersSchema: (tool: Tool.Any) => JsonSchema.JsonSchema;

package/dist/loop/toolSchema.js

@@ -0,0 +1,25 @@
+import { Match, Record, Schema, SchemaRepresentation } from "effect";
+const finiteChecks = ((finite) => finite._tag === "Number" ? finite.checks : [])(SchemaRepresentation.toRepresentation(Schema.Finite.ast).representation), finiteIds = new Set(finiteChecks.flatMap((check) => check.representation === void 0 ? [] : [check.representation.id])), isFinite = (checks) => checks.some((check) => check.representation !== void 0 && finiteIds.has(check.representation.id)), absentWhenOptional = (isOptional, type) => {
+  if (!isOptional || type._tag !== "Union")
+    return type;
+  const types = type.types.filter((member) => member._tag !== "Undefined"), [only] = types;
+  return types.length === 1 && only !== void 0 && type.checks.length === 0 && type.annotations === void 0 ? only : { ...type, types };
+}, modelFacing = (representation) => Match.value(representation).pipe(Match.tag("Number", (number) => isFinite(number.checks) ? number : { ...number, checks: [...finiteChecks, ...number.checks] }), Match.tag("Objects", (objects) => ({
+  ...objects,
+  propertySignatures: objects.propertySignatures.map((property) => ({
+    ...property,
+    type: absentWhenOptional(property.isOptional, modelFacing(property.type))
+  })),
+  indexSignatures: objects.indexSignatures.map((signature) => ({ ...signature, type: modelFacing(signature.type) }))
+})), Match.tag("Arrays", (arrays) => ({
+  ...arrays,
+  elements: arrays.elements.map((element) => ({
+    ...element,
+    type: absentWhenOptional(element.isOptional, modelFacing(element.type))
+  })),
+  rest: arrays.rest.map(modelFacing)
+})), Match.tag("Union", (union) => ({ ...union, types: union.types.map(modelFacing) })), Match.tag("Suspend", (suspend) => ({ ...suspend, thunk: modelFacing(suspend.thunk) })), Match.orElse((other) => other));
+export const strictJsonSchema = (schema) => {
+  const document = SchemaRepresentation.toRepresentation(schema.ast), compiled = SchemaRepresentation.toJsonSchemaDocument({ representation: modelFacing(document.representation), references: Record.map(document.references, modelFacing) }, { onExcessProperty: "error" });
+  return Object.keys(compiled.definitions).length > 0 ? { ...compiled.schema, $defs: compiled.definitions } : compiled.schema;
+}, toolParametersSchema = (tool) => strictJsonSchema(tool.parametersSchema);

package/dist/loop/toolSchema.test.d.ts

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

package/dist/mcp/bridge.d.ts

@@ -1,34 +1,34 @@
-import { Tool, Toolkit } from "@effect/ai";
+import { Tool, Toolkit } from "effect/ai";
 import { Context, Effect, Schema } from "effect";
 import { McpClient } from "../ports/mcp-client.port.js";
 import type { McpToolDescriptor } from "../ports/mcp-client.port.js";
 export declare const McpDescribe: Tool.Tool<"mcp_describe", {
     readonly parameters: Schema.Struct<{
-        server: Schema.SchemaClass<string, string, never>;
-        tool: Schema.SchemaClass<string, string, never>;
+        readonly server: Schema.String;
+        readonly tool: Schema.String;
     }>;
     readonly success: Schema.Struct<{
-        server: typeof Schema.String;
-        tool: typeof Schema.String;
-        description: typeof Schema.String;
-        inputSchema: typeof Schema.Unknown;
+        readonly server: Schema.String;
+        readonly tool: Schema.String;
+        readonly description: Schema.String;
+        readonly inputSchema: Schema.Unknown;
     }>;
     readonly failure: Schema.Struct<{
-        error: typeof Schema.String;
-        message: typeof Schema.String;
+        readonly error: Schema.String;
+        readonly message: Schema.String;
     }>;
     readonly failureMode: "return";
 }, never>;
 export declare const McpCall: Tool.Tool<"mcp_call", {
     readonly parameters: Schema.Struct<{
-        server: Schema.SchemaClass<string, string, never>;
-        tool: Schema.SchemaClass<string, string, never>;
-        args: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        readonly server: Schema.String;
+        readonly tool: Schema.String;
+        readonly args: Schema.$Record<Schema.String, Schema.Unknown>;
     }>;
-    readonly success: typeof Schema.Unknown;
+    readonly success: Schema.Unknown;
     readonly failure: Schema.Struct<{
-        error: typeof Schema.String;
-        message: typeof Schema.String;
+        readonly error: Schema.String;
+        readonly message: Schema.String;
     }>;
     readonly failureMode: "return";
 }, never>;