@xandreed/core 0.12.0 → 0.13.0

package/README.md

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

package/dist/index.d.ts

@@ -15,7 +15,6 @@ export type { ModelCallPolicy as ModelCallPolicyType } from "./domain/model-call
 export { CurrentEmptyResponseTolerance, CurrentModelCallPolicy } from "./loop/modelPolicy.js";
 export { formatModelSelection, parseModelSelection } from "./domain/model-selection.entity.functions.js";
 export type { LoopEvent, ToolCallSummary } from "./domain/loop-event.entity.js";
-export { ConversationStore, ConversationSummary, RunOutcomeRecord, StoredMessage, StoreError, } from "./ports/conversation-store.port.js";
 export { EngineSettings, SETTINGS_KEYS, SettingsError, SettingsStore, } from "./ports/settings-store.port.js";
 export type { ModelRole, SettingsKey } from "./ports/settings-store.port.js";
 export { AuthError, AuthStore, Credential } from "./ports/auth-store.port.js";
@@ -54,7 +53,6 @@ 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 "./domain/prompt-provenance.entity.js";

package/dist/index.js

@@ -27,13 +27,6 @@ export { ModelCallPolicy, ReasoningEffort } from "./domain/model-call-policy.ent
 export { ModelCatalogEntry } from "./domain/model-catalog.entity.js";
 export { CurrentEmptyResponseTolerance, CurrentModelCallPolicy } from "./loop/modelPolicy.js";
 export { formatModelSelection, parseModelSelection } from "./domain/model-selection.entity.functions.js";
-export {
-  ConversationStore,
-  ConversationSummary,
-  RunOutcomeRecord,
-  StoredMessage,
-  StoreError
-} from "./ports/conversation-store.port.js";
 export {
   EngineSettings,
   SETTINGS_KEYS,
@@ -102,7 +95,6 @@ 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 "./domain/prompt-provenance.entity.js";

package/dist/loop/cacheKey.d.ts

@@ -1,6 +1,6 @@
 import { Context, Option } from "effect";
 /**
- * The CURRENT conversation's cache identity, stamped by `runAgent` for the
+ * The CURRENT conversation's cache identity, stamped by the step loop for the
  * duration of a run. Adapters that can key server-side prompt caches on a
  * stable id (OpenAI-compatible `prompt_cache_key`) read it at call time —
  * one conversation, one cache lane, so parallel sessions stop evicting

package/dist/loop/mapping.d.ts

@@ -11,7 +11,7 @@ import type { TokenUsage } from "../domain/token-usage.entity.js";
  * by hand and keeps the blob). Everything here is pure: no mutation, no IO.
  */
 /** Wrap a fold summary as the single user message standing in for the folded
- *  history — prepended by `runAgent` when the conversation has a checkpoint. */
+ *  history — prepended when memory replays a conversation from a checkpoint. */
 export declare const handoffToMessage: (summary: string) => AgentMessage;
 /**
  * The largest SAFE fold cut keeping at least `keepTurns` assistant turns

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

@@ -1,112 +1,14 @@
 import { Context } from "effect";
-import type { Effect, Option, Stream } from "effect";
-import type { Tool, Toolkit } from "effect/ai";
-import type { AgentMessage, ConversationId } from "../domain/message.entity.js";
+import type { Effect } from "effect";
 import type { HarnessError } from "../harness/plugin.entity.js";
-import type { EventBody, MemoryEntry, SessionEvent, SessionRecord } from "../harness/session.entity.js";
-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>;
-    readonly read: (id: ConversationId, after: number) => Effect.Effect<ReadonlyArray<SessionEvent>, HarnessError>;
-    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 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.ServiceClass<AgentLoop, "efferent/AgentLoop", {
-    readonly run: (input: LoopInput) => Effect.Effect<{
-        readonly text: string;
-        readonly outcome: "completed" | "partial";
-    }, HarnessError>;
-}>;
-export declare class AgentLoop extends AgentLoop_base {
-}
-declare const DelegateLoop_base: Context.ServiceClass<DelegateLoop, "efferent/DelegateLoop", {
-    readonly run: (input: LoopInput) => Effect.Effect<{
-        readonly text: string;
-        readonly outcome: "completed" | "partial";
-    }, HarnessError>;
-}>;
-/** A workflow can delegate coding while retaining its own outer loop. */
-export declare class DelegateLoop extends DelegateLoop_base {
-}
-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.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.ServiceClass<Approval, "efferent/Approval", {
-    readonly request: (description: string) => Effect.Effect<boolean, HarnessError>;
-}>;
-export declare class Approval extends Approval_base {
-}
-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;
-    }>, HarnessError>;
-}>;
-export declare class ContextManager extends ContextManager_base {
-}
-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.ServiceClass<SessionEnvironment, "efferent/SessionEnvironment", {
     readonly workspace: string;
-    readonly session?: SessionRecord;
 }>;
 export declare class SessionEnvironment extends SessionEnvironment_base {
 }
-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>;
-}>;
-/** Ordered hooks alter a turn; observers subscribe to the journal separately. */
-export declare class TurnHooks extends TurnHooks_base {
-}
-export interface SessionHandle {
-    readonly record: SessionRecord;
-    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>;
-    readonly events: (after?: number) => Stream.Stream<SessionEvent, HarnessError>;
-    readonly transient: Stream.Stream<EventBody>;
-    readonly history: Effect.Effect<ReadonlyArray<SessionEvent>, HarnessError>;
-    readonly busy: Effect.Effect<boolean>;
-    readonly pending: Effect.Effect<ReadonlyArray<{
-        readonly id: string;
-        readonly text: string;
-    }>>;
-    readonly continue: Effect.Effect<void, HarnessError>;
-    readonly refresh: Effect.Effect<void, HarnessError>;
-    readonly close: Effect.Effect<void>;
-}
 export {};

package/dist/ports/harness.port.js

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

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@xandreed/core",
-  "version": "0.12.0",
+  "version": "0.13.0",
+  "engines": {
+    "node": ">=24",
+    "bun": ">=1.3.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,7 +16,7 @@
     }
   },
   "dependencies": {
-    "effect": "4.0.0-rc.118"
+    "effect": "4.0.7"
   },
   "types": "./dist/index.d.ts",
   "files": [
@@ -22,9 +26,5 @@
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "node": ">=24",
-    "bun": ">=1.3.0"
-  },
   "license": "MIT"
 }

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

@@ -1,33 +0,0 @@
-import { Schema } from "effect";
-export declare const SessionRecord: Schema.Struct<{
-    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<{
-    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<{
-    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<{
-    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

@@ -1,25 +0,0 @@
-import { Schema } from "effect";
-import { ConversationId } from "../domain/message.entity.js";
-export const SessionRecord = Schema.Struct({
-  id: ConversationId,
-  workspace: Schema.String,
-  profile: Schema.String,
-  createdAt: Schema.Number,
-  parent: Schema.optional(ConversationId)
-}), EventBody = Schema.Struct({
-  name: Schema.NonEmptyString,
-  runId: Schema.optional(Schema.String),
-  data: Schema.Record(Schema.String, Schema.Unknown)
-}), SessionEvent = Schema.Struct({
-  ...EventBody.fields,
-  version: Schema.Literal(1),
-  id: Schema.String,
-  sessionId: ConversationId,
-  seq: Schema.Int,
-  at: Schema.Number
-}), MemoryEntry = Schema.Struct({
-  id: Schema.String,
-  workspace: Schema.String,
-  text: Schema.String,
-  createdAt: Schema.Number
-});

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

@@ -1,127 +0,0 @@
-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.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, Schema.Struct<{
-    readonly conversationId: Schema.brand<Schema.String, "ConversationId">;
-    /** Epoch millis. */
-    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, 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. */
-    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, 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<{
-        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<{
-            readonly type: Schema.Literal<"reasoning">;
-            readonly text: Schema.String;
-            readonly providerOptions: Schema.optional<Schema.Unknown>;
-        }>, Schema.Struct<{
-            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>;
-        }>]>>;
-        readonly providerOptions: Schema.optional<Schema.Unknown>;
-    }>, Schema.Struct<{
-        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>;
-        }>>;
-        readonly providerOptions: Schema.optional<Schema.Unknown>;
-    }>]>;
-}>, {}>;
-/** 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.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
-     *  without its results is a row the next run cannot send. Returns the
-     *  positions, aligned with the input. */
-    readonly appendAll: (id: ConversationId, messages: ReadonlyArray<AgentMessage>) => Effect.Effect<ReadonlyArray<number>, StoreError>;
-    readonly list: (id: ConversationId) => Effect.Effect<ReadonlyArray<AgentMessage>, StoreError>;
-    /** The rows after the latest fold, each with its position. */
-    readonly listActive: (id: ConversationId) => Effect.Effect<ReadonlyArray<StoredMessage>, StoreError>;
-    readonly checkpoint: (id: ConversationId, summary: string) => Effect.Effect<void, StoreError>;
-    /** A fold up to an EXPLICIT position (the within-run compaction seam):
-     *  rows at or before it are covered by the summary; `listActive` returns
-     *  only the rows after. `checkpoint` folds everything appended so far. */
-    readonly checkpointAt: (id: ConversationId, summary: string, messagePosition: number) => Effect.Effect<void, StoreError>;
-    readonly latestCheckpoint: (id: ConversationId) => Effect.Effect<Option.Option<Checkpoint>, StoreError>;
-    readonly setTitle: (id: ConversationId, title: string) => Effect.Effect<void, StoreError>;
-    /** Record how a run ended (appended; the latest is the conversation's). */
-    readonly recordOutcome: (id: ConversationId, outcome: RunOutcomeRecord["outcome"], reason: RunOutcomeRecord["reason"]) => Effect.Effect<void, StoreError>;
-    readonly latestOutcome: (id: ConversationId) => Effect.Effect<Option.Option<RunOutcomeRecord>, StoreError>;
-    readonly listByWorkspace: (workspaceDir: string) => Effect.Effect<ReadonlyArray<ConversationSummary>, StoreError>;
-    /** BRANCH: copy rows [0..upToPosition] (default: all) into a NEW
-     *  conversation in the same workspace, along with the latest covered
-     *  checkpoint — the original stays untouched; the fork continues
-     *  independently (git-branch semantics over the trail). */
-    readonly fork: (id: ConversationId, upToPosition?: number) => Effect.Effect<ConversationId, StoreError>;
-    /** RETENTION: delete whole conversations created before `beforeEpochMs`
-     *  (messages + checkpoints + the conversation row) and reclaim the
-     *  space. Nothing calls this automatically — deletion is a deliberate,
-     *  human-initiated act on an otherwise append-only store. Returns the
-     *  number of conversations removed. */
-    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
- * re-projection of the same message reconcile instead of duplicating.
- *
- * A checkpoint FOLDS the history for loading purposes only: `list` always
- * returns every row; `listActive` returns the rows after the latest fold.
- * The loop prepends the fold's summary itself (domain logic stays here,
- * not in the adapter).
- */
-export declare class ConversationStore extends ConversationStore_base {
-}
-export {};

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

@@ -1,36 +0,0 @@
-import { Context, Option, Schema } from "effect";
-import { AgentMessage, ConversationId } from "../domain/message.entity.js";
-
-export class StoreError extends Schema.TaggedError()("StoreError", {
-  message: Schema.String
-}) {
-}
-
-export class RunOutcomeRecord extends Schema.Class("RunOutcomeRecord")({
-  conversationId: ConversationId,
-  at: Schema.Number,
-  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.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"])
-  }))
-}) {
-}
-
-export class StoredMessage extends Schema.Class("StoredMessage")({
-  position: Schema.Int,
-  message: AgentMessage
-}) {
-}
-
-export class ConversationStore extends Context.Service()("@xandreed/core/ConversationStore") {
-}