effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/capabilities/Redaction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Redaction.mjs","names":[],"sources":["../../src/capabilities/Redaction.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\n\nimport { utf8ByteLength } from \"../core/internal/utf8.ts\";\nimport { RunEvent } from \"../core/RunEvent.ts\";\n\nconst MAX_REDACTED_PREVIEW_BYTES = 8 * 1024;\nconst MAX_REDACTION_NODES = 4_096;\nconst MAX_REDACTION_DEPTH = 16;\n\n/** Branded evidence that a preview passed through the configured structural Redactor. */\nexport const RedactedPreview = Schema.String.pipe(\n  Schema.refine((value): value is string => utf8ByteLength(value) <= MAX_REDACTED_PREVIEW_BYTES, {\n    expected: `redacted preview of at most ${MAX_REDACTED_PREVIEW_BYTES} UTF-8 bytes`,\n  }),\n  Schema.brand(\"@effect-agent/capabilities/RedactedPreview\"),\n);\n\nexport type RedactedPreview = typeof RedactedPreview.Type;\n\n/** Structural redaction failed closed rather than returning unreviewed caller text. */\nexport class RedactionError extends Schema.TaggedError<RedactionError>()(\"RedactionError\", {\n  reason: Schema.Literals([\"input-too-deep\", \"input-too-large\", \"encoding-failed\"]),\n  message: Schema.String,\n}) {}\n\n/** Redaction owns the boundary from decoded Tool values to bounded audit/model previews. */\nexport class Redactor extends Context.Service<\n  Redactor,\n  {\n    readonly redact: (decodedValue: unknown) => Effect.Effect<RedactedPreview, RedactionError>;\n  }\n>()(\"@effect-agent/capabilities/Redactor\") {}\n\ninterface RedactionCounter {\n  nodes: number;\n}\n\nconst redactValue = (value: unknown, depth: number, counter: RedactionCounter): Schema.Json => {\n  if (depth > MAX_REDACTION_DEPTH) {\n    throw RedactionError.make({\n      reason: \"input-too-deep\",\n      message: `Decoded value exceeds redaction depth ${MAX_REDACTION_DEPTH}`,\n    });\n  }\n  counter.nodes += 1;\n  if (counter.nodes > MAX_REDACTION_NODES) {\n    throw RedactionError.make({\n      reason: \"input-too-large\",\n      message: `Decoded value exceeds redaction node count ${MAX_REDACTION_NODES}`,\n    });\n  }\n  if (Array.isArray(value)) {\n    return value.map((item) => redactValue(item, depth + 1, counter));\n  }\n  if (value !== null && typeof value === \"object\") {\n    const redacted: Record<string, Schema.Json> = {};\n\n    for (const [key, item] of Object.entries(value)) {\n      redacted[key] = redactValue(item, depth + 1, counter);\n    }\n\n    return redacted;\n  }\n  // The default policy is deliberately type-aware and fail-closed: it preserves\n  // object/array shape for reviewer context but never copies a decoded scalar,\n  // regardless of its field name. Applications that need visible values provide\n  // a Tool-specific Redactor after validating those values against that Tool's\n  // input Schema.\n  if (value === null) return \"[REDACTED:null]\";\n  if (typeof value === \"string\") return \"[REDACTED:string]\";\n  if (typeof value === \"number\") return \"[REDACTED:number]\";\n  if (typeof value === \"boolean\") return \"[REDACTED:boolean]\";\n\n  return \"[REDACTED:unsupported]\";\n};\n\nconst truncateUtf8 = (value: string, maxBytes: number): string => {\n  if (utf8ByteLength(value) <= maxBytes) {\n    return value;\n  }\n  const suffix = \"…\";\n  const suffixBytes = utf8ByteLength(suffix);\n  let output = \"\";\n  let bytes = 0;\n\n  for (const character of value) {\n    const characterBytes = utf8ByteLength(character);\n\n    if (bytes + characterBytes + suffixBytes > maxBytes) {\n      break;\n    }\n    output += character;\n    bytes += characterBytes;\n  }\n\n  return `${output}${suffix}`;\n};\n\nconst encodeRunEvent = Schema.encodeEffect(RunEvent);\n\n/**\n * One composed step from live Run Events to structurally redacted transcript lines\n * (P7 WP7 friction fix; SEC-008/testing.md §12 \"structurally redacted\" live transcripts):\n * Schema-encode each event through the canonical `RunEvent` union, then pass the encoded\n * value through the configured `Redactor` — so the safe path is the short path and no live\n * suite hand-assembles (or accidentally skips) the encode→redact pair. Engine-constructed\n * events always encode, so an encode failure is a defect, never a silent omission.\n */\nexport const redactedTranscript = (\n  events: Iterable<RunEvent>,\n): Effect.Effect<ReadonlyArray<RedactedPreview>, RedactionError, Redactor> =>\n  Effect.gen(function* () {\n    const redactor = yield* Redactor;\n    const lines: Array<RedactedPreview> = [];\n\n    for (const event of events) {\n      const encoded = yield* encodeRunEvent(event).pipe(Effect.orDie);\n\n      lines.push(yield* redactor.redact(encoded));\n    }\n\n    return lines;\n  });\n\n/**\n * Default structural implementation. It exposes only collection shape and\n * scalar types, so an ordinary field such as `note` cannot bypass redaction.\n * Tool-specific Layers may expose explicitly reviewed fields instead.\n */\nexport const StructuralRedactorLive = Layer.succeed(Redactor)({\n  redact: (decodedValue) =>\n    Effect.try({\n      try: () => {\n        const structurallyRedacted = redactValue(decodedValue, 0, { nodes: 0 });\n\n        return truncateUtf8(JSON.stringify(structurallyRedacted), MAX_REDACTED_PREVIEW_BYTES);\n      },\n      catch: (cause) =>\n        Schema.is(RedactionError)(cause)\n          ? cause\n          : RedactionError.make({\n              reason: \"encoding-failed\",\n              message: \"Could not encode the structurally redacted preview\",\n            }),\n    }).pipe(\n      Effect.flatMap((preview) =>\n        Schema.decodeEffect(RedactedPreview)(preview).pipe(\n          Effect.mapError(() =>\n            RedactionError.make({\n              reason: \"encoding-failed\",\n              message: \"Redacted preview did not satisfy its bounded schema\",\n            }),\n          ),\n        ),\n      ),\n    ),\n});\n"],"mappings":";;;;;;;;;;;;AAKA,MAAM,6BAA6B;AACnC,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB;;AAG5B,MAAa,kBAAkB,OAAO,OAAO,KAC3C,OAAO,QAAQ,UAA2B,eAAe,KAAK,KAAK,4BAA4B,EAC7F,UAAU,+BAA+B,2BAA2B,cACtE,CAAC,GACD,OAAO,MAAM,4CAA4C,CAC3D;;AAKA,IAAa,iBAAb,cAAoC,OAAO,YAA4B,CAAC,CAAC,kBAAkB;CACzF,QAAQ,OAAO,SAAS;EAAC;EAAkB;EAAmB;CAAiB,CAAC;CAChF,SAAS,OAAO;AAClB,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,WAAb,cAA8B,QAAQ,QAKpC,CAAC,CAAC,qCAAqC,CAAC,CAAC,CAAC;AAM5C,MAAM,eAAe,OAAgB,OAAe,YAA2C;CAC7F,IAAI,QAAQ,qBACV,MAAM,eAAe,KAAK;EACxB,QAAQ;EACR,SAAS,yCAAyC;CACpD,CAAC;CAEH,QAAQ,SAAS;CACjB,IAAI,QAAQ,QAAQ,qBAClB,MAAM,eAAe,KAAK;EACxB,QAAQ;EACR,SAAS,8CAA8C;CACzD,CAAC;CAEH,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,KAAK,SAAS,YAAY,MAAM,QAAQ,GAAG,OAAO,CAAC;CAElE,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;EAC/C,MAAM,WAAwC,CAAC;EAE/C,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,KAAK,GAC5C,SAAS,OAAO,YAAY,MAAM,QAAQ,GAAG,OAAO;EAGtD,OAAO;CACT;CAMA,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,OAAO,UAAU,WAAW,OAAO;CAEvC,OAAO;AACT;AAEA,MAAM,gBAAgB,OAAe,aAA6B;CAChE,IAAI,eAAe,KAAK,KAAK,UAC3B,OAAO;CAET,MAAM,SAAS;CACf,MAAM,cAAc,eAAe,MAAM;CACzC,IAAI,SAAS;CACb,IAAI,QAAQ;CAEZ,KAAK,MAAM,aAAa,OAAO;EAC7B,MAAM,iBAAiB,eAAe,SAAS;EAE/C,IAAI,QAAQ,iBAAiB,cAAc,UACzC;EAEF,UAAU;EACV,SAAS;CACX;CAEA,OAAO,GAAG,SAAS;AACrB;AAEA,MAAM,iBAAiB,OAAO,aAAa,QAAQ;;;;;;;;;AAUnD,MAAa,sBACX,WAEA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAO;CACxB,MAAM,QAAgC,CAAC;CAEvC,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,UAAU,OAAO,eAAe,KAAK,CAAC,CAAC,KAAK,OAAO,KAAK;EAE9D,MAAM,KAAK,OAAO,SAAS,OAAO,OAAO,CAAC;CAC5C;CAEA,OAAO;AACT,CAAC;;;;;;AAOH,MAAa,yBAAyB,MAAM,QAAQ,QAAQ,CAAC,CAAC,EAC5D,SAAS,iBACP,OAAO,IAAI;CACT,WAAW;EACT,MAAM,uBAAuB,YAAY,cAAc,GAAG,EAAE,OAAO,EAAE,CAAC;EAEtE,OAAO,aAAa,KAAK,UAAU,oBAAoB,GAAG,0BAA0B;CACtF;CACA,QAAQ,UACN,OAAO,GAAG,cAAc,CAAC,CAAC,KAAK,IAC3B,QACA,eAAe,KAAK;EAClB,QAAQ;EACR,SAAS;CACX,CAAC;AACT,CAAC,CAAC,CAAC,KACD,OAAO,SAAS,YACd,OAAO,aAAa,eAAe,CAAC,CAAC,OAAO,CAAC,CAAC,KAC5C,OAAO,eACL,eAAe,KAAK;CAClB,QAAQ;CACR,SAAS;AACX,CAAC,CACH,CACF,CACF,CACF,EACJ,CAAC"}

package/dist/capabilities/Remembering.d.mts

@@ -0,0 +1,434 @@
+import { n as MemoryContent } from "../MemoryReference-B8Q3UJoJ.mjs";
+import { t as Any } from "../MemoryNamespace-BbRW5p71.mjs";
+import { MemoryDocument, MemoryMutationFailure, MemoryOperationConflict, MemoryReader, MemoryStorageError, MemoryWriter } from "../core/MemoryStore.mjs";
+import { Admission, AdmissionError, BoundCheckpoint, CheckpointError, Extracted, Intent, Invalidation, InvalidationReceipt, MutationFailpoint, MutationFailure, ProcessingError, Store } from "../core/RememberingStore.mjs";
+import { Effect, Schema } from "effect";
+declare namespace Remembering_d_exports {
+  export { CleanupInput, Decision, Limits, MergeInput, SourceSnapshot, admit, invalidate, make };
+}
+declare const Limits_base: Schema.Class<Limits, Schema.Struct<{
+  readonly maxSourceBytes: Schema.Int;
+  readonly maxProposalBytes: Schema.Int;
+  readonly timeoutMillis: Schema.Int;
+}>, {}>;
+declare class Limits extends Limits_base {}
+declare const SourceSnapshot_base: Schema.Class<SourceSnapshot, Schema.Struct<{
+  readonly source: Schema.Struct<{
+    readonly key: {
+      new (props: {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, options?: Schema.MakeOptions | undefined): {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      };
+      pipe<A>(this: A): A;
+      pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+      pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+      pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+      pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+      pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+      pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+      readonly Rebuild: Schema.decodeTo<Schema.declareConstructor<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, {
+        readonly namespace: {
+          readonly address: string;
+        };
+        readonly id: string;
+      }, readonly [Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>], {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>, Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>, never, never>;
+      readonly "~effect/Schema/Schema": "~effect/Schema/Schema";
+      readonly ast: import("effect/SchemaAST").Declaration;
+      readonly "~type.parameters": readonly [Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>];
+      readonly "~type.constructor.default": "no-default";
+      readonly "~type.mutability": "readonly";
+      readonly "~type.optionality": "required";
+      readonly "~encoded.mutability": "readonly";
+      readonly "~encoded.optionality": "required";
+      annotate(annotations: Schema.Annotations.Bottom<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, readonly [Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>]>): Schema.decodeTo<Schema.declareConstructor<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, {
+        readonly namespace: {
+          readonly address: string;
+        };
+        readonly id: string;
+      }, readonly [Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>], {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>, Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>, never, never>;
+      annotateKey(annotations: Schema.Annotations.Key<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>): Schema.decodeTo<Schema.declareConstructor<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, {
+        readonly namespace: {
+          readonly address: string;
+        };
+        readonly id: string;
+      }, readonly [Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>], {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>, Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>, never, never>;
+      check(checks_0: import("effect/SchemaAST").Check<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>, ...checks: import("effect/SchemaAST").Check<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>[]): Schema.decodeTo<Schema.declareConstructor<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, {
+        readonly namespace: {
+          readonly address: string;
+        };
+        readonly id: string;
+      }, readonly [Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>], {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>, Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>, never, never>;
+      rebuild(ast: import("effect/SchemaAST").Declaration): Schema.decodeTo<Schema.declareConstructor<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, {
+        readonly namespace: {
+          readonly address: string;
+        };
+        readonly id: string;
+      }, readonly [Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>], {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>, Schema.Struct<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }>, never, never>;
+      make(input: {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, options?: Schema.MakeOptions): {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      };
+      makeOption(input: {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, options?: Schema.MakeOptions): import("effect/Option").Option<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }>;
+      makeEffect(input: {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, options?: Schema.MakeOptions): Effect.Effect<{
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      }, import("effect/SchemaIssue").Issue, never>;
+      readonly Type: {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      };
+      readonly Encoded: {
+        readonly namespace: {
+          readonly address: string;
+        };
+        readonly id: string;
+      };
+      readonly DecodingServices: never;
+      readonly EncodingServices: never;
+      readonly "~type.make.in": {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      };
+      readonly "~type.make": {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      };
+      readonly Iso: {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      };
+      readonly identifier: string;
+      readonly fields: {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      };
+      mapFields<To extends Schema.Struct.Fields>(f: (fields: {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }) => To, options?: {
+        readonly unsafePreserveChecks?: boolean | undefined;
+      } | undefined): Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
+      extend<Extended = never, Static = {}, Brand = {}>(identifier: string): {
+        <NewFields extends Schema.Struct.Fields>(fields: NewFields, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        } & NewFields : Omit<{
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        } & NewFields : Omit<{
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+          readonly namespace: {
+            readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+          };
+          readonly id: string;
+        } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof NewFields_1 extends never ? S["fields"] & NewFields_1 : Omit<S["fields"], keyof S["fields"] & keyof NewFields_1> & NewFields_1) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+        <Extension extends Schema.Struct<Schema.Struct.Fields>>(schema: Extension, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        } & Extension["fields"] : Omit<{
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        } & Extension["fields"] : Omit<{
+          readonly namespace: Schema.Struct<{
+            readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+          }>;
+          readonly id: Schema.NonEmptyString;
+        }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+          readonly namespace: {
+            readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+          };
+          readonly id: string;
+        } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof Extension_1["fields"] extends never ? S["fields"] & Extension_1["fields"] : Omit<S["fields"], keyof S["fields"] & keyof Extension_1["fields"]> & Extension_1["fields"]) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+      };
+    };
+    readonly locator: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+    readonly position: Schema.Struct<{
+      readonly authorityGeneration: Schema.NonEmptyString;
+      readonly sequence: Schema.Int;
+    }>;
+  }>;
+  readonly text: Schema.String;
+}>, {}>;
+declare class SourceSnapshot extends SourceSnapshot_base {}
+/** Application-authorized output. The coordinator binds key, operation ID and expected revision.
+ * Fact acceptance, sharing scopes, profile schema and source-aware merging remain application code.
+ */
+declare const Decision: Schema.Union<readonly [Schema.TaggedStruct<"Put", {
+  readonly locator: Schema.NonEmptyString;
+  readonly content: typeof MemoryContent;
+  readonly scopes: Schema.$Array<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/MemoryScope">>;
+}>, Schema.TaggedStruct<"Withdraw", {
+  readonly reason: Schema.String;
+}>, Schema.TaggedStruct<"NoChange", {}>, Schema.TaggedStruct<"Reject", {}>]>;
+type Decision = typeof Decision.Type;
+interface MergeInput<Value, S extends Any, T extends Any> {
+  readonly intent: Intent<S, T>;
+  readonly proposal: Extracted<Value>;
+  readonly current: MemoryDocument<T> | null;
+}
+interface CleanupInput<Value, S extends Any, T extends Any> extends MergeInput<Value, S, T> {
+  readonly suppression: Invalidation;
+  readonly applied: MemoryDocument<T>;
+}
+/** Foreground admission performs only one durable port call. Bind authority and idempotency
+ * from the trusted invocation before calling; a queued receipt is returned only after commit.
+ */
+declare const admit: <E, R>(store: Store<E, R>, intent: Intent<{
+  readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+}, {
+  readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+}>) => Effect.Effect<Admission, E | AdmissionError | MutationFailure, R | MutationFailpoint>;
+/** Source owners await this durable suppression receipt before acknowledging edit/deletion/Forget.
+ * Scheduling all affected retained references and conditional cleanup is the host's obligation.
+ */
+declare const invalidate: <E, R>(store: Store<E, R>, event: Invalidation) => Effect.Effect<InvalidationReceipt, E | AdmissionError | MutationFailure, R | MutationFailpoint>;
+/** Define one application learner. Extraction may call native Effect AI LanguageModel directly;
+ * callback/model/schema requirements and errors remain in the returned Effect. No model owns
+ * authority, source loading, fact acceptance, profile representation or sharing policy.
+ * These are Effect-composition callbacks: they can yield application Context services, and advance
+ * retains every callback's E/R. The framework neither acquires nor provides application policy.
+ *
+ * advance is finite: it extracts, prepares, dispatches, or rebases at most once. The host calls it
+ * again when ready. A proposal is persisted before any target read; a complete command is saved
+ * before dispatch. Unknown outcomes leave that command untouched. Only MemoryConflict rebases.
+ * Cleanup receives the immutable proposal, original applied document and latest target so it can
+ * remove that contribution without overwriting intervening human corrections.
+ *
+ * loadSource returns an explicit Invalidation when source authority changed or was revoked; its
+ * suppression is committed before processing returns. null means absent on an initial load. A
+ * later null or a changed snapshot without an authority event fails source-changed and retains
+ * the obligation. Sources must keep revision content immutable. Evidence is checked again before
+ * preparing a new command. A saved Prepared command may already have executed, so it never calls
+ * loadSource and must reconcile even during a source outage. Source owners durably invalidate
+ * before acknowledging edits, and authoritative recall filters suppression while cleanup runs.
+ * No source text, proposal, authority identity, or extracted values are added to tracing spans.
+ */
+declare const make: <S extends Any, T extends Any, Value, Encoded extends Schema.Json, DecodeR, EncodeR, SourceE, SourceR, ExtractE, ExtractR, MergeE, MergeR, CleanupE, CleanupR>(options: {
+  readonly proposal: Schema.Codec<Value, Encoded, DecodeR, EncodeR>;
+  readonly loadSource: (intent: Intent<S, T>) => Effect.Effect<SourceSnapshot | Invalidation | null, SourceE, SourceR>;
+  readonly extract: (source: SourceSnapshot, intent: Intent<S, T>) => Effect.Effect<Extracted<Value> | null, ExtractE, ExtractR>;
+  readonly merge: (input: MergeInput<Value, S, T>) => Effect.Effect<Decision, MergeE, MergeR>;
+  readonly cleanup: (input: CleanupInput<Value, S, T>) => Effect.Effect<Decision, CleanupE, CleanupR>;
+}) => {
+  advance: <StoreE, StoreR>(input: {
+    readonly intent: Intent<S, T>;
+    readonly store: Store<StoreE, StoreR>;
+    readonly limits: Limits;
+    /** Stops new extraction only. Saved commands, rebase and suppression cleanup still run. */
+    readonly extractionEnabled: boolean;
+  }) => Effect.Effect<BoundCheckpoint<S, T>, CleanupE | ExtractE | MergeE | SourceE | StoreE | AdmissionError | CheckpointError | MemoryMutationFailure | MemoryOperationConflict | MemoryStorageError | MutationFailure | ProcessingError | Schema.SchemaError, CleanupR | DecodeR | EncodeR | ExtractR | MergeR | SourceR | StoreR | MemoryReader | MemoryWriter | MutationFailpoint>;
+};
+//#endregion
+export { CleanupInput, Decision, Limits, MergeInput, SourceSnapshot, admit, invalidate, make, Remembering_d_exports as t };
+//# sourceMappingURL=Remembering.d.mts.map