effect-agent 0.1.0-beta.12 → 0.1.0-beta.121

package/dist/capabilities/Redaction.d.mts

@@ -0,0 +1,37 @@
+import { l as RunEvent } from "../RunEvent-DIrzkjLr.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace Redaction_d_exports {
+  export { RedactedPreview, RedactionError, Redactor, StructuralRedactorLive, redactedTranscript };
+}
+/** Branded evidence that a preview passed through the configured structural Redactor. */
+export declare const RedactedPreview: Schema.brand<Schema.refine<string, Schema.String>, "@effect-agent/capabilities/RedactedPreview">;
+export type RedactedPreview = typeof RedactedPreview.Type;
+declare const RedactionError_base: Schema.Class<RedactionError, Schema.TaggedStruct<"RedactionError", {
+  readonly reason: Schema.Literals<readonly ["input-too-deep", "input-too-large", "encoding-failed"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Structural redaction failed closed rather than returning unreviewed caller text. */
+export declare class RedactionError extends RedactionError_base {}
+declare const Redactor_base: Context.ServiceClass<Redactor, "@effect-agent/capabilities/Redactor", {
+  readonly redact: (decodedValue: unknown) => Effect.Effect<RedactedPreview, RedactionError>;
+}>;
+/** Redaction owns the boundary from decoded Tool values to bounded audit/model previews. */
+export declare class Redactor extends Redactor_base {}
+/**
+ * One composed step from live Run Events to structurally redacted transcript lines
+ * (P7 WP7 friction fix; SEC-008/testing.md §12 "structurally redacted" live transcripts):
+ * Schema-encode each event through the canonical `RunEvent` union, then pass the encoded
+ * value through the configured `Redactor` — so the safe path is the short path and no live
+ * suite hand-assembles (or accidentally skips) the encode→redact pair. Engine-constructed
+ * events always encode, so an encode failure is a defect, never a silent omission.
+ */
+export declare const redactedTranscript: (events: Iterable<RunEvent>) => Effect.Effect<ReadonlyArray<RedactedPreview>, RedactionError, Redactor>;
+/**
+ * Default structural implementation. It exposes only collection shape and
+ * scalar types, so an ordinary field such as `note` cannot bypass redaction.
+ * Tool-specific Layers may expose explicitly reviewed fields instead.
+ */
+export declare const StructuralRedactorLive: Layer.Layer<Redactor, never, never>;
+//#endregion
+export { Redaction_d_exports as t };
+//# sourceMappingURL=Redaction.d.mts.map

package/dist/capabilities/Redaction.mjs

@@ -0,0 +1,104 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { RunEvent } from "../core/RunEvent.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/capabilities/Redaction.ts
+var Redaction_exports = /* @__PURE__ */ __exportAll({
+	RedactedPreview: () => RedactedPreview,
+	RedactionError: () => RedactionError,
+	Redactor: () => Redactor,
+	StructuralRedactorLive: () => StructuralRedactorLive,
+	redactedTranscript: () => redactedTranscript
+});
+const MAX_REDACTED_PREVIEW_BYTES = 8192;
+const MAX_REDACTION_NODES = 4096;
+const MAX_REDACTION_DEPTH = 16;
+/** Branded evidence that a preview passed through the configured structural Redactor. */
+const RedactedPreview = Schema.String.pipe(Schema.refine((value) => utf8ByteLength(value) <= MAX_REDACTED_PREVIEW_BYTES, { expected: `redacted preview of at most ${MAX_REDACTED_PREVIEW_BYTES} UTF-8 bytes` }), Schema.brand("@effect-agent/capabilities/RedactedPreview"));
+/** Structural redaction failed closed rather than returning unreviewed caller text. */
+var RedactionError = class extends Schema.TaggedError()("RedactionError", {
+	reason: Schema.Literals([
+		"input-too-deep",
+		"input-too-large",
+		"encoding-failed"
+	]),
+	message: Schema.String
+}) {};
+/** Redaction owns the boundary from decoded Tool values to bounded audit/model previews. */
+var Redactor = class extends Context.Service()("@effect-agent/capabilities/Redactor") {};
+const redactValue = (value, depth, counter) => {
+	if (depth > MAX_REDACTION_DEPTH) throw RedactionError.make({
+		reason: "input-too-deep",
+		message: `Decoded value exceeds redaction depth ${MAX_REDACTION_DEPTH}`
+	});
+	counter.nodes += 1;
+	if (counter.nodes > MAX_REDACTION_NODES) throw RedactionError.make({
+		reason: "input-too-large",
+		message: `Decoded value exceeds redaction node count ${MAX_REDACTION_NODES}`
+	});
+	if (Array.isArray(value)) return value.map((item) => redactValue(item, depth + 1, counter));
+	if (value !== null && typeof value === "object") {
+		const redacted = {};
+		for (const [key, item] of Object.entries(value)) redacted[key] = redactValue(item, depth + 1, counter);
+		return redacted;
+	}
+	if (value === null) return "[REDACTED:null]";
+	if (typeof value === "string") return "[REDACTED:string]";
+	if (typeof value === "number") return "[REDACTED:number]";
+	if (typeof value === "boolean") return "[REDACTED:boolean]";
+	return "[REDACTED:unsupported]";
+};
+const truncateUtf8 = (value, maxBytes) => {
+	if (utf8ByteLength(value) <= maxBytes) return value;
+	const suffix = "…";
+	const suffixBytes = utf8ByteLength(suffix);
+	let output = "";
+	let bytes = 0;
+	for (const character of value) {
+		const characterBytes = utf8ByteLength(character);
+		if (bytes + characterBytes + suffixBytes > maxBytes) break;
+		output += character;
+		bytes += characterBytes;
+	}
+	return `${output}${suffix}`;
+};
+const encodeRunEvent = Schema.encodeEffect(RunEvent);
+/**
+* One composed step from live Run Events to structurally redacted transcript lines
+* (P7 WP7 friction fix; SEC-008/testing.md §12 "structurally redacted" live transcripts):
+* Schema-encode each event through the canonical `RunEvent` union, then pass the encoded
+* value through the configured `Redactor` — so the safe path is the short path and no live
+* suite hand-assembles (or accidentally skips) the encode→redact pair. Engine-constructed
+* events always encode, so an encode failure is a defect, never a silent omission.
+*/
+const redactedTranscript = (events) => Effect.gen(function* () {
+	const redactor = yield* Redactor;
+	const lines = [];
+	for (const event of events) {
+		const encoded = yield* encodeRunEvent(event).pipe(Effect.orDie);
+		lines.push(yield* redactor.redact(encoded));
+	}
+	return lines;
+});
+/**
+* Default structural implementation. It exposes only collection shape and
+* scalar types, so an ordinary field such as `note` cannot bypass redaction.
+* Tool-specific Layers may expose explicitly reviewed fields instead.
+*/
+const StructuralRedactorLive = Layer.succeed(Redactor)({ redact: (decodedValue) => Effect.try({
+	try: () => {
+		const structurallyRedacted = redactValue(decodedValue, 0, { nodes: 0 });
+		return truncateUtf8(JSON.stringify(structurallyRedacted), MAX_REDACTED_PREVIEW_BYTES);
+	},
+	catch: (cause) => Schema.is(RedactionError)(cause) ? cause : RedactionError.make({
+		reason: "encoding-failed",
+		message: "Could not encode the structurally redacted preview"
+	})
+}).pipe(Effect.flatMap((preview) => Schema.decodeEffect(RedactedPreview)(preview).pipe(Effect.mapError(() => RedactionError.make({
+	reason: "encoding-failed",
+	message: "Redacted preview did not satisfy its bounded schema"
+}))))) });
+//#endregion
+export { RedactedPreview, RedactionError, Redactor, StructuralRedactorLive, redactedTranscript, Redaction_exports as t };
+
+//# sourceMappingURL=Redaction.mjs.map

package/dist/capabilities/Redaction.mjs.map

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

package/dist/capabilities/Remembering.d.mts

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