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

package/dist/core/RememberingStore.d.mts

@@ -0,0 +1,1562 @@
+import { t as Any } from "../MemoryNamespace-BbRW5p71.mjs";
+import { MemoryDocument, MemoryKey, MemoryWrite } from "./MemoryStore.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace RememberingStore_d_exports {
+  export { Admission, AdmissionError, BoundCheckpoint, BoundInvalidation, Checkpoint, CheckpointError, Evidence, Extracted, Intent, Invalidation, InvalidationReceipt, MutationFailpoint, MutationFailure, MutationPoint, ProcessingError, Progress, Proposal, Source, SourcePosition, Store, comparePosition };
+}
+declare const Counter: Schema.Int;
+/** Host source-order lineage. Sequence is monotonic only within one authorityGeneration.
+ * Opaque revision strings and different authority generations are never ordered.
+ */
+declare const SourcePosition: Schema.Struct<{
+  readonly authorityGeneration: Schema.NonEmptyString;
+  readonly sequence: Schema.Int;
+}>;
+type SourcePosition = typeof SourcePosition.Type;
+declare const comparePosition: (left: SourcePosition, right: SourcePosition) => number | undefined;
+declare const 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;
+  }>;
+}>;
+type Source = typeof Source.Type;
+declare const IntentWire_base: Schema.Class<IntentWire, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  /** Stable host-selected idempotency identity, including processor/schema version. It must be
+   * unique across all source-owner Stores writing this target for the receipt retention window.
+   */
+  readonly id: Schema.NonEmptyString;
+  /** Trusted invocation identity, never taken from extracted/model values. */
+  readonly invocationId: Schema.NonEmptyString;
+  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 target: {
+    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>>>;
+    };
+  };
+}>, {}>;
+declare class IntentWire extends IntentWire_base {}
+type Intent<S extends Any = Any, T extends Any = Any> = Omit<IntentWire, "source" | "target"> & {
+  readonly source: Omit<Source, "key"> & {
+    readonly key: MemoryKey<S>;
+  };
+  readonly target: MemoryKey<T>;
+};
+declare const Intent: {
+  Wire: typeof IntentWire;
+  make: <S extends Any, T extends Any>(fields: Intent<S, T>) => Intent<S, T>;
+};
+/** Half-open UTF-8 byte range in the exact authoritative source revision. A quote proves
+ * provenance only. Applications decide whether it supports a fact and may be shared.
+ */
+declare const Evidence: Schema.Struct<{
+  readonly source: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly locator: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>;
+  readonly startByte: Schema.Int;
+  readonly endByte: Schema.Int;
+  readonly quote: Schema.NonEmptyString;
+}>;
+type Evidence = typeof Evidence.Type;
+declare const Proposal: Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly evidence: Schema.$Array<Schema.Struct<{
+    readonly source: Schema.Struct<{
+      readonly id: Schema.NonEmptyString;
+      readonly locator: Schema.NonEmptyString;
+      readonly revision: Schema.NonEmptyString;
+    }>;
+    readonly startByte: Schema.Int;
+    readonly endByte: Schema.Int;
+    readonly quote: Schema.NonEmptyString;
+  }>>;
+}>;
+type Proposal = typeof Proposal.Type;
+interface Extracted<Value> {
+  readonly value: Value;
+  readonly evidence: ReadonlyArray<Evidence>;
+}
+declare const Invalidation_base: Schema.Class<Invalidation, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.NonEmptyString;
+  readonly source: {
+    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 position: Schema.Struct<{
+    readonly authorityGeneration: Schema.NonEmptyString;
+    readonly sequence: Schema.Int;
+  }>;
+  readonly reason: Schema.Literals<readonly ["source-edit", "source-deletion", "source-revocation", "forget"]>;
+}>, {}>;
+declare class Invalidation extends Invalidation_base {}
+type BoundInvalidation<S extends Any> = Omit<Invalidation, "source"> & {
+  readonly source: MemoryKey<S>;
+};
+declare const PreparedFields: {
+  readonly proposal: typeof Proposal;
+  readonly attempt: typeof Counter;
+  readonly purpose: Schema.Literals<readonly ["remember", "cleanup"]>;
+  readonly applied: Schema.NullOr<typeof MemoryDocument.Wire>;
+};
+declare const CompletedFields: {
+  readonly proposal: Schema.NullOr<typeof Proposal>;
+  readonly attempt: typeof Counter;
+  readonly applied: Schema.NullOr<typeof MemoryDocument.Wire>;
+  readonly outcome: Schema.Literals<readonly ["applied", "no-change", "rejected", "suppressed"]>;
+  readonly cleaned: typeof Schema.Boolean;
+};
+interface ProgressSchema extends Schema.Union<readonly [Schema.TaggedStruct<"Pending", {}>, Schema.TaggedStruct<"Proposed", typeof PreparedFields>, Schema.TaggedStruct<"Prepared", typeof PreparedFields & {
+  readonly command: typeof MemoryWrite.Wire;
+}>, Schema.TaggedStruct<"Completed", typeof CompletedFields>]> {}
+declare const Progress: ProgressSchema;
+type Progress<T extends Any = Any> = (typeof Progress.members)[0]["Type"] | (Omit<(typeof Progress.members)[1]["Type"], "applied"> & {
+  readonly applied: MemoryDocument<T> | null;
+}) | (Omit<(typeof Progress.members)[2]["Type"], "applied" | "command"> & {
+  readonly applied: MemoryDocument<T> | null;
+  readonly command: MemoryWrite<T>;
+}) | (Omit<(typeof Progress.members)[3]["Type"], "applied"> & {
+  readonly applied: MemoryDocument<T> | null;
+});
+declare const Checkpoint_base: Schema.Class<Checkpoint, Schema.Struct<{
+  readonly version: Schema.Int;
+  readonly intent: typeof IntentWire;
+  readonly suppression: Schema.NullOr<typeof Invalidation>;
+  readonly progress: ProgressSchema;
+}>, {}>;
+/** Retain this source-target reference after removing a job from the active queue. It contains
+ * the immutable proposal and original application receipt needed by later invalidation.
+ * Prepared commands must never be pruned or replaced while their outcome is uncertain.
+ */
+declare class Checkpoint extends Checkpoint_base {}
+/** A checked checkpoint bound to the caller's original namespace definitions. */
+type BoundCheckpoint<S extends Any, T extends Any> = Omit<Checkpoint, "intent" | "progress" | "suppression"> & {
+  readonly intent: Intent<S, T>;
+  readonly progress: Progress<T>;
+  readonly suppression: BoundInvalidation<S> | null;
+};
+declare const Admission_base: Schema.Class<Admission, Schema.Struct<{
+  readonly id: Schema.NonEmptyString;
+  readonly status: Schema.Literals<readonly ["queued", "duplicate"]>;
+}>, {}>;
+declare class Admission extends Admission_base {}
+declare const InvalidationReceipt_base: Schema.Class<InvalidationReceipt, Schema.Struct<{
+  readonly id: Schema.NonEmptyString;
+  readonly status: Schema.Literals<readonly ["accepted", "duplicate", "stale"]>;
+  readonly affected: Schema.Int;
+}>, {}>;
+declare class InvalidationReceipt extends InvalidationReceipt_base {}
+declare const AdmissionError_base: Schema.Class<AdmissionError, Schema.TaggedStruct<"RememberingAdmissionError", {
+  readonly reason: Schema.Literals<readonly ["invalid-input", "conflict", "capacity", "suppressed", "disabled"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class AdmissionError extends AdmissionError_base {}
+declare const CheckpointError_base: Schema.Class<CheckpointError, Schema.TaggedStruct<"RememberingCheckpointError", {
+  readonly reason: Schema.Literals<readonly ["fenced", "missing", "corrupt"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class CheckpointError extends CheckpointError_base {}
+declare const ProcessingError_base: Schema.Class<ProcessingError, Schema.TaggedStruct<"RememberingProcessingError", {
+  readonly reason: Schema.Literals<readonly ["invalid-input", "invalid-evidence", "source-changed", "budget", "timeout", "disabled", "cleanup-rejected"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProcessingError extends ProcessingError_base {}
+declare const MutationPoint: Schema.Literals<readonly ["admission:before", "admission:after", "proposal:before", "proposal:after", "command:before", "command:after", "rebase:before", "rebase:after", "completion:before", "completion:after", "suppression:before", "suppression:after", "cleanup:before", "cleanup:after"]>;
+type MutationPoint = typeof MutationPoint.Type;
+declare const MutationFailure_base: Schema.Class<MutationFailure, Schema.TaggedStruct<"RememberingMutationFailure", {
+  readonly point: Schema.Literals<readonly ["admission:before", "admission:after", "proposal:before", "proposal:after", "command:before", "command:after", "rebase:before", "rebase:after", "completion:before", "completion:after", "suppression:before", "suppression:after", "cleanup:before", "cleanup:after"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class MutationFailure extends MutationFailure_base {}
+declare const MutationFailpoint_base: Context.ServiceClass<MutationFailpoint, "@effect-agent/remembering/MutationFailpoint", {
+  readonly hit: (point: MutationPoint) => Effect.Effect<void, MutationFailure>;
+}>;
+/** Explicit transition failpoints. No-op unless a test installs a replacement. */
+declare class MutationFailpoint extends MutationFailpoint_base {
+  static readonly layer: Layer.Layer<MutationFailpoint, never, never>;
+}
+/** Host-owned durable admission/checkpoint port. It is not a scheduler or profile store.
+ * The explicit port binds an existing host job transaction; its Effects retain their E and R.
+ * Hosts may acquire it from their own Context service. The protocol never provides its requirements.
+ *
+ * admit atomically binds the complete intent, receipt, source authority, and ready obligation.
+ * Identical retries return duplicate; reusing an id with different intent fails conflict.
+ * read/save validate the complete intent. save atomically checks expectedVersion and advances
+ * its fence; invalidation advances the same fence. A failed CAS must never dispatch new work.
+ *
+ * invalidate durably records suppression before source acknowledgement and marks every retained
+ * source-target reference ready for reconciliation/cleanup. It MUST preserve Prepared commands.
+ * Older positions cannot undo newer authority; forget is terminal for that source identity.
+ * Bind the active authorityGeneration before admission. Unknown or mismatched lineages fail
+ * closed; an explicit host restore cutover installs a new lineage and fences all old workers.
+ * Source edits suppress contributions from earlier positions; deletion/forget include their own
+ * position. A duplicate invalidation cannot lose pending cleanup. New admissions against an old
+ * authority, withdrawn source, or terminal forget fail suppressed.
+ *
+ * Bound active jobs, proposals, references and receipts. Capacity failure rejects new admission;
+ * it never evicts an unresolved command, suppression, or cleanup obligation. Retain references,
+ * receipts and suppression for the entire supported delivery/replay/restore window. Expired or
+ * incompatible restores fail closed. The host owns alarms, outboxes, ordering, retries, leases,
+ * source authorization and whether extraction is enabled. Cleanup remains runnable when it is off.
+ */
+interface Store<E = never, R = never> {
+  readonly admit: (intent: Intent) => Effect.Effect<Admission, E | AdmissionError, R>;
+  readonly read: (intent: Intent) => Effect.Effect<Checkpoint, E | CheckpointError, R>;
+  readonly save: (input: {
+    readonly intent: Intent;
+    readonly expectedVersion: number;
+    readonly progress: Progress;
+  }) => Effect.Effect<Checkpoint, E | CheckpointError, R>;
+  readonly invalidate: (event: Invalidation) => Effect.Effect<InvalidationReceipt, E | AdmissionError, R>;
+}
+//#endregion
+export { Admission, AdmissionError, BoundCheckpoint, BoundInvalidation, Checkpoint, CheckpointError, Evidence, Extracted, Intent, Invalidation, InvalidationReceipt, MutationFailpoint, MutationFailure, MutationPoint, ProcessingError, Progress, Proposal, Source, SourcePosition, Store, comparePosition, RememberingStore_d_exports as t };
+//# sourceMappingURL=RememberingStore.d.mts.map