@xandreed/core 0.3.0 → 0.8.0-next.0

package/dist/memory/memory-log.entity.js

@@ -0,0 +1,75 @@
+import { Schema } from "effect";
+import { AgentMessage, ToolCallId } from "../domain/message.entity.js";
+import { DecisionId } from "../decision-record.entity.js";
+import { UserMessageFromString } from "../turn/user-message.entity.js";
+export const EntryId = Schema.Trimmed.check(Schema.isNonEmpty()).pipe(Schema.brand("EntryId")), Subject = Schema.Struct({
+  kind: Schema.Trimmed.check(Schema.isNonEmpty()),
+  id: Schema.Trimmed.check(Schema.isNonEmpty()),
+  label: Schema.OptionFromNullOr(Schema.String),
+  data: Schema.OptionFromNullOr(Schema.Unknown)
+}), ArtifactRef = Schema.Struct({
+  id: Schema.Trimmed.check(Schema.isNonEmpty()),
+  kind: Schema.Literals(["image", "file"]),
+  mediaType: Schema.Trimmed.check(Schema.isNonEmpty()),
+  url: Schema.String,
+  alt: Schema.OptionFromNullOr(Schema.String)
+}), CompactionAction = Schema.Union([
+  Schema.TaggedStruct("CompactViews", { entries: Schema.Array(EntryId), texts: Schema.Array(Schema.String) }),
+  Schema.TaggedStruct("Spill", { entry: EntryId, preview: Schema.String }),
+  Schema.TaggedStruct("DropTurns", { throughTurn: Schema.Int, ledger: Schema.String }),
+  Schema.TaggedStruct("Summarize", { keepFromTurn: Schema.Int, summary: Schema.String })
+]), ActivationSource = Schema.Literals(["always", "matcher", "load_skill", "host"]), LogBody = Schema.Union([
+  Schema.TaggedStruct("SystemPrepared", {
+    fingerprint: Schema.String,
+    text: Schema.String,
+    sections: Schema.Array(Schema.Struct({ id: Schema.String, version: Schema.String, fingerprint: Schema.String }))
+  }),
+  Schema.TaggedStruct("TurnStarted", { userMessage: UserMessageFromString }).pipe(Schema.encodeKeys({ userMessage: "prompt" })),
+  Schema.TaggedStruct("TurnContext", { sectionId: Schema.String, version: Schema.String, text: Schema.String }),
+  Schema.TaggedStruct("Message", { message: AgentMessage }),
+  Schema.TaggedStruct("ToolResult", {
+    toolCallId: ToolCallId,
+    toolName: Schema.String,
+    isError: Schema.Boolean,
+    encoded: Schema.Unknown,
+    view: Schema.String,
+    viewVersion: Schema.String,
+    subjects: Schema.Array(Subject),
+    artifacts: Schema.Array(ArtifactRef),
+    pinned: Schema.Boolean
+  }),
+  Schema.TaggedStruct("ToolDigest", {
+    entry: EntryId,
+    version: Schema.String,
+    mode: Schema.Literals(["select", "summarize"]),
+    keep: Schema.Array(Schema.String),
+    text: Schema.String,
+    digester: Schema.String,
+    trigger: Schema.Literals(["write", "compaction"])
+  }),
+  Schema.TaggedStruct("StepContext", { step: Schema.Int, text: Schema.String }),
+  Schema.TaggedStruct("ToolsActivated", {
+    skills: Schema.Array(Schema.String),
+    tools: Schema.Array(Schema.String),
+    source: ActivationSource,
+    decision: Schema.OptionFromNullOr(DecisionId)
+  }),
+  Schema.TaggedStruct("Compaction", { strategy: Schema.String, version: Schema.String, action: CompactionAction }),
+  Schema.TaggedStruct("TurnEnded", {
+    outcome: Schema.Literals(["completed", "partial", "failed"]),
+    reply: Schema.OptionFromNullOr(Schema.String)
+  })
+]), LogEntry = Schema.Struct({
+  id: EntryId,
+  runId: Schema.String,
+  turn: Schema.Int,
+  step: Schema.Int,
+  at: Schema.Number,
+  body: LogBody
+}), BuiltContext = Schema.Struct({
+  messages: Schema.Array(AgentMessage),
+  fingerprint: Schema.String,
+  estimatedTokens: Schema.Int,
+  compactions: Schema.Array(EntryId),
+  through: Schema.OptionFromNullOr(EntryId)
+});

package/dist/memory/memory-log.entity.test.d.ts

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

package/dist/memory/memory-session.d.ts

@@ -0,0 +1,51 @@
+import { Effect, Option } from "effect";
+import type { AgentMessage } from "../domain/message.entity.js";
+import type { HarnessError } from "../harness/plugin.entity.js";
+import type { LogHandle, MaintainSignal, MemoryReader, MemorySession } from "../ports/memory.port.js";
+import type { CompactionAction, EntryId, LogEntry } from "./memory-log.entity.js";
+import type { RenderOptions } from "./memory-log.entity.functions.js";
+/** What a strategy decides at one maintain point. */
+export interface MaintainDecision {
+    readonly actions: ReadonlyArray<CompactionAction>;
+    /** Tool-result entries to digest now (recorded with trigger "compaction"). */
+    readonly digest: ReadonlyArray<EntryId>;
+}
+export declare const noMaintenance: MaintainDecision;
+/** What distinguishes one memory strategy from another. */
+export interface MemoryPolicy {
+    readonly strategy: {
+        readonly id: string;
+        readonly version: string;
+    };
+    readonly render: Pick<RenderOptions, "turnContext" | "replies" | "digests" | "media">;
+    /** Digest a result as it is written; None never digests at write time. */
+    readonly digestOnWrite: Option.Option<(result: {
+        readonly tool: string;
+        readonly chars: number;
+    }) => boolean>;
+    /** Digest calls run at once (default 4); results are recorded in log order either way. */
+    readonly digestConcurrency?: number;
+    /** Decide compactions and digests from the full log; the session records them before the next build. */
+    readonly maintain: (input: {
+        readonly entries: ReadonlyArray<LogEntry>;
+        readonly signal: MaintainSignal;
+        readonly turn: number;
+        readonly runId: string;
+        /** The render the strategy would send now (its own compactions applied). */
+        readonly render: (entries: ReadonlyArray<LogEntry>) => ReadonlyArray<AgentMessage>;
+    }) => Effect.Effect<MaintainDecision, HarnessError>;
+}
+/** The read-only view of a session, as tools, sections, matchers and reactions get it. */
+export declare const readerOf: (session: MemorySession) => MemoryReader;
+/**
+ * The shared session over a log handle. It loads the log once, assigns
+ * entry ids (`<runId>:<n>`), appends through to storage, runs the tools'
+ * digests the strategy asks for (with the `ResultDigester` of the environment
+ * it is opened in, when there is one, for the latest user message: a log
+ * without one digests nothing), and renders with the strategy's own compactions — so
+ * every strategy stores, retrieves and rebuilds the same way and differs only
+ * in the decisions it records.
+ */
+export declare const openLogSession: (log: LogHandle, policy: MemoryPolicy, scope: {
+    readonly runId: string;
+}) => Effect.Effect<MemorySession, HarnessError>;

package/dist/memory/memory-session.js

@@ -0,0 +1,97 @@
+import { Clock, Effect, Option, Ref, Semaphore } from "effect";
+import { ResultDigester } from "../ports/memory.port.js";
+import {
+  buildContext,
+  currentTurnOf,
+  entryId,
+  queryLog,
+  rawTranscript,
+  referenceTranscript,
+  renderLog,
+  subjectsOf,
+  toolInputsOf
+} from "./memory-log.entity.functions.js";
+export const noMaintenance = { actions: [], digest: [] };
+const defaultDigestConcurrency = 4;
+export const readerOf = (session) => ({
+  turn: session.turn,
+  entries: session.entries,
+  query: session.query,
+  subjects: session.subjects,
+  resolve: session.resolve,
+  transcript: session.transcript
+});
+const latestUserMessage = (entries) => Option.fromNullishOr(entries.flatMap((entry) => entry.body._tag === "TurnStarted" ? [entry.body.userMessage] : []).at(-1));
+export const openLogSession = (log, policy, scope) => Effect.gen(function* () {
+  const runId = scope.runId, digester = yield* Effect.serviceOption(ResultDigester), stored = yield* log.read, entries = yield* Ref.make(stored), counter = yield* Ref.make(stored.filter((entry) => entry.runId === runId).length), writing = yield* Semaphore.make(1), renderOptions = (all, stepContext) => ({
+    ...policy.render,
+    stepContext,
+    strategy: policy.strategy.id,
+    currentTurn: currentTurnOf(all),
+    currentRun: runId
+  }), record = (bodies, step) => bodies.length === 0 ? Effect.succeed([]) : writing.withPermits(1)(Effect.gen(function* () {
+    const current = currentTurnOf(yield* Ref.get(entries)), turn = bodies.some((body) => body._tag === "TurnStarted") ? current + 1 : Math.max(current, 1), at = yield* Clock.currentTimeMillis, start = yield* Ref.get(counter), appended = bodies.map((body, index) => ({ id: entryId(runId, start + index), runId, turn, step, at, body }));
+    yield* log.append(appended);
+    yield* Ref.set(counter, start + bodies.length);
+    yield* Ref.update(entries, (all) => [...all, ...appended]);
+    return appended;
+  })), digest = (targets, views, trigger, step) => Ref.get(entries).pipe(Effect.flatMap((all) => Option.match(Option.all([digester, latestUserMessage(all)]), {
+    onNone: () => Effect.succeed([]),
+    onSome: ([service, userMessage]) => Effect.gen(function* () {
+      const inputs = toolInputsOf(all, []), bodies = yield* Effect.forEach(targets, (entry) => entry.body._tag !== "ToolResult" || entry.body.isError ? Effect.succeed([]) : views.digest(entry.body.toolName, entry.body.encoded, inputs.get(String(entry.body.toolCallId)) ?? {}, userMessage).pipe(Effect.flatMap(Option.match({
+        onNone: () => Effect.succeed([]),
+        onSome: (task) => service.digest(task).pipe(Effect.map((outcome) => Option.toArray(Option.map(task.apply(outcome), (text) => ({
+          _tag: "ToolDigest",
+          entry: entry.id,
+          version: task.version,
+          mode: task.mode,
+          keep: outcome.keep,
+          text,
+          digester: `${service.id}@${service.version}`,
+          trigger
+        })))), Effect.orElseSucceed(() => []))
+      }))), { concurrency: policy.digestConcurrency ?? defaultDigestConcurrency });
+      return yield* record(bodies.flat(), step);
+    })
+  }))), recordTail = (tail, views, step) => Effect.gen(function* () {
+    const inputs = toolInputsOf(yield* Ref.get(entries), tail), bodies = yield* Effect.forEach(tail, (message) => message.role !== "tool" ? Effect.succeed([{ _tag: "Message", message }]) : Effect.forEach(message.content, (part) => {
+      const params = inputs.get(String(part.toolCallId)) ?? {};
+      return views.view(part.toolName, part.output, params, part.isError ?? !1).pipe(Effect.map((view) => ({
+        _tag: "ToolResult",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        isError: part.isError ?? !1,
+        encoded: part.output,
+        view: view.text,
+        viewVersion: view.version,
+        subjects: view.subjects,
+        artifacts: view.artifacts,
+        pinned: view.pinned
+      })));
+    })), recorded = yield* record(bodies.flat(), step), onWrite = policy.digestOnWrite, targets = Option.isNone(onWrite) ? [] : recorded.filter((entry) => entry.body._tag === "ToolResult" && onWrite.value({ tool: entry.body.toolName, chars: entry.body.view.length })), digests = yield* digest(targets, views, "write", step);
+    return [...recorded, ...digests];
+  }), maintain = (signal) => Effect.gen(function* () {
+    const all = yield* Ref.get(entries), decision = yield* policy.maintain({
+      entries: all,
+      signal,
+      turn: currentTurnOf(all),
+      runId,
+      render: (candidate) => renderLog(candidate, renderOptions(candidate, "tail"))
+    }), compactions = yield* record(decision.actions.map((action) => ({ _tag: "Compaction", strategy: policy.strategy.id, version: policy.strategy.version, action })), 0), wanted = new Set(decision.digest.map(String)), digests = yield* digest(all.filter((entry) => wanted.has(String(entry.id))), signal.views, "compaction", 0);
+    return [...compactions, ...digests];
+  });
+  return {
+    strategy: policy.strategy,
+    renderRecipe: (stepContext) => Ref.get(entries).pipe(Effect.map((all) => renderOptions(all, stepContext))),
+    turn: Ref.get(entries).pipe(Effect.map(currentTurnOf)),
+    entries: Ref.get(entries),
+    query: (query) => Ref.get(entries).pipe(Effect.map((all) => queryLog(all, query))),
+    subjects: (kinds) => Ref.get(entries).pipe(Effect.map((all) => subjectsOf(all, kinds))),
+    resolve: (id) => Ref.get(entries).pipe(Effect.map((all) => Option.fromNullishOr(all.find((entry) => entry.id === id)))),
+    transcript: (fidelity) => Ref.get(entries).pipe(Effect.map((all) => fidelity === "raw" ? rawTranscript(all) : fidelity === "reference" ? referenceTranscript(all) : renderLog(all, renderOptions(all, "tail")))),
+    record,
+    recordTail,
+    maintain,
+    build: ({ stepContext }) => Ref.get(entries).pipe(Effect.map((all) => buildContext(all, renderOptions(all, stepContext))))
+  };
+});

package/dist/memory/memory-session.test.d.ts

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

package/dist/memory/memory.conformance.d.ts

@@ -0,0 +1,32 @@
+import { Context, Effect, Option, Ref } from "effect";
+import type { ConformanceCheck } from "../conformance.entity.js";
+import type { ConversationMemory, LogHandle } from "../ports/memory.port.js";
+/**
+ * A memory log held as session events, through the storage codec: what a
+ * turn's log does, without a session. The user's message is stored as its
+ * own `turn.started`, as a session's begin stores it.
+ */
+export declare const inMemoryLog: Effect.Effect<{
+    stored: Ref.Ref<readonly {
+        readonly session: string & import("effect/Brand").Brand<"ConversationId">;
+        readonly seq: number;
+        readonly turn: Option.Option<number>;
+        readonly kind: string;
+        readonly at: number;
+        readonly data: {
+            readonly [x: string]: unknown;
+        };
+    }[]>;
+    log: LogHandle;
+}, never, never>;
+type Memory = Context.Service.Shape<typeof ConversationMemory>;
+/**
+ * The ConversationMemory contract, as checks any strategy must pass: own
+ * entry ids, a log that reads back exactly after a reopen, views and
+ * artifacts kept, a pure build, the step context only when asked,
+ * append-only maintenance and a reference transcript without tool traffic.
+ * `services` are the turn services the strategy needs (a summarizer…); each
+ * session is opened with them provided.
+ */
+export declare const memoryConformance: (memory: Memory, services?: Context.Context<never>) => ReadonlyArray<ConformanceCheck>;
+export {};

package/dist/memory/memory.conformance.js

@@ -0,0 +1,102 @@
+import { Context, Effect, Option, Ref, Schema } from "effect";
+import { ConformanceFailure } from "../conformance.entity.js";
+import { ConversationId, ToolCallId } from "../domain/message.entity.js";
+import { HarnessError } from "../harness/plugin.entity.js";
+import { draftOfEntry, entriesOfEvents, turnStartedDraft } from "../session/session-event.entity.functions.js";
+import { UserMessage } from "../turn/user-message.entity.js";
+import { canonicalJson } from "./memory-log.entity.functions.js";
+import { LogEntry } from "./memory-log.entity.js";
+const conversation = ConversationId.make("00000000-0000-4000-8000-00000000c0f0");
+export const inMemoryLog = Effect.gen(function* () {
+  const stored = yield* Ref.make([]), codec = (error) => new HarnessError({ code: "memory.log", message: error.message }), log = {
+    read: Ref.get(stored).pipe(Effect.flatMap(entriesOfEvents), Effect.mapError(codec)),
+    append: (entries) => Effect.forEach(entries, (entry) => (entry.body._tag === "TurnStarted" ? turnStartedDraft(entry.turn, {
+      runId: entry.runId,
+      key: entry.runId,
+      origin: "user",
+      userMessage: entry.body.userMessage,
+      command: {},
+      claimed: [],
+      entry: entry.id,
+      at: entry.at
+    }).pipe(Effect.map(Option.some)) : draftOfEntry(entry)).pipe(Effect.mapError(codec))).pipe(Effect.flatMap((drafts) => Ref.update(stored, (all) => [...all, ...drafts.flatMap(Option.toArray).map((draft, index) => ({
+      session: conversation,
+      seq: all.length + index + 1,
+      turn: draft.turn,
+      kind: draft.kind,
+      at: 0,
+      data: JSON.parse(JSON.stringify(draft.data))
+    }))])))
+  };
+  return { stored, log };
+});
+const artifact = { id: "artifact-1", kind: "image", mediaType: "image/png", url: "https://example.test/artifact-1.png", alt: Option.some("a figure") }, views = {
+  view: (_tool, encoded) => Effect.succeed({ text: `VIEW ${canonicalJson(encoded)}`, version: "1", subjects: [], artifacts: [artifact], pinned: !1 }),
+  compact: () => Effect.succeed(Option.none()),
+  digest: () => Effect.succeed(Option.none())
+}, callId = ToolCallId.make("conformance-call"), toolTail = [
+  { role: "assistant", content: [{ type: "tool-call", toolCallId: callId, toolName: "lookup", input: { query: "alpha" } }] },
+  { role: "tool", content: [{ type: "tool-result", toolCallId: callId, toolName: "lookup", output: { id: "record-alpha" }, isError: !1 }] }
+], encodeEntries = (entries) => canonicalJson(Schema.encodeSync(Schema.Array(LogEntry))(entries)), fail = (check) => (message) => Effect.fail(new ConformanceFailure({ check, message })), expect = (check, holds, message) => holds ? Effect.void : fail(check)(message), said = (text) => ({ _tag: "TurnStarted", userMessage: new UserMessage({ text }) }), recordTurn = (session, userMessage, reply) => Effect.gen(function* () {
+  yield* session.record([said(userMessage)], 0);
+  yield* session.recordTail(toolTail, views, 0);
+  yield* session.record([{ _tag: "TurnEnded", outcome: "completed", reply: Option.some(reply) }], 1);
+});
+export const memoryConformance = (memory, services = Context.empty()) => {
+  const check = (name, id, body) => ({
+    name,
+    run: Effect.scoped(Effect.gen(function* () {
+      const stored = yield* inMemoryLog;
+      yield* body((log, runId) => memory.open({ conversation, runId, log }).pipe(Effect.provide(services)), stored.log);
+    })).pipe(Effect.catchTag("HarnessError", (error) => fail(id)(`${error.code}: ${error.message}`)))
+  });
+  return [
+    check("entries get their own ids, <runId>:<n>, continuing across reopens", "ids", (open, log) => Effect.gen(function* () {
+      const a = yield* (yield* open(log, "run-1")).record([said("one"), { _tag: "TurnContext", sectionId: "s", version: "1", text: "context" }], 0), b = yield* (yield* open(log, "run-1")).record([{ _tag: "TurnEnded", outcome: "completed", reply: Option.none() }], 0), c = yield* (yield* open(log, "run-2")).record([said("two")], 0), ids = [...a, ...b, ...c].map((entry) => String(entry.id));
+      yield* expect("ids", ids.join() === "run-1:0,run-1:1,run-1:2,run-2:0", `ids were ${ids.join()}`);
+    })),
+    check("a reopened session reads back exactly what was recorded, and builds the same context", "reopen", (open, log) => Effect.gen(function* () {
+      const session = yield* open(log, "run-1");
+      yield* recordTurn(session, "find alpha", "found record-alpha");
+      const reopened = yield* open(log, "run-1");
+      yield* expect("reopen", encodeEntries(yield* reopened.entries) === encodeEntries(yield* session.entries), "the reopened log differs");
+      const [left, right] = [yield* session.build({ stepContext: "tail" }), yield* reopened.build({ stepContext: "tail" })];
+      yield* expect("reopen", left.fingerprint === right.fingerprint, "the reopened session builds a different context");
+    })),
+    check("tool results keep their views and artifacts", "views", (open, log) => Effect.gen(function* () {
+      const session = yield* open(log, "run-1");
+      yield* recordTurn(session, "find alpha", "found record-alpha");
+      const result = (yield* (yield* open(log, "run-1")).entries).find((entry) => entry.body._tag === "ToolResult");
+      yield* expect("views", result?.body._tag === "ToolResult" && result.body.view.startsWith("VIEW ") && result.body.artifacts[0]?.id === artifact.id, "the tool result lost its view or artifacts");
+    })),
+    check("build is a pure fold of the log", "pure", (open, log) => Effect.gen(function* () {
+      const session = yield* open(log, "run-1");
+      yield* recordTurn(session, "find alpha", "found record-alpha");
+      const [left, right] = [yield* session.build({ stepContext: "tail" }), yield* session.build({ stepContext: "tail" })];
+      yield* expect("pure", left.fingerprint === right.fingerprint && canonicalJson(left.messages) === canonicalJson(right.messages), "two builds differ");
+    })),
+    check("the step context closes the tail only when asked", "step-context", (open, log) => Effect.gen(function* () {
+      const session = yield* open(log, "run-1");
+      yield* session.record([said("find alpha")], 0);
+      yield* session.record([{ _tag: "StepContext", step: 0, text: "STEP-MARK" }], 0);
+      const tail = canonicalJson((yield* session.build({ stepContext: "tail" })).messages), none = canonicalJson((yield* session.build({ stepContext: "none" })).messages);
+      yield* expect("step-context", tail.includes("STEP-MARK") && !none.includes("STEP-MARK"), "the step context is misplaced");
+    })),
+    check("maintenance only appends to the log", "append-only", (open, log) => Effect.gen(function* () {
+      const session = yield* open(log, "run-1");
+      yield* recordTurn(session, "find alpha", "found record-alpha");
+      yield* session.record([said("and beta")], 0);
+      const before = yield* session.entries;
+      yield* session.maintain({ phase: "turn-start", lastUsage: Option.none(), budgetTokens: 1e5, views });
+      yield* session.maintain({ phase: "step", lastUsage: Option.none(), budgetTokens: 1e5, views });
+      const after = yield* session.entries;
+      yield* expect("append-only", encodeEntries(after.slice(0, before.length)) === encodeEntries(before), "maintenance rewrote earlier entries");
+    })),
+    check("the reference transcript holds user messages and replies, never tool traffic", "reference", (open, log) => Effect.gen(function* () {
+      const session = yield* open(log, "run-1");
+      yield* recordTurn(session, "find alpha", "found record-alpha");
+      const transcript = yield* session.transcript("reference"), text = canonicalJson(transcript);
+      yield* expect("reference", transcript.every((message) => message.role === "user" || message.role === "assistant") && text.includes("find alpha") && text.includes("found record-alpha") && !text.includes("tool-call"), `reference transcript: ${text.slice(0, 300)}`);
+    }))
+  ];
+};

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

@@ -7,30 +7,28 @@ import type { ProviderId } from "../domain/model-selection.entity.js";
  * needs no key. Matches the on-disk `auth.json` vocabulary the previous line
  * established, so existing credentials keep working.
  */
-export declare const Credential: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["api_key"]>;
-    key: typeof Schema.String;
+export declare const Credential: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"api_key">;
+    readonly key: Schema.String;
 }>, Schema.Struct<{
-    type: Schema.Literal<["oauth"]>;
-    access: typeof Schema.String;
-    refresh: typeof Schema.String;
-    expires: typeof Schema.Number;
-    accountId: Schema.optional<typeof Schema.String>;
-    installationId: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literal<"oauth">;
+    readonly access: Schema.String;
+    readonly refresh: Schema.String;
+    readonly expires: Schema.Number;
+    readonly accountId: Schema.optional<Schema.String>;
+    readonly installationId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["local"]>;
-    baseUrl: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literal<"local">;
+    readonly baseUrl: Schema.optional<Schema.String>;
 }>]>;
 export type Credential = typeof Credential.Type;
-declare const AuthError_base: Schema.TaggedErrorClass<AuthError, "AuthError", {
-    readonly _tag: Schema.tag<"AuthError">;
-} & {
-    provider: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const AuthError_base: Schema.Class<AuthError, Schema.TaggedStruct<"AuthError", {
+    readonly provider: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class AuthError extends AuthError_base {
 }
-declare const AuthStore_base: Context.TagClass<AuthStore, "@xandreed/core/AuthStore", {
+declare const AuthStore_base: Context.ServiceClass<AuthStore, "@xandreed/core/AuthStore", {
     readonly all: Effect.Effect<ReadonlyMap<string, Credential>, AuthError>;
     readonly get: (p: ProviderId) => Effect.Effect<Option.Option<Credential>, AuthError>;
     readonly resolveKey: (p: ProviderId) => Effect.Effect<Option.Option<Redacted.Redacted<string>>, AuthError>;

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

@@ -1,12 +1,16 @@
 import { Context, Option, Schema } from "effect";
-export const Credential = Schema.Union(Schema.Struct({ type: Schema.Literal("api_key"), key: Schema.String }), Schema.Struct({
-  type: Schema.Literal("oauth"),
-  access: Schema.String,
-  refresh: Schema.String,
-  expires: Schema.Number,
-  accountId: Schema.optional(Schema.String),
-  installationId: Schema.optional(Schema.String)
-}), Schema.Struct({ type: Schema.Literal("local"), baseUrl: Schema.optional(Schema.String) }));
+export const Credential = Schema.Union([
+  Schema.Struct({ type: Schema.Literal("api_key"), key: Schema.String }),
+  Schema.Struct({
+    type: Schema.Literal("oauth"),
+    access: Schema.String,
+    refresh: Schema.String,
+    expires: Schema.Number,
+    accountId: Schema.optional(Schema.String),
+    installationId: Schema.optional(Schema.String)
+  }),
+  Schema.Struct({ type: Schema.Literal("local"), baseUrl: Schema.optional(Schema.String) })
+]);
 
 export class AuthError extends Schema.TaggedError()("AuthError", {
   provider: Schema.String,
@@ -14,5 +18,5 @@ export class AuthError extends Schema.TaggedError()("AuthError", {
 }) {
 }
 
-export class AuthStore extends Context.Tag("@xandreed/core/AuthStore")() {
+export class AuthStore extends Context.Service()("@xandreed/core/AuthStore") {
 }

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

@@ -1,15 +1,139 @@
 import { Context } from "effect";
-import type { Effect } from "effect";
-import type { CapabilityCatalog, CapabilitySelection } from "../harness/capability.entity.js";
+import type { Effect, Option } from "effect";
+import type { LanguageModel, Tool } from "effect/ai";
+import type { AgentMessage } from "../domain/message.entity.js";
+import type { TokenUsage } from "../domain/token-usage.entity.js";
+import type { PromptTier, SkillDefinition, ToolAnnotations } from "../harness/capability.entity.js";
 import type { HarnessError } from "../harness/plugin.entity.js";
-declare const Capabilities_base: Context.TagClass<Capabilities, "efferent/Capabilities", {
-    readonly catalog: CapabilityCatalog;
-}>;
+import type { ArtifactRef, Subject } from "../memory/memory-log.entity.js";
+import type { UserMessage } from "../turn/user-message.entity.js";
+/**
+ * How a tool's long result may be digested for the current user message, with the
+ * tool's own prompt. The memory strategy decides WHEN (on write above a size,
+ * or at compaction); the digester runs it; the outcome is logged once.
+ * `Select` (preferred) keeps whole items by key and re-renders them, so every
+ * identifier the answer may cite survives. `Summarize` is accepted only when
+ * every `preserve`d identifier appears verbatim in the summary.
+ */
+export type DigestDefinition<Result, Params> = {
+    readonly _tag: "Select";
+    readonly version: string;
+    readonly instructions: string;
+    readonly items: (result: Result) => ReadonlyArray<{
+        readonly key: string;
+        readonly text: string;
+    }>;
+    readonly render: (result: Result, params: Params, keep: ReadonlyArray<string>) => string;
+} | {
+    readonly _tag: "Summarize";
+    readonly version: string;
+    readonly instructions: string;
+    readonly preserve: (result: Result) => ReadonlyArray<string>;
+};
+/** How one tool's result appears in context — owned by the tool, applied by memory. */
+export interface ToolViewDefinition<Result, Params> {
+    readonly version: string;
+    /** The exact text the model sees when the result is written. */
+    readonly render: (result: Result, params: Params) => string;
+    /** The older-turn form; None keeps `render`'s text. */
+    readonly compact: Option.Option<(result: Result, params: Params) => string>;
+    readonly subjects: (result: Result, params: Params) => ReadonlyArray<Subject>;
+    /** Files and images the result carries, kept by reference. */
+    readonly artifacts: (result: Result, params: Params) => ReadonlyArray<ArtifactRef>;
+    readonly digest: Option.Option<DigestDefinition<Result, Params>>;
+}
+/** The view as an author writes it; optional parts default in `defineTool`. */
+export interface ToolViewInput<Result, Params> {
+    readonly version: string;
+    readonly render: (result: Result, params: Params) => string;
+    readonly compact?: (result: Result, params: Params) => string;
+    readonly subjects?: (result: Result, params: Params) => ReadonlyArray<Subject>;
+    readonly artifacts?: (result: Result, params: Params) => ReadonlyArray<ArtifactRef>;
+    readonly digest?: DigestDefinition<Result, Params>;
+}
+/** A typed tool definition as its author writes it (see `defineTool`). */
+export interface ToolDefinition<T extends Tool.Any, R> {
+    readonly tool: T;
+    readonly handler: (params: Tool.Parameters<T>) => Effect.Effect<Tool.Success<T>, Tool.Failure<T>, R>;
+    readonly view: Option.Option<ToolViewDefinition<Tool.Success<T>, Tool.Parameters<T>>>;
+    readonly annotations: ToolAnnotations;
+}
+/** The erased form the registry consumes; its requirements are provided per run. */
+export interface RegisteredTool {
+    readonly tool: Tool.Any;
+    readonly handler: (params: unknown) => Effect.Effect<unknown, unknown, unknown>;
+    readonly view: Option.Option<ToolViewDefinition<unknown, unknown>>;
+    readonly annotations: ToolAnnotations;
+}
+export interface PromptContext {
+    readonly variant: Option.Option<string>;
+    readonly active: ReadonlyArray<string>;
+    readonly skills: ReadonlyArray<SkillDefinition>;
+}
+/** One section of the system prompt (static/session) or of the turn context (turn). */
+export interface PromptSection {
+    readonly id: string;
+    readonly version: string;
+    readonly tier: PromptTier;
+    readonly order: number;
+    readonly render: (context: PromptContext) => Effect.Effect<Option.Option<string>, HarnessError, unknown>;
+}
+export interface StepInfo {
+    readonly stepIndex: number;
+    readonly activeTools: ReadonlyArray<string>;
+    readonly lastUsage: Option.Option<TokenUsage>;
+}
+export type ToolChoice = "required" | {
+    readonly tool: string;
+};
+export interface StepDirective {
+    /** Appended at the end of the context for this step only. */
+    readonly context: Option.Option<string>;
+    readonly toolChoice: Option.Option<ToolChoice>;
+}
+export interface InitialBatch {
+    readonly calls: ReadonlyArray<{
+        readonly name: string;
+        readonly params: unknown;
+    }>;
+    /** Skills the batch needs, activated before it runs. */
+    readonly skills: ReadonlyArray<string>;
+}
+export interface ModelChoice {
+    readonly model: LanguageModel.LanguageModel;
+    /** Selects a system-prompt variant; sections receive it. */
+    readonly variant: Option.Option<string>;
+}
+/** One bundle a host (or a capability plugin) contributes. */
+export interface Capability {
+    readonly id: string;
+    readonly version: string;
+    readonly tools: ReadonlyArray<RegisteredTool>;
+    readonly skills: ReadonlyArray<SkillDefinition>;
+    readonly promptSections: ReadonlyArray<PromptSection>;
+}
+declare const Capabilities_base: Context.ServiceClass<Capabilities, "efferent/Capabilities", readonly Capability[]>;
+/** A MULTI-provider key: every contributor's bundle, in graph order. */
 export declare class Capabilities extends Capabilities_base {
 }
-declare const IntentMatcher_base: Context.TagClass<IntentMatcher, "efferent/IntentMatcher", {
-    readonly match: (message: string, catalog: CapabilityCatalog) => Effect.Effect<CapabilitySelection, HarnessError>;
+export interface IntentMatch {
+    readonly skills: ReadonlyArray<string>;
+    readonly probabilities: Option.Option<Readonly<Record<string, number>>>;
+    /** The matcher declined to choose; the turn runs on always-on skills. */
+    readonly abstained: boolean;
+}
+declare const IntentMatcher_base: Context.ServiceClass<IntentMatcher, "efferent/IntentMatcher", {
+    readonly id: string;
+    readonly version: string;
+    readonly match: (input: {
+        readonly userMessage: UserMessage;
+        readonly skills: ReadonlyArray<SkillDefinition>;
+        readonly active: ReadonlyArray<string>;
+        /** A reference transcript: user messages and replies only. */
+        readonly history: ReadonlyArray<AgentMessage>;
+    }) => Effect.Effect<IntentMatch, HarnessError>;
 }>;
+/** Pre-turn skill selection. Probabilistic intent never authorizes: the registry resolves grants. */
 export declare class IntentMatcher extends IntentMatcher_base {
 }
 export {};

package/dist/ports/capability.port.js

@@ -1,7 +1,7 @@
 import { Context } from "effect";
 
-export class Capabilities extends Context.Tag("efferent/Capabilities")() {
+export class Capabilities extends Context.Service()("efferent/Capabilities") {
 }
 
-export class IntentMatcher extends Context.Tag("efferent/IntentMatcher")() {
+export class IntentMatcher extends Context.Service()("efferent/IntentMatcher") {
 }