@xandreed/core 0.4.0 → 0.11.0

package/dist/ports/conversation-store.port.d.ts

@@ -2,206 +2,80 @@ import { Context, Option, Schema } from "effect";
 import type { Effect } from "effect";
 import { AgentMessage, ConversationId } from "../domain/message.entity.js";
 import type { Checkpoint } from "../domain/message.entity.js";
-declare const StoreError_base: Schema.TaggedErrorClass<StoreError, "StoreError", {
-    readonly _tag: Schema.tag<"StoreError">;
-} & {
-    message: typeof Schema.String;
-}>;
+declare const StoreError_base: Schema.Class<StoreError, Schema.TaggedStruct<"StoreError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class StoreError extends StoreError_base {
 }
-declare const RunOutcomeRecord_base: Schema.Class<RunOutcomeRecord, {
-    conversationId: Schema.brand<typeof Schema.UUID, "ConversationId">;
-    /** Epoch millis. */
-    at: typeof Schema.Number;
-    outcome: Schema.Literal<["ok", "partial"]>;
-    reason: Schema.Literal<["completed", "step-cap", "degenerate-loop"]>;
-}, Schema.Struct.Encoded<{
-    conversationId: Schema.brand<typeof Schema.UUID, "ConversationId">;
+declare const RunOutcomeRecord_base: Schema.Class<RunOutcomeRecord, Schema.Struct<{
+    readonly conversationId: Schema.brand<Schema.String, "ConversationId">;
     /** Epoch millis. */
-    at: typeof Schema.Number;
-    outcome: Schema.Literal<["ok", "partial"]>;
-    reason: Schema.Literal<["completed", "step-cap", "degenerate-loop"]>;
-}>, never, {
-    readonly at: number;
-} & {
-    readonly conversationId: string & import("effect/Brand").Brand<"ConversationId">;
-} & {
-    readonly outcome: "ok" | "partial";
-} & {
-    readonly reason: "completed" | "step-cap" | "degenerate-loop";
-}, {}, {}>;
+    readonly at: Schema.Number;
+    readonly outcome: Schema.Literals<readonly ["ok", "partial"]>;
+    readonly reason: Schema.Literals<readonly ["completed", "step-cap", "degenerate-loop"]>;
+}>, {}>;
 /** How a run ENDED — persisted beside the trail so the database alone says
  *  whether the last run completed on its own or was stopped by the step cap
  *  or the degenerate-loop breaker (the loop's `agent_end` was in-memory only). */
 export declare class RunOutcomeRecord extends RunOutcomeRecord_base {
 }
-declare const ConversationSummary_base: Schema.Class<ConversationSummary, {
-    id: Schema.brand<typeof Schema.UUID, "ConversationId">;
-    createdAt: typeof Schema.Number;
-    firstPrompt: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    title: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    /** The latest recorded run outcome, when a run has finished in it. */
-    lastOutcome: Schema.optionalWith<Schema.Struct<{
-        outcome: Schema.Literal<["ok", "partial"]>;
-        reason: Schema.Literal<["completed", "step-cap", "degenerate-loop"]>;
-    }>, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    id: Schema.brand<typeof Schema.UUID, "ConversationId">;
-    createdAt: typeof Schema.Number;
-    firstPrompt: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    title: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+declare const ConversationSummary_base: Schema.Class<ConversationSummary, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ConversationId">;
+    readonly createdAt: Schema.Number;
+    readonly firstPrompt: Schema.OptionFromOptional<Schema.String>;
+    readonly title: Schema.OptionFromOptional<Schema.String>;
     /** The latest recorded run outcome, when a run has finished in it. */
-    lastOutcome: Schema.optionalWith<Schema.Struct<{
-        outcome: Schema.Literal<["ok", "partial"]>;
-        reason: Schema.Literal<["completed", "step-cap", "degenerate-loop"]>;
-    }>, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly createdAt: number;
-} & {
-    readonly id: string & import("effect/Brand").Brand<"ConversationId">;
-} & {
-    readonly firstPrompt: Option.Option<string>;
-} & {
-    readonly title: Option.Option<string>;
-} & {
-    readonly lastOutcome: Option.Option<{
-        readonly outcome: "ok" | "partial";
-        readonly reason: "completed" | "step-cap" | "degenerate-loop";
-    }>;
-}, {}, {}>;
+    readonly lastOutcome: Schema.OptionFromOptional<Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["ok", "partial"]>;
+        readonly reason: Schema.Literals<readonly ["completed", "step-cap", "degenerate-loop"]>;
+    }>>;
+}>, {}>;
 export declare class ConversationSummary extends ConversationSummary_base {
 }
-declare const StoredMessage_base: Schema.Class<StoredMessage, {
-    position: typeof Schema.Int;
-    message: Schema.Union<[Schema.Struct<{
-        role: Schema.Literal<["user"]>;
-        content: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+declare const StoredMessage_base: Schema.Class<StoredMessage, Schema.Struct<{
+    readonly position: Schema.Int;
+    readonly message: Schema.Union<readonly [Schema.Struct<{
+        readonly role: Schema.Literal<"user">;
+        readonly content: Schema.String;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        role: Schema.Literal<["assistant"]>;
-        content: Schema.Array$<Schema.Union<[Schema.Struct<{
-            type: Schema.Literal<["text"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly role: Schema.Literal<"assistant">;
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
         }>, Schema.Struct<{
-            type: Schema.Literal<["reasoning"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
+            readonly type: Schema.Literal<"reasoning">;
+            readonly text: Schema.String;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
         }>, Schema.Struct<{
-            type: Schema.Literal<["tool-call"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            input: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            providerExecuted: Schema.optional<typeof Schema.Boolean>;
+            readonly type: Schema.Literal<"tool-call">;
+            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+            readonly toolName: Schema.String;
+            readonly input: Schema.Unknown;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
+            readonly providerExecuted: Schema.optional<Schema.Boolean>;
         }>]>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        role: Schema.Literal<["tool"]>;
-        content: Schema.Array$<Schema.Struct<{
-            type: Schema.Literal<["tool-result"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            output: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            isError: Schema.optional<typeof Schema.Boolean>;
+        readonly role: Schema.Literal<"tool">;
+        readonly content: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"tool-result">;
+            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+            readonly toolName: Schema.String;
+            readonly output: Schema.Unknown;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
+            readonly isError: Schema.optional<Schema.Boolean>;
         }>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>]>;
-}, Schema.Struct.Encoded<{
-    position: typeof Schema.Int;
-    message: Schema.Union<[Schema.Struct<{
-        role: Schema.Literal<["user"]>;
-        content: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
-    }>, Schema.Struct<{
-        role: Schema.Literal<["assistant"]>;
-        content: Schema.Array$<Schema.Union<[Schema.Struct<{
-            type: Schema.Literal<["text"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-        }>, Schema.Struct<{
-            type: Schema.Literal<["reasoning"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-        }>, Schema.Struct<{
-            type: Schema.Literal<["tool-call"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            input: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            providerExecuted: Schema.optional<typeof Schema.Boolean>;
-        }>]>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
-    }>, Schema.Struct<{
-        role: Schema.Literal<["tool"]>;
-        content: Schema.Array$<Schema.Struct<{
-            type: Schema.Literal<["tool-result"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            output: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            isError: Schema.optional<typeof Schema.Boolean>;
-        }>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
-    }>]>;
-}>, never, {
-    readonly message: {
-        readonly providerOptions?: unknown;
-        readonly role: "user";
-        readonly content: string;
-    } | {
-        readonly providerOptions?: unknown;
-        readonly role: "assistant";
-        readonly content: readonly ({
-            readonly type: "text";
-            readonly text: string;
-            readonly providerOptions?: unknown;
-        } | {
-            readonly type: "reasoning";
-            readonly text: string;
-            readonly providerOptions?: unknown;
-        } | {
-            readonly type: "tool-call";
-            readonly providerOptions?: unknown;
-            readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
-            readonly toolName: string;
-            readonly input: unknown;
-            readonly providerExecuted?: boolean | undefined;
-        })[];
-    } | {
-        readonly providerOptions?: unknown;
-        readonly role: "tool";
-        readonly content: readonly {
-            readonly type: "tool-result";
-            readonly providerOptions?: unknown;
-            readonly toolCallId: string & import("effect/Brand").Brand<"ToolCallId">;
-            readonly toolName: string;
-            readonly output: unknown;
-            readonly isError?: boolean | undefined;
-        }[];
-    };
-} & {
-    readonly position: number;
-}, {}, {}>;
+}>, {}>;
 /** A persisted row WITH its durable position — what the active window is
  *  made of, so a loader never reconstructs positions by arithmetic (an
  *  undecodable row in between would shift every later one). */
 export declare class StoredMessage extends StoredMessage_base {
 }
-declare const ConversationStore_base: Context.TagClass<ConversationStore, "@xandreed/core/ConversationStore", {
+declare const ConversationStore_base: Context.ServiceClass<ConversationStore, "@xandreed/core/ConversationStore", {
     readonly create: (workspaceDir?: string) => Effect.Effect<ConversationId, StoreError>;
     readonly append: (id: ConversationId, message: AgentMessage) => Effect.Effect<number, StoreError>;
     /** One turn's rows land TOGETHER or not at all — an assistant tool call
@@ -235,6 +109,9 @@ declare const ConversationStore_base: Context.TagClass<ConversationStore, "@xand
     readonly prune: (beforeEpochMs: number) => Effect.Effect<number, StoreError>;
 }>;
 /**
+ * @deprecated Positional compatibility projection over SessionLog. New composable
+ * hosts use Sessions, TurnWriter and ConversationMemory directly.
+ *
  * The conversation persistence port. Positions are the durable identity:
  * `append` assigns a monotonic, immutable absolute position per conversation,
  * and UIs key their blocks on it so a live-streamed block and a later

package/dist/ports/conversation-store.port.js

@@ -9,20 +9,20 @@ export class StoreError extends Schema.TaggedError()("StoreError", {
 export class RunOutcomeRecord extends Schema.Class("RunOutcomeRecord")({
   conversationId: ConversationId,
   at: Schema.Number,
-  outcome: Schema.Literal("ok", "partial"),
-  reason: Schema.Literal("completed", "step-cap", "degenerate-loop")
+  outcome: Schema.Literals(["ok", "partial"]),
+  reason: Schema.Literals(["completed", "step-cap", "degenerate-loop"])
 }) {
 }
 
 export class ConversationSummary extends Schema.Class("ConversationSummary")({
   id: ConversationId,
   createdAt: Schema.Number,
-  firstPrompt: Schema.optionalWith(Schema.String, { as: "Option" }),
-  title: Schema.optionalWith(Schema.String, { as: "Option" }),
-  lastOutcome: Schema.optionalWith(Schema.Struct({
-    outcome: Schema.Literal("ok", "partial"),
-    reason: Schema.Literal("completed", "step-cap", "degenerate-loop")
-  }), { as: "Option" })
+  firstPrompt: Schema.OptionFromOptional(Schema.String),
+  title: Schema.OptionFromOptional(Schema.String),
+  lastOutcome: Schema.OptionFromOptional(Schema.Struct({
+    outcome: Schema.Literals(["ok", "partial"]),
+    reason: Schema.Literals(["completed", "step-cap", "degenerate-loop"])
+  }))
 }) {
 }
 
@@ -32,5 +32,5 @@ export class StoredMessage extends Schema.Class("StoredMessage")({
 }) {
 }
 
-export class ConversationStore extends Context.Tag("@xandreed/core/ConversationStore")() {
+export class ConversationStore extends Context.Service()("@xandreed/core/ConversationStore") {
 }

package/dist/ports/file-system.port.d.ts

@@ -1,14 +1,12 @@
 import { Context, Schema } from "effect";
 import type { Effect } from "effect";
-declare const FsError_base: Schema.TaggedErrorClass<FsError, "FsError", {
-    readonly _tag: Schema.tag<"FsError">;
-} & {
-    path: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FsError_base: Schema.Class<FsError, Schema.TaggedStruct<"FsError", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class FsError extends FsError_base {
 }
-declare const FileSystem_base: Context.TagClass<FileSystem, "@xandreed/core/FileSystem", {
+declare const FileSystem_base: Context.ServiceClass<FileSystem, "@xandreed/core/FileSystem", {
     readonly read: (path: string) => Effect.Effect<string, FsError>;
     readonly write: (path: string, content: string) => Effect.Effect<void, FsError>;
     readonly exists: (path: string) => Effect.Effect<boolean, FsError>;

package/dist/ports/file-system.port.js

@@ -6,5 +6,5 @@ export class FsError extends Schema.TaggedError()("FsError", {
 }) {
 }
 
-export class FileSystem extends Context.Tag("@xandreed/core/FileSystem")() {
+export class FileSystem extends Context.Service()("@xandreed/core/FileSystem") {
 }

package/dist/ports/harness.port.d.ts

@@ -1,10 +1,11 @@
 import { Context } from "effect";
 import type { Effect, Option, Stream } from "effect";
-import type { Tool, Toolkit } from "@effect/ai";
+import type { Tool, Toolkit } from "effect/ai";
 import type { AgentMessage, ConversationId } from "../domain/message.entity.js";
 import type { HarnessError } from "../harness/plugin.entity.js";
 import type { EventBody, MemoryEntry, SessionEvent, SessionRecord } from "../harness/session.entity.js";
-declare const SessionStore_base: Context.TagClass<SessionStore, "efferent/SessionStore", {
+import type { UserMessage } from "../turn/user-message.entity.js";
+declare const SessionStore_base: Context.ServiceClass<SessionStore, "efferent/SessionStore", {
     readonly create: (workspace: string, profile: string) => Effect.Effect<SessionRecord, HarnessError>;
     readonly get: (id: ConversationId) => Effect.Effect<SessionRecord, HarnessError>;
     readonly list: (workspace: string) => Effect.Effect<ReadonlyArray<SessionRecord>, HarnessError>;
@@ -12,18 +13,23 @@ declare const SessionStore_base: Context.TagClass<SessionStore, "efferent/Sessio
     readonly append: (id: ConversationId, body: EventBody) => Effect.Effect<SessionEvent, HarnessError>;
     readonly fork: (id: ConversationId, through: number) => Effect.Effect<SessionRecord, HarnessError>;
 }>;
+/** @deprecated Historical event vocabulary; live adapters project it over SessionLog. New hosts use Sessions and TurnWriter. */
 export declare class SessionStore extends SessionStore_base {
 }
 export interface LoopInput {
     readonly session: SessionRecord;
     readonly runId: string;
-    readonly prompt: string;
+    readonly userMessage: UserMessage;
     readonly system: string;
     readonly publish: (event: EventBody) => Effect.Effect<SessionEvent, HarnessError>;
     readonly transient: (event: EventBody) => Effect.Effect<void>;
     readonly steering: Effect.Effect<Option.Option<string>, HarnessError>;
+    /** Journal reads for memory plugins: events after `after`, filtered by name (all when empty). */
+    readonly history: (after: number, names: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<SessionEvent>, HarnessError>;
+    /** Host services the run's tools and hooks may require (data ports, per-turn models). */
+    readonly services: Context.Context<never>;
 }
-declare const AgentLoop_base: Context.TagClass<AgentLoop, "efferent/AgentLoop", {
+declare const AgentLoop_base: Context.ServiceClass<AgentLoop, "efferent/AgentLoop", {
     readonly run: (input: LoopInput) => Effect.Effect<{
         readonly text: string;
         readonly outcome: "completed" | "partial";
@@ -31,7 +37,7 @@ declare const AgentLoop_base: Context.TagClass<AgentLoop, "efferent/AgentLoop",
 }>;
 export declare class AgentLoop extends AgentLoop_base {
 }
-declare const DelegateLoop_base: Context.TagClass<DelegateLoop, "efferent/DelegateLoop", {
+declare const DelegateLoop_base: Context.ServiceClass<DelegateLoop, "efferent/DelegateLoop", {
     readonly run: (input: LoopInput) => Effect.Effect<{
         readonly text: string;
         readonly outcome: "completed" | "partial";
@@ -40,24 +46,24 @@ declare const DelegateLoop_base: Context.TagClass<DelegateLoop, "efferent/Delega
 /** A workflow can delegate coding while retaining its own outer loop. */
 export declare class DelegateLoop extends DelegateLoop_base {
 }
-declare const AgentTools_base: Context.TagClass<AgentTools, "efferent/AgentTools", {
+declare const AgentTools_base: Context.ServiceClass<AgentTools, "efferent/AgentTools", {
     readonly toolkit: Toolkit.Toolkit<Record<string, Tool.Any>>;
     readonly handlers: Context.Context<Tool.HandlersFor<Record<string, Tool.Any>>>;
     readonly prompt: string;
 }>;
 export declare class AgentTools extends AgentTools_base {
 }
-declare const ActionPolicy_base: Context.TagClass<ActionPolicy, "efferent/ActionPolicy", {
+declare const ActionPolicy_base: Context.ServiceClass<ActionPolicy, "efferent/ActionPolicy", {
     readonly authorize: (tool: string, input: unknown) => Effect.Effect<void, HarnessError>;
 }>;
 export declare class ActionPolicy extends ActionPolicy_base {
 }
-declare const Approval_base: Context.TagClass<Approval, "efferent/Approval", {
+declare const Approval_base: Context.ServiceClass<Approval, "efferent/Approval", {
     readonly request: (description: string) => Effect.Effect<boolean, HarnessError>;
 }>;
 export declare class Approval extends Approval_base {
 }
-declare const ContextManager_base: Context.TagClass<ContextManager, "efferent/ContextManager", {
+declare const ContextManager_base: Context.ServiceClass<ContextManager, "efferent/ContextManager", {
     readonly compact: (messages: ReadonlyArray<AgentMessage>, tokens: number) => Effect.Effect<Option.Option<{
         readonly summary: string;
         readonly keepFrom: number;
@@ -65,20 +71,20 @@ declare const ContextManager_base: Context.TagClass<ContextManager, "efferent/Co
 }>;
 export declare class ContextManager extends ContextManager_base {
 }
-declare const Memory_base: Context.TagClass<Memory, "efferent/Memory", {
+declare const Memory_base: Context.ServiceClass<Memory, "efferent/Memory", {
     readonly recall: (workspace: string, query: string) => Effect.Effect<ReadonlyArray<MemoryEntry>, HarnessError>;
     readonly remember: (workspace: string, text: string) => Effect.Effect<MemoryEntry, HarnessError>;
     readonly forget: (workspace: string, id: string) => Effect.Effect<void, HarnessError>;
 }>;
 export declare class Memory extends Memory_base {
 }
-declare const SessionEnvironment_base: Context.TagClass<SessionEnvironment, "efferent/SessionEnvironment", {
+declare const SessionEnvironment_base: Context.ServiceClass<SessionEnvironment, "efferent/SessionEnvironment", {
     readonly workspace: string;
     readonly session?: SessionRecord;
 }>;
 export declare class SessionEnvironment extends SessionEnvironment_base {
 }
-declare const TurnHooks_base: Context.TagClass<TurnHooks, "efferent/TurnHooks", {
+declare const TurnHooks_base: Context.ServiceClass<TurnHooks, "efferent/TurnHooks", {
     readonly before: (input: LoopInput) => Effect.Effect<LoopInput, HarnessError>;
     readonly after: (input: LoopInput) => Effect.Effect<void, HarnessError>;
 }>;
@@ -87,7 +93,7 @@ export declare class TurnHooks extends TurnHooks_base {
 }
 export interface SessionHandle {
     readonly record: SessionRecord;
-    readonly use: <I, A, B, E, R>(tag: Context.Tag<I, A>, run: (service: A) => Effect.Effect<B, E, R>) => Effect.Effect<B, E | HarnessError, R>;
+    readonly use: <I, A, B, E, R>(tag: Context.Service<I, A>, run: (service: A) => Effect.Effect<B, E, R>) => Effect.Effect<B, E | HarnessError, R>;
     readonly send: (text: string) => Effect.Effect<void, HarnessError>;
     readonly steer: (text: string) => Effect.Effect<void, HarnessError>;
     readonly interrupt: Effect.Effect<void>;

package/dist/ports/harness.port.js

@@ -1,31 +1,31 @@
 import { Context } from "effect";
 
-export class SessionStore extends Context.Tag("efferent/SessionStore")() {
+export class SessionStore extends Context.Service()("efferent/SessionStore") {
 }
 
-export class AgentLoop extends Context.Tag("efferent/AgentLoop")() {
+export class AgentLoop extends Context.Service()("efferent/AgentLoop") {
 }
 
-export class DelegateLoop extends Context.Tag("efferent/DelegateLoop")() {
+export class DelegateLoop extends Context.Service()("efferent/DelegateLoop") {
 }
 
-export class AgentTools extends Context.Tag("efferent/AgentTools")() {
+export class AgentTools extends Context.Service()("efferent/AgentTools") {
 }
 
-export class ActionPolicy extends Context.Tag("efferent/ActionPolicy")() {
+export class ActionPolicy extends Context.Service()("efferent/ActionPolicy") {
 }
 
-export class Approval extends Context.Tag("efferent/Approval")() {
+export class Approval extends Context.Service()("efferent/Approval") {
 }
 
-export class ContextManager extends Context.Tag("efferent/ContextManager")() {
+export class ContextManager extends Context.Service()("efferent/ContextManager") {
 }
 
-export class Memory extends Context.Tag("efferent/Memory")() {
+export class Memory extends Context.Service()("efferent/Memory") {
 }
 
-export class SessionEnvironment extends Context.Tag("efferent/SessionEnvironment")() {
+export class SessionEnvironment extends Context.Service()("efferent/SessionEnvironment") {
 }
 
-export class TurnHooks extends Context.Tag("efferent/TurnHooks")() {
+export class TurnHooks extends Context.Service()("efferent/TurnHooks") {
 }

package/dist/ports/mcp-client.port.d.ts

@@ -1,11 +1,9 @@
 import { Context, Schema } from "effect";
 import type { Effect } from "effect";
-declare const McpError_base: Schema.TaggedErrorClass<McpError, "McpError", {
-    readonly _tag: Schema.tag<"McpError">;
-} & {
-    server: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const McpError_base: Schema.Class<McpError, Schema.TaggedStruct<"McpError", {
+    readonly server: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 /**
  * The MCP client port — external, user-configured tool servers surfaced to
  * agents through the ordinary toolkit machinery (see `mcp/bridge.ts`). The
@@ -15,55 +13,25 @@ declare const McpError_base: Schema.TaggedErrorClass<McpError, "McpError", {
  */
 export declare class McpError extends McpError_base {
 }
-declare const McpToolDescriptor_base: Schema.Class<McpToolDescriptor, {
-    server: typeof Schema.String;
-    name: typeof Schema.String;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    /** The server's inputSchema, verbatim JSON Schema — the provider sees it
-     *  unchanged through the bridge's annotation override. */
-    inputSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-}, Schema.Struct.Encoded<{
-    server: typeof Schema.String;
-    name: typeof Schema.String;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
+declare const McpToolDescriptor_base: Schema.Class<McpToolDescriptor, Schema.Struct<{
+    readonly server: Schema.String;
+    readonly name: Schema.String;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
     /** The server's inputSchema, verbatim JSON Schema — the provider sees it
      *  unchanged through the bridge's annotation override. */
-    inputSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-}>, never, {
-    readonly description: import("effect/Option").Option<string>;
-} & {
-    readonly name: string;
-} & {
-    readonly server: string;
-} & {
-    readonly inputSchema: {
-        readonly [x: string]: unknown;
-    };
-}, {}, {}>;
+    readonly inputSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, {}>;
 export declare class McpToolDescriptor extends McpToolDescriptor_base {
 }
-declare const McpCallOutcome_base: Schema.Class<McpCallOutcome, {
-    /** MCP's in-band failure flag — bridged to failure-as-data, never thrown. */
-    isError: typeof Schema.Boolean;
-    /** structuredContent when the server sent it, else the text blocks joined. */
-    result: typeof Schema.Unknown;
-}, Schema.Struct.Encoded<{
+declare const McpCallOutcome_base: Schema.Class<McpCallOutcome, Schema.Struct<{
     /** MCP's in-band failure flag — bridged to failure-as-data, never thrown. */
-    isError: typeof Schema.Boolean;
+    readonly isError: Schema.Boolean;
     /** structuredContent when the server sent it, else the text blocks joined. */
-    result: typeof Schema.Unknown;
-}>, never, {
-    readonly isError: boolean;
-} & {
-    readonly result: unknown;
-}, {}, {}>;
+    readonly result: Schema.Unknown;
+}>, {}>;
 export declare class McpCallOutcome extends McpCallOutcome_base {
 }
-declare const McpClient_base: Context.TagClass<McpClient, "@xandreed/core/McpClient", {
+declare const McpClient_base: Context.ServiceClass<McpClient, "@xandreed/core/McpClient", {
     /** Aggregate across every configured server — best-effort: an
      *  unreachable server contributes nothing, never a failure. */
     readonly listTools: Effect.Effect<ReadonlyArray<McpToolDescriptor>>;

package/dist/ports/mcp-client.port.js

@@ -9,8 +9,8 @@ export class McpError extends Schema.TaggedError()("McpError", {
 export class McpToolDescriptor extends Schema.Class("McpToolDescriptor")({
   server: Schema.String,
   name: Schema.String,
-  description: Schema.optionalWith(Schema.String, { as: "Option" }),
-  inputSchema: Schema.Record({ key: Schema.String, value: Schema.Unknown })
+  description: Schema.OptionFromOptional(Schema.String),
+  inputSchema: Schema.Record(Schema.String, Schema.Unknown)
 }) {
 }
 
@@ -20,5 +20,5 @@ export class McpCallOutcome extends Schema.Class("McpCallOutcome")({
 }) {
 }
 
-export class McpClient extends Context.Tag("@xandreed/core/McpClient")() {
+export class McpClient extends Context.Service()("@xandreed/core/McpClient") {
 }