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

package/dist/capabilities/SemanticMemory.mjs

@@ -0,0 +1,315 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { MemoryLookup } from "../core/MemoryReference.mjs";
+import { MemoryDocument, MemoryKey, MemoryReader, MemoryStorageError } from "../core/MemoryStore.mjs";
+import { MemoryAccess } from "../core/MemoryRevalidation.mjs";
+import { MemoryIndexError, MemoryIndexQuery, MemoryIndexSearch, MemoryIndexSource, SemanticMemoryChunk, SemanticMemoryIndex, SemanticMemoryProfile } from "../core/SemanticMemoryIndex.mjs";
+import { SemanticCandidateLimits, SemanticMemoryError, revalidateSemanticMemoryCandidates } from "../core/SemanticMemoryRevalidation.mjs";
+import { EmbeddingModel } from "effect/unstable/ai";
+import { Clock, Crypto, Effect, Encoding, Schema } from "effect";
+//#region src/capabilities/SemanticMemory.ts
+var SemanticMemory_exports = /* @__PURE__ */ __exportAll({
+	SemanticIndexLimits: () => SemanticIndexLimits,
+	SemanticIndexResult: () => SemanticIndexResult,
+	SemanticQueryLimits: () => SemanticQueryLimits,
+	SemanticQueryResult: () => SemanticQueryResult,
+	indexMemorySource: () => indexMemorySource,
+	querySemanticMemory: () => querySemanticMemory
+});
+const Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
+const InputTokens = Schema.NullOr(Schema.Natural);
+var SemanticIndexLimits = class extends Schema.Class("@effect-agent/capabilities/SemanticIndexLimits")({
+	maxSourceBytes: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 4194304
+	})),
+	maxChunks: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 256
+	})),
+	timeoutMillis: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 3e5
+	}))
+}) {};
+var SemanticQueryLimits = class extends Schema.Class("@effect-agent/capabilities/SemanticQueryLimits")({
+	maxQueryBytes: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 65536
+	})),
+	maxCandidates: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 128
+	})),
+	maxScannedChunks: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 65536
+	})),
+	/** Aggregate UTF-8 JSON of current authorized candidate sources; defaults to 16 MiB. */
+	maxSourceBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 67108864
+	}))),
+	/** Aggregate UTF-8 JSON passage bytes, including repeated provenance; defaults to 16 MiB. */
+	maxOutputBytes: SemanticCandidateLimits.fields.maxOutputBytes,
+	minScore: Schema.Finite.check(Schema.isBetween({
+		minimum: -1,
+		maximum: 1
+	})),
+	timeoutMillis: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 6e4
+	}))
+}) {};
+var SemanticIndexResultWire = class extends Schema.Class("@effect-agent/capabilities/SemanticIndexResult")({
+	key: MemoryKey.Wire,
+	status: Schema.Literals([
+		"Missing",
+		"Withdrawn",
+		"Indexed"
+	]),
+	embeddedChunks: Schema.Natural,
+	embeddedBytes: Schema.Natural,
+	inputTokens: InputTokens,
+	startedAt: Timestamp,
+	finishedAt: Timestamp
+}) {};
+const SemanticIndexResult = {
+	Wire: SemanticIndexResultWire,
+	make: (fields) => Object.assign(Schema.decodeUnknownSync(SemanticIndexResultWire)(fields), { key: MemoryKey.make(fields.key) })
+};
+/** Candidates have already passed current-source checks; compose lookup with Memory.recall. */
+var SemanticQueryResult = class extends Schema.Class("@effect-agent/capabilities/SemanticQueryResult")({
+	lookup: MemoryLookup,
+	scannedChunks: Schema.Natural,
+	staleExcluded: Schema.Natural,
+	unauthorizedExcluded: Schema.Natural,
+	queryBytes: Schema.Natural,
+	inputTokens: InputTokens,
+	startedAt: Timestamp,
+	finishedAt: Timestamp
+}) {};
+const utf8 = (text) => {
+	const hex = Encoding.encodeHex(text);
+	return Uint8Array.from({ length: hex.length / 2 }, (_, index) => Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16));
+};
+const invalid = (operation) => SemanticMemoryError.make({
+	operation,
+	reason: "invalid-input"
+});
+const asSource = (document) => MemoryIndexSource.make({
+	key: document.key,
+	source: document.source,
+	sourceGeneration: document.generation
+});
+const sameSource = (left, right) => left.key.namespace.address === right.key.namespace.address && left.key.id === right.key.id && left.generation === right.generation && left.source.revision === right.source.revision && left.source.locator === right.source.locator && left._tag === right._tag;
+const readDocument = Effect.fn("semanticMemory.readDocument")(function* (key) {
+	const document = yield* (yield* MemoryReader).get(key).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.NullOr(MemoryDocument.Wire))), Effect.catchTag("SchemaError", () => Effect.fail(MemoryStorageError.make({
+		operation: "validate semantic source",
+		reason: "corrupt"
+	}))));
+	if (document !== null && (document.key.namespace.address !== key.namespace.address || document.key.id !== key.id || document.source.id !== key.id)) return yield* MemoryStorageError.make({
+		operation: "validate semantic source identity",
+		reason: "corrupt"
+	});
+	return document;
+});
+const embeddings = Effect.fn("semanticMemory.embeddings")(function* (inputs, profile) {
+	const response = yield* (yield* EmbeddingModel.EmbeddingModel).embedMany(inputs).pipe(Effect.flatMap(Schema.decodeUnknownEffect(EmbeddingModel.EmbedManyResponse)), Effect.catchTag("SchemaError", () => Effect.fail(SemanticMemoryError.make({
+		operation: "decode embeddings",
+		reason: "invalid-embedding"
+	}))));
+	const tokens = response.usage.inputTokens;
+	if (response.embeddings.length !== inputs.length || tokens !== void 0 && (!Number.isSafeInteger(tokens) || tokens < 0) || response.embeddings.some(({ vector }) => {
+		const norm = vector.reduce((sum, value) => sum + value * value, 0);
+		return vector.length !== profile.dimensions || norm <= 0 || !Number.isFinite(norm);
+	})) return yield* SemanticMemoryError.make({
+		operation: "validate embeddings",
+		reason: "invalid-embedding"
+	});
+	return response;
+});
+const chunkText = Effect.fn("semanticMemory.chunkText")(function* (text, profile, limits) {
+	if (utf8ByteLength(text) > limits.maxSourceBytes) return yield* SemanticMemoryError.make({
+		operation: "chunk source",
+		reason: "budget"
+	});
+	const chunks = [];
+	let current = "";
+	let startByte = 0;
+	let currentBytes = 0;
+	for (const codepoint of text) {
+		const size = utf8ByteLength(codepoint);
+		if (currentBytes + size > profile.maxChunkBytes) {
+			chunks.push({
+				ordinal: chunks.length,
+				startByte,
+				endByte: startByte + currentBytes,
+				text: current
+			});
+			startByte += currentBytes;
+			current = "";
+			currentBytes = 0;
+			if (chunks.length >= limits.maxChunks) return yield* SemanticMemoryError.make({
+				operation: "chunk source",
+				reason: "budget"
+			});
+		}
+		current += codepoint;
+		currentBytes += size;
+	}
+	if (current.length > 0) chunks.push({
+		ordinal: chunks.length,
+		startByte,
+		endByte: startByte + currentBytes,
+		text: current
+	});
+	if (chunks.length === 0) return yield* invalid("chunk empty source");
+	return chunks;
+});
+/**
+* Rebuild one selected source through the native Effect EmbeddingModel. The host binds the
+* index profile to that provider's immutable model revision. A fresh Layer starts empty.
+* Every invocation rebuilds; the host owns source discovery, scheduling, and freshness policy.
+*
+* Chunking and embedding leave the last successful index intact. A final authoritative read
+* rejects a source changed during embedding, then replace atomically exchanges its chunks.
+* An independent source can still change between that read and replacement;
+* querySemanticMemory always revalidates and excludes such stale candidates.
+* No model or source text is attached to telemetry. Errors retain native provider/index types.
+*/
+const indexMemorySource = Effect.fn("indexMemorySource")(function* (key, limits) {
+	yield* Schema.decodeUnknownEffect(MemoryKey.Wire)(key).pipe(Effect.mapError(() => invalid("index key")));
+	const checkedKey = MemoryKey.make(key);
+	const checkedLimits = yield* Schema.decodeEffect(SemanticIndexLimits)(limits).pipe(Effect.mapError(() => invalid("index limits")));
+	return yield* Effect.gen(function* () {
+		const startedAt = yield* Clock.currentTimeMillis;
+		const index = yield* SemanticMemoryIndex;
+		const profile = yield* Schema.decodeEffect(SemanticMemoryProfile)(index.profile).pipe(Effect.mapError(() => invalid("index profile")));
+		const document = yield* readDocument(checkedKey);
+		if (document === null || document._tag === "WithdrawnMemoryDocument") {
+			if (document !== null) yield* index.withdraw(asSource(document));
+			return SemanticIndexResult.make({
+				key: checkedKey,
+				status: document === null ? "Missing" : "Withdrawn",
+				embeddedChunks: 0,
+				embeddedBytes: 0,
+				inputTokens: null,
+				startedAt,
+				finishedAt: yield* Clock.currentTimeMillis
+			});
+		}
+		const texts = yield* chunkText(document.content.text, profile, checkedLimits);
+		const encodedProfile = yield* Schema.encodeEffect(Schema.fromJsonString(SemanticMemoryProfile))(profile).pipe(Effect.mapError(() => invalid("encode profile")));
+		const fingerprint = yield* (yield* Crypto.Crypto).digest("SHA-256", utf8(encodedProfile)).pipe(Effect.map(Encoding.encodeHex), Effect.mapError(() => SemanticMemoryError.make({
+			operation: "fingerprint profile",
+			reason: "unavailable"
+		})));
+		const response = yield* embeddings(texts.map((chunk) => chunk.text), profile);
+		const chunks = [];
+		for (const text of texts) {
+			const vector = response.embeddings[text.ordinal]?.vector;
+			if (vector === void 0) return yield* SemanticMemoryError.make({
+				operation: "embedding count",
+				reason: "invalid-embedding"
+			});
+			chunks.push(SemanticMemoryChunk.make({
+				...text,
+				passageId: `chunk:${fingerprint}:${text.ordinal}`,
+				vector: [...vector]
+			}));
+		}
+		const latest = yield* readDocument(checkedKey);
+		if (latest === null || !sameSource(document, latest)) {
+			if (latest?._tag === "WithdrawnMemoryDocument") yield* index.withdraw(asSource(latest));
+			return yield* SemanticMemoryError.make({
+				operation: "publish current source",
+				reason: "source-changed"
+			});
+		}
+		yield* index.replace({
+			source: asSource(document),
+			profile,
+			chunks
+		});
+		return SemanticIndexResult.make({
+			key: checkedKey,
+			status: "Indexed",
+			embeddedChunks: chunks.length,
+			embeddedBytes: utf8ByteLength(document.content.text),
+			inputTokens: response.usage.inputTokens ?? null,
+			startedAt,
+			finishedAt: yield* Clock.currentTimeMillis
+		});
+	}).pipe(Effect.scoped, Effect.timeoutOrElse({
+		duration: checkedLimits.timeoutMillis,
+		orElse: () => Effect.fail(SemanticMemoryError.make({
+			operation: "index source",
+			reason: "timeout"
+		}))
+	}));
+});
+/**
+* Query an optional derivative index, then read each distinct source once. Attribution and
+* metadata always come from that current source. Revision, generation, namespace, access,
+* locator, and exact UTF-8 excerpt checks run before returning any passage. Older candidates
+* are omitted rather than assigning their similarity score to changed text.
+* Process candidates in source groups, retain only passage excerpts, and restore index rank.
+* maxSourceBytes bounds aggregate UTF-8 JSON for distinct authorized sources with matching
+* generation/revision/locator candidates. Its default is 16 MiB; exhaustion returns no partial
+* result. Reader allocation, decoding, and one source serialization precede this bound.
+*
+* Compose result.lookup through Memory.recall to enforce the final rendered item/byte/token
+* budget and overall deadline. An empty result says nothing about undiscovered sources.
+* Checks begun before an acknowledged correction/withdrawal may finish with their already
+* captured source view.
+*/
+const querySemanticMemory = Effect.fn("querySemanticMemory")(function* (query, access, limits) {
+	const checkedQuery = yield* Schema.decodeEffect(Schema.NonEmptyString)(query).pipe(Effect.mapError(() => invalid("query text")));
+	const checkedAccess = yield* Schema.decodeEffect(MemoryAccess.Wire)(access).pipe(Effect.mapError(() => invalid("query access")));
+	const checkedLimits = yield* Schema.decodeEffect(SemanticQueryLimits)(limits).pipe(Effect.mapError(() => invalid("query limits")));
+	const queryBytes = utf8ByteLength(checkedQuery);
+	if (queryBytes > checkedLimits.maxQueryBytes) return yield* SemanticMemoryError.make({
+		operation: "query bytes",
+		reason: "budget"
+	});
+	return yield* Effect.gen(function* () {
+		const startedAt = yield* Clock.currentTimeMillis;
+		const index = yield* SemanticMemoryIndex;
+		const profile = yield* Schema.decodeEffect(SemanticMemoryProfile)(index.profile).pipe(Effect.mapError(() => invalid("query profile")));
+		const response = yield* embeddings([checkedQuery], profile);
+		const vector = response.embeddings[0]?.vector;
+		if (vector === void 0) return yield* SemanticMemoryError.make({
+			operation: "query embedding count",
+			reason: "invalid-embedding"
+		});
+		const found = yield* index.search(MemoryIndexQuery.make({
+			namespace: checkedAccess.namespace,
+			vector,
+			limit: checkedLimits.maxCandidates,
+			minScore: checkedLimits.minScore,
+			maxScannedChunks: checkedLimits.maxScannedChunks
+		})).pipe(Effect.flatMap(Schema.decodeUnknownEffect(MemoryIndexSearch.Wire)), Effect.catchTag("SchemaError", () => Effect.fail(MemoryIndexError.make({
+			operation: "validate candidates",
+			reason: "corrupt"
+		}))));
+		const validated = yield* revalidateSemanticMemoryCandidates(found, checkedAccess, profile, checkedLimits);
+		return SemanticQueryResult.make({
+			...validated,
+			queryBytes,
+			inputTokens: response.usage.inputTokens ?? null,
+			startedAt,
+			finishedAt: yield* Clock.currentTimeMillis
+		});
+	}).pipe(Effect.scoped, Effect.timeoutOrElse({
+		duration: checkedLimits.timeoutMillis,
+		orElse: () => Effect.fail(SemanticMemoryError.make({
+			operation: "query memory",
+			reason: "timeout"
+		}))
+	}));
+});
+//#endregion
+export { SemanticIndexLimits, SemanticIndexResult, SemanticQueryLimits, SemanticQueryResult, indexMemorySource, querySemanticMemory, SemanticMemory_exports as t };
+
+//# sourceMappingURL=SemanticMemory.mjs.map

package/dist/capabilities/SemanticMemory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SemanticMemory.mjs","names":[],"sources":["../../src/capabilities/SemanticMemory.ts"],"sourcesContent":["import { Clock, Crypto, Effect, Encoding, Schema } from \"effect\";\nimport { EmbeddingModel } from \"effect/unstable/ai\";\n\nimport { utf8ByteLength } from \"../core/internal/utf8.ts\";\nimport type * as MemoryNamespace from \"../core/MemoryNamespace.ts\";\nimport { MemoryLookup } from \"../core/MemoryReference.ts\";\nimport { MemoryAccess } from \"../core/MemoryRevalidation.ts\";\nimport {\n  MemoryDocument,\n  MemoryKey,\n  MemoryReader,\n  MemoryStorageError,\n} from \"../core/MemoryStore.ts\";\nimport {\n  MemoryIndexError,\n  MemoryIndexQuery,\n  MemoryIndexSearch,\n  MemoryIndexSource,\n  SemanticMemoryChunk,\n  SemanticMemoryIndex,\n  SemanticMemoryProfile,\n} from \"../core/SemanticMemoryIndex.ts\";\nimport {\n  SemanticMemoryError,\n  SemanticCandidateLimits,\n  revalidateSemanticMemoryCandidates,\n} from \"../core/SemanticMemoryRevalidation.ts\";\n\nconst Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));\nconst InputTokens = Schema.NullOr(Schema.Natural);\n\nexport class SemanticIndexLimits extends Schema.Class<SemanticIndexLimits>(\n  \"@effect-agent/capabilities/SemanticIndexLimits\",\n)({\n  maxSourceBytes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 4_194_304 })),\n  maxChunks: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 256 })),\n  timeoutMillis: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 300_000 })),\n}) {}\n\nexport class SemanticQueryLimits extends Schema.Class<SemanticQueryLimits>(\n  \"@effect-agent/capabilities/SemanticQueryLimits\",\n)({\n  maxQueryBytes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65_536 })),\n  maxCandidates: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 128 })),\n  maxScannedChunks: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65_536 })),\n  /** Aggregate UTF-8 JSON of current authorized candidate sources; defaults to 16 MiB. */\n  maxSourceBytes: Schema.optionalKey(\n    Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 67_108_864 })),\n  ),\n  /** Aggregate UTF-8 JSON passage bytes, including repeated provenance; defaults to 16 MiB. */\n  maxOutputBytes: SemanticCandidateLimits.fields.maxOutputBytes,\n  minScore: Schema.Finite.check(Schema.isBetween({ minimum: -1, maximum: 1 })),\n  timeoutMillis: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 60_000 })),\n}) {}\n\nclass SemanticIndexResultWire extends Schema.Class<SemanticIndexResultWire>(\n  \"@effect-agent/capabilities/SemanticIndexResult\",\n)({\n  key: MemoryKey.Wire,\n  status: Schema.Literals([\"Missing\", \"Withdrawn\", \"Indexed\"]),\n  embeddedChunks: Schema.Natural,\n  embeddedBytes: Schema.Natural,\n  inputTokens: InputTokens,\n  startedAt: Timestamp,\n  finishedAt: Timestamp,\n}) {}\n\nexport type SemanticIndexResult<Namespace extends MemoryNamespace.Any = MemoryNamespace.Any> = Omit<\n  SemanticIndexResultWire,\n  \"key\"\n> & { readonly key: MemoryKey<Namespace> };\n\nexport const SemanticIndexResult = {\n  Wire: SemanticIndexResultWire,\n  make: <Namespace extends MemoryNamespace.Any>(\n    fields: SemanticIndexResult<Namespace>,\n  ): SemanticIndexResult<Namespace> =>\n    Object.assign(Schema.decodeUnknownSync(SemanticIndexResultWire)(fields), {\n      key: MemoryKey.make(fields.key),\n    }),\n};\n\n/** Candidates have already passed current-source checks; compose lookup with Memory.recall. */\nexport class SemanticQueryResult extends Schema.Class<SemanticQueryResult>(\n  \"@effect-agent/capabilities/SemanticQueryResult\",\n)({\n  lookup: MemoryLookup,\n  scannedChunks: Schema.Natural,\n  staleExcluded: Schema.Natural,\n  unauthorizedExcluded: Schema.Natural,\n  queryBytes: Schema.Natural,\n  inputTokens: InputTokens,\n  startedAt: Timestamp,\n  finishedAt: Timestamp,\n}) {}\n\nconst utf8 = (text: string): Uint8Array => {\n  const hex = Encoding.encodeHex(text);\n\n  return Uint8Array.from({ length: hex.length / 2 }, (_, index) =>\n    Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16),\n  );\n};\n\nconst invalid = (operation: string) =>\n  SemanticMemoryError.make({ operation, reason: \"invalid-input\" });\n\nconst asSource = (document: MemoryDocument): MemoryIndexSource =>\n  MemoryIndexSource.make({\n    key: document.key,\n    source: document.source,\n    sourceGeneration: document.generation,\n  });\n\nconst sameSource = (left: MemoryDocument, right: MemoryDocument): boolean =>\n  left.key.namespace.address === right.key.namespace.address &&\n  left.key.id === right.key.id &&\n  left.generation === right.generation &&\n  left.source.revision === right.source.revision &&\n  left.source.locator === right.source.locator &&\n  left._tag === right._tag;\n\nconst readDocument = Effect.fn(\"semanticMemory.readDocument\")(function* (key: MemoryKey) {\n  const reader = yield* MemoryReader;\n\n  const document = yield* reader.get(key).pipe(\n    Effect.flatMap(Schema.decodeUnknownEffect(Schema.NullOr(MemoryDocument.Wire))),\n    Effect.catchTag(\"SchemaError\", () =>\n      Effect.fail(\n        MemoryStorageError.make({ operation: \"validate semantic source\", reason: \"corrupt\" }),\n      ),\n    ),\n  );\n\n  if (\n    document !== null &&\n    (document.key.namespace.address !== key.namespace.address ||\n      document.key.id !== key.id ||\n      document.source.id !== key.id)\n  ) {\n    return yield* MemoryStorageError.make({\n      operation: \"validate semantic source identity\",\n      reason: \"corrupt\",\n    });\n  }\n\n  return document;\n});\n\nconst embeddings = Effect.fn(\"semanticMemory.embeddings\")(function* (\n  inputs: ReadonlyArray<string>,\n  profile: SemanticMemoryProfile,\n) {\n  const model = yield* EmbeddingModel.EmbeddingModel;\n\n  const response = yield* model.embedMany(inputs).pipe(\n    Effect.flatMap(Schema.decodeUnknownEffect(EmbeddingModel.EmbedManyResponse)),\n    Effect.catchTag(\"SchemaError\", () =>\n      Effect.fail(\n        SemanticMemoryError.make({ operation: \"decode embeddings\", reason: \"invalid-embedding\" }),\n      ),\n    ),\n  );\n\n  const tokens = response.usage.inputTokens;\n\n  if (\n    response.embeddings.length !== inputs.length ||\n    (tokens !== undefined && (!Number.isSafeInteger(tokens) || tokens < 0)) ||\n    response.embeddings.some(({ vector }) => {\n      const norm = vector.reduce((sum, value) => sum + value * value, 0);\n\n      return vector.length !== profile.dimensions || norm <= 0 || !Number.isFinite(norm);\n    })\n  ) {\n    return yield* SemanticMemoryError.make({\n      operation: \"validate embeddings\",\n      reason: \"invalid-embedding\",\n    });\n  }\n\n  return response;\n});\n\nconst chunkText = Effect.fn(\"semanticMemory.chunkText\")(function* (\n  text: string,\n  profile: SemanticMemoryProfile,\n  limits: SemanticIndexLimits,\n) {\n  if (utf8ByteLength(text) > limits.maxSourceBytes) {\n    return yield* SemanticMemoryError.make({ operation: \"chunk source\", reason: \"budget\" });\n  }\n\n  const chunks: Array<{\n    readonly ordinal: number;\n    readonly startByte: number;\n    readonly endByte: number;\n    readonly text: string;\n  }> = [];\n\n  let current = \"\";\n  let startByte = 0;\n  let currentBytes = 0;\n\n  for (const codepoint of text) {\n    const size = utf8ByteLength(codepoint);\n\n    if (currentBytes + size > profile.maxChunkBytes) {\n      chunks.push({\n        ordinal: chunks.length,\n        startByte,\n        endByte: startByte + currentBytes,\n        text: current,\n      });\n      startByte += currentBytes;\n      current = \"\";\n      currentBytes = 0;\n      if (chunks.length >= limits.maxChunks) {\n        return yield* SemanticMemoryError.make({ operation: \"chunk source\", reason: \"budget\" });\n      }\n    }\n    current += codepoint;\n    currentBytes += size;\n  }\n  if (current.length > 0)\n    chunks.push({\n      ordinal: chunks.length,\n      startByte,\n      endByte: startByte + currentBytes,\n      text: current,\n    });\n  if (chunks.length === 0) return yield* invalid(\"chunk empty source\");\n\n  return chunks;\n});\n\n/**\n * Rebuild one selected source through the native Effect EmbeddingModel. The host binds the\n * index profile to that provider's immutable model revision. A fresh Layer starts empty.\n * Every invocation rebuilds; the host owns source discovery, scheduling, and freshness policy.\n *\n * Chunking and embedding leave the last successful index intact. A final authoritative read\n * rejects a source changed during embedding, then replace atomically exchanges its chunks.\n * An independent source can still change between that read and replacement;\n * querySemanticMemory always revalidates and excludes such stale candidates.\n * No model or source text is attached to telemetry. Errors retain native provider/index types.\n */\nexport const indexMemorySource = Effect.fn(\"indexMemorySource\")(function* <\n  Namespace extends MemoryNamespace.Any,\n>(key: MemoryKey<Namespace>, limits: SemanticIndexLimits) {\n  yield* Schema.decodeUnknownEffect(MemoryKey.Wire)(key).pipe(\n    Effect.mapError(() => invalid(\"index key\")),\n  );\n  const checkedKey = MemoryKey.make(key);\n\n  const checkedLimits = yield* Schema.decodeEffect(SemanticIndexLimits)(limits).pipe(\n    Effect.mapError(() => invalid(\"index limits\")),\n  );\n\n  return yield* Effect.gen(function* () {\n    const startedAt = yield* Clock.currentTimeMillis;\n    const index = yield* SemanticMemoryIndex;\n\n    const profile = yield* Schema.decodeEffect(SemanticMemoryProfile)(index.profile).pipe(\n      Effect.mapError(() => invalid(\"index profile\")),\n    );\n\n    const document = yield* readDocument(checkedKey);\n\n    if (document === null || document._tag === \"WithdrawnMemoryDocument\") {\n      if (document !== null) yield* index.withdraw(asSource(document));\n\n      return SemanticIndexResult.make({\n        key: checkedKey,\n        status: document === null ? \"Missing\" : \"Withdrawn\",\n        embeddedChunks: 0,\n        embeddedBytes: 0,\n        inputTokens: null,\n        startedAt,\n        finishedAt: yield* Clock.currentTimeMillis,\n      });\n    }\n    const texts = yield* chunkText(document.content.text, profile, checkedLimits);\n\n    const encodedProfile = yield* Schema.encodeEffect(Schema.fromJsonString(SemanticMemoryProfile))(\n      profile,\n    ).pipe(Effect.mapError(() => invalid(\"encode profile\")));\n\n    const crypto = yield* Crypto.Crypto;\n\n    const fingerprint = yield* crypto.digest(\"SHA-256\", utf8(encodedProfile)).pipe(\n      Effect.map(Encoding.encodeHex),\n      Effect.mapError(() =>\n        SemanticMemoryError.make({ operation: \"fingerprint profile\", reason: \"unavailable\" }),\n      ),\n    );\n\n    const response = yield* embeddings(\n      texts.map((chunk) => chunk.text),\n      profile,\n    );\n\n    const chunks: Array<SemanticMemoryChunk> = [];\n\n    for (const text of texts) {\n      const vector = response.embeddings[text.ordinal]?.vector;\n\n      if (vector === undefined)\n        return yield* SemanticMemoryError.make({\n          operation: \"embedding count\",\n          reason: \"invalid-embedding\",\n        });\n      chunks.push(\n        SemanticMemoryChunk.make({\n          ...text,\n          passageId: `chunk:${fingerprint}:${text.ordinal}`,\n          vector: [...vector],\n        }),\n      );\n    }\n    const latest = yield* readDocument(checkedKey);\n\n    if (latest === null || !sameSource(document, latest)) {\n      if (latest?._tag === \"WithdrawnMemoryDocument\") yield* index.withdraw(asSource(latest));\n\n      return yield* SemanticMemoryError.make({\n        operation: \"publish current source\",\n        reason: \"source-changed\",\n      });\n    }\n    yield* index.replace({ source: asSource(document), profile, chunks });\n\n    return SemanticIndexResult.make({\n      key: checkedKey,\n      status: \"Indexed\",\n      embeddedChunks: chunks.length,\n      embeddedBytes: utf8ByteLength(document.content.text),\n      inputTokens: response.usage.inputTokens ?? null,\n      startedAt,\n      finishedAt: yield* Clock.currentTimeMillis,\n    });\n  }).pipe(\n    Effect.scoped,\n    Effect.timeoutOrElse({\n      duration: checkedLimits.timeoutMillis,\n      orElse: () =>\n        Effect.fail(SemanticMemoryError.make({ operation: \"index source\", reason: \"timeout\" })),\n    }),\n  );\n});\n\n/**\n * Query an optional derivative index, then read each distinct source once. Attribution and\n * metadata always come from that current source. Revision, generation, namespace, access,\n * locator, and exact UTF-8 excerpt checks run before returning any passage. Older candidates\n * are omitted rather than assigning their similarity score to changed text.\n * Process candidates in source groups, retain only passage excerpts, and restore index rank.\n * maxSourceBytes bounds aggregate UTF-8 JSON for distinct authorized sources with matching\n * generation/revision/locator candidates. Its default is 16 MiB; exhaustion returns no partial\n * result. Reader allocation, decoding, and one source serialization precede this bound.\n *\n * Compose result.lookup through Memory.recall to enforce the final rendered item/byte/token\n * budget and overall deadline. An empty result says nothing about undiscovered sources.\n * Checks begun before an acknowledged correction/withdrawal may finish with their already\n * captured source view.\n */\nexport const querySemanticMemory = Effect.fn(\"querySemanticMemory\")(function* (\n  query: string,\n  access: MemoryAccess,\n  limits: SemanticQueryLimits,\n) {\n  const checkedQuery = yield* Schema.decodeEffect(Schema.NonEmptyString)(query).pipe(\n    Effect.mapError(() => invalid(\"query text\")),\n  );\n\n  const checkedAccess = yield* Schema.decodeEffect(MemoryAccess.Wire)(access).pipe(\n    Effect.mapError(() => invalid(\"query access\")),\n  );\n\n  const checkedLimits = yield* Schema.decodeEffect(SemanticQueryLimits)(limits).pipe(\n    Effect.mapError(() => invalid(\"query limits\")),\n  );\n\n  const queryBytes = utf8ByteLength(checkedQuery);\n\n  if (queryBytes > checkedLimits.maxQueryBytes)\n    return yield* SemanticMemoryError.make({ operation: \"query bytes\", reason: \"budget\" });\n\n  return yield* Effect.gen(function* () {\n    const startedAt = yield* Clock.currentTimeMillis;\n    const index = yield* SemanticMemoryIndex;\n\n    const profile = yield* Schema.decodeEffect(SemanticMemoryProfile)(index.profile).pipe(\n      Effect.mapError(() => invalid(\"query profile\")),\n    );\n\n    const response = yield* embeddings([checkedQuery], profile);\n    const vector = response.embeddings[0]?.vector;\n\n    if (vector === undefined)\n      return yield* SemanticMemoryError.make({\n        operation: \"query embedding count\",\n        reason: \"invalid-embedding\",\n      });\n\n    const found = yield* index\n      .search(\n        MemoryIndexQuery.make({\n          namespace: checkedAccess.namespace,\n          vector,\n          limit: checkedLimits.maxCandidates,\n          minScore: checkedLimits.minScore,\n          maxScannedChunks: checkedLimits.maxScannedChunks,\n        }),\n      )\n      .pipe(\n        Effect.flatMap(Schema.decodeUnknownEffect(MemoryIndexSearch.Wire)),\n        Effect.catchTag(\"SchemaError\", () =>\n          Effect.fail(\n            MemoryIndexError.make({ operation: \"validate candidates\", reason: \"corrupt\" }),\n          ),\n        ),\n      );\n\n    const validated = yield* revalidateSemanticMemoryCandidates(\n      found,\n      checkedAccess,\n      profile,\n      checkedLimits,\n    );\n\n    return SemanticQueryResult.make({\n      ...validated,\n      queryBytes,\n      inputTokens: response.usage.inputTokens ?? null,\n      startedAt,\n      finishedAt: yield* Clock.currentTimeMillis,\n    });\n  }).pipe(\n    Effect.scoped,\n    Effect.timeoutOrElse({\n      duration: checkedLimits.timeoutMillis,\n      orElse: () =>\n        Effect.fail(SemanticMemoryError.make({ operation: \"query memory\", reason: \"timeout\" })),\n    }),\n  );\n});\n"],"mappings":"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"}

package/dist/capabilities/Subagent.d.mts

@@ -0,0 +1,4 @@
+import { c as SubagentExecutionFailureClassification, l as SubagentGrant, s as SubagentExecutionFailure } from "../SubagentContract-DdT7Cqe6.mjs";
+import { l as WorkerReport, r as WorkerCompletion } from "../Worker-CaPYykpe.mjs";
+import { A as cancel, B as delegationAllocationFromPolicy, C as reporting, D as Worker, E as BackgroundTools, F as start, I as SubagentPolicy, L as SubagentPolicyInput, M as inspect, N as list, O as WorkerObservation, P as observe, R as SubagentPrestartDenied, S as make, T as BackgroundOptions, V as delegationCapsFromPolicy, _ as SubagentTools, a as SubagentDelegation, b as define, c as SubagentFailureMode, d as SubagentResult, f as SubagentResultContext, g as SubagentToolFailure, h as SubagentTool, i as SubagentDefineOptions, j as followUp, k as awaitWorker, l as SubagentLayerRequirements, m as SubagentRuntimeOptions, n as SubagentContainedFailure, o as SubagentDurableAccounting, p as SubagentReturnModeFailure, r as SubagentDeclarationOptions, s as SubagentDurableOptions, t as SubagentChildRunFailure, u as SubagentPrepareContext, w as reportingToWorker, x as layer, y as background, z as SubagentProjectionFailure } from "../Subagent-DyfzHNdv.mjs";
+export { type BackgroundOptions, type BackgroundTools, SubagentChildRunFailure, SubagentContainedFailure, SubagentDeclarationOptions, SubagentDefineOptions, SubagentDelegation, SubagentDurableAccounting, SubagentDurableOptions, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentFailureMode, SubagentGrant, SubagentLayerRequirements, SubagentPolicy, type SubagentPolicyInput, SubagentPrepareContext, SubagentPrestartDenied, SubagentProjectionFailure, SubagentResult, SubagentResultContext, SubagentReturnModeFailure, SubagentRuntimeOptions, SubagentTool, SubagentToolFailure, SubagentTools, Worker, WorkerCompletion, WorkerObservation, WorkerReport, awaitWorker as await, background, cancel, define, delegationAllocationFromPolicy, delegationCapsFromPolicy, followUp, inspect, layer, list, make, observe, reporting, reportingToWorker, start };

package/dist/capabilities/Subagent.mjs

@@ -0,0 +1,5 @@
+import { SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentGrant } from "../core/SubagentContract.mjs";
+import { WorkerCompletion, WorkerReport } from "../core/Worker.mjs";
+import "./SubagentReservations.mjs";
+import { C as delegationCapsFromPolicy, S as delegationAllocationFromPolicy, _ as reporting, a as define, b as SubagentPrestartDenied, c as Worker, d as cancel, f as followUp, g as start, h as observe, i as background, l as WorkerObservation, m as list, n as SubagentResult, o as layer, p as inspect, s as make, t as SubagentDurableAccounting, u as awaitWorker, v as reportingToWorker, x as SubagentProjectionFailure, y as SubagentPolicy } from "../Subagent-Cy_hU1tv.mjs";
+export { SubagentDurableAccounting, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentGrant, SubagentPolicy, SubagentPrestartDenied, SubagentProjectionFailure, SubagentResult, Worker, WorkerCompletion, WorkerObservation, WorkerReport, awaitWorker as await, background, cancel, define, delegationAllocationFromPolicy, delegationCapsFromPolicy, followUp, inspect, layer, list, make, observe, reporting, reportingToWorker, start };

package/dist/capabilities/SubagentReservations.d.mts

@@ -0,0 +1,186 @@
+import { d as ToolCallId, s as RunId } from "../Identifiers-CN2s30fF.mjs";
+import { d as SubagentReservationAmounts, o as SubagentDelegationCaps } from "../SubagentContract-DdT7Cqe6.mjs";
+import { Context, Effect, Layer, Schema, Scope } from "effect";
+declare namespace SubagentReservations_d_exports {
+  export { BudgetReservationId, SubagentAvailableAmounts, SubagentBudgetDimension, SubagentBudgetExhausted, SubagentObservedUsage, SubagentParentBudgetActive, SubagentParentBudgetConflict, SubagentParentBudgetUnknown, SubagentParentBudgetView, SubagentReservationConflict, SubagentReservationRequest, SubagentReservationStatus, SubagentReservationUnknown, SubagentReservationView, SubagentReservations, SubagentReservationsMemoryLive, makeBudgetReservationId };
+}
+/**
+ * Stable identity of one parent-owned Subagent budget reservation.
+ *
+ * Derivation rule (see {@link makeBudgetReservationId}):
+ * `encodeURIComponent(parentRunId) + ":" + encodeURIComponent(parentToolCallId)`.
+ * Component encoding escapes `:`; the mapping is injective for every
+ * `(parentRunId, parentToolCallId)` pair.
+ */
+declare const BudgetReservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/capabilities/BudgetReservationId">;
+type BudgetReservationId = typeof BudgetReservationId.Type;
+/** Derive the stable reservation identity of one Subagent Invocation. */
+declare const makeBudgetReservationId: (parentRunId: RunId, parentToolCallId: ToolCallId) => BudgetReservationId;
+/** One enforced hierarchical delegation budget dimension. */
+declare const SubagentBudgetDimension: Schema.Literals<readonly ["total-child-invocations", "concurrent-children", "turns", "tool-calls", "duration", "input-tokens", "output-tokens", "cost", "result-bytes"]>;
+type SubagentBudgetDimension = typeof SubagentBudgetDimension.Type;
+declare const SubagentObservedUsage_base: Schema.Class<SubagentObservedUsage, Schema.Struct<{
+  readonly turns: Schema.optionalKey<Schema.Natural>;
+  readonly toolCalls: Schema.optionalKey<Schema.Natural>;
+  readonly durationMillis: Schema.optionalKey<Schema.Natural>;
+  readonly inputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly outputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly costMicrousd: Schema.optionalKey<Schema.Natural>;
+  readonly resultBytes: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** Observed child usage. An absent dimension was never reported and settles conservatively. */
+declare class SubagentObservedUsage extends SubagentObservedUsage_base {}
+declare const SubagentAvailableAmounts_base: Schema.Class<SubagentAvailableAmounts, Schema.Struct<{
+  readonly turns: Schema.optionalKey<Schema.Natural>;
+  readonly toolCalls: Schema.optionalKey<Schema.Natural>;
+  readonly durationMillis: Schema.optionalKey<Schema.Natural>;
+  readonly inputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly outputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly costMicrousd: Schema.optionalKey<Schema.Natural>;
+  readonly resultBytes: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** Remaining delegable allocation per configured dimension. Absent means not configured. */
+declare class SubagentAvailableAmounts extends SubagentAvailableAmounts_base {}
+/** Reservation lifecycle: absent → reserved → releasePending → released. */
+declare const SubagentReservationStatus: Schema.Literals<readonly ["reserved", "releasePending", "released"]>;
+type SubagentReservationStatus = typeof SubagentReservationStatus.Type;
+declare const SubagentReservationRequest_base: Schema.Class<SubagentReservationRequest, Schema.Struct<{
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly parentToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly allocation: typeof SubagentReservationAmounts;
+  /** Additional invocation slots held for this child's entire subtree. */
+  readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** All-or-nothing allocation request for one Subagent Invocation. */
+declare class SubagentReservationRequest extends SubagentReservationRequest_base {}
+declare const SubagentReservationView_base: Schema.Class<SubagentReservationView, Schema.Struct<{
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/capabilities/BudgetReservationId">;
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly parentToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly status: Schema.Literals<readonly ["reserved", "releasePending", "released"]>;
+  readonly allocated: typeof SubagentReservationAmounts;
+  readonly observedConsumed: typeof SubagentObservedUsage;
+  readonly coveredConsumed: typeof SubagentReservationAmounts;
+  readonly released: typeof SubagentReservationAmounts;
+  readonly overrun: typeof SubagentReservationAmounts;
+}>, {}>;
+/** Accounting snapshot of one reservation: allocated, observed, covered, released, and overrun. */
+declare class SubagentReservationView extends SubagentReservationView_base {}
+declare const SubagentParentBudgetView_base: Schema.Class<SubagentParentBudgetView, Schema.Struct<{
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly caps: typeof SubagentDelegationCaps;
+  readonly totalChildInvocations: Schema.Natural;
+  readonly available: typeof SubagentAvailableAmounts;
+  readonly cumulativeOverrun: typeof SubagentReservationAmounts;
+  readonly reservations: Schema.$Array<typeof SubagentReservationView>;
+}>, {}>;
+/** Aggregate parent delegation budget snapshot including every reservation it owns. */
+declare class SubagentParentBudgetView extends SubagentParentBudgetView_base {}
+declare const SubagentBudgetExhausted_base: Schema.Class<SubagentBudgetExhausted, Schema.TaggedStruct<"SubagentBudgetExhausted", {
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly dimension: Schema.Literals<readonly ["total-child-invocations", "concurrent-children", "turns", "tool-calls", "duration", "input-tokens", "output-tokens", "cost", "result-bytes"]>;
+  readonly limitValue: Schema.Natural;
+  readonly observedValue: Schema.Natural;
+}>, import("effect/Cause").YieldableError>;
+/** All-or-nothing admission failed: one dimension cannot cover the requested allocation. */
+declare class SubagentBudgetExhausted extends SubagentBudgetExhausted_base {}
+declare const SubagentReservationConflict_base: Schema.Class<SubagentReservationConflict, Schema.TaggedStruct<"SubagentReservationConflict", {
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/capabilities/BudgetReservationId">;
+  readonly existingAllocation: typeof SubagentReservationAmounts;
+  readonly requestedAllocation: typeof SubagentReservationAmounts;
+}>, import("effect/Cause").YieldableError>;
+/** The stable key is already reserved with a different allocation; neither request may win silently. */
+declare class SubagentReservationConflict extends SubagentReservationConflict_base {}
+declare const SubagentReservationUnknown_base: Schema.Class<SubagentReservationUnknown, Schema.TaggedStruct<"SubagentReservationUnknown", {
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/capabilities/BudgetReservationId">;
+}>, import("effect/Cause").YieldableError>;
+/** No reservation exists for this identity. */
+declare class SubagentReservationUnknown extends SubagentReservationUnknown_base {}
+declare const SubagentParentBudgetUnknown_base: Schema.Class<SubagentParentBudgetUnknown, Schema.TaggedStruct<"SubagentParentBudgetUnknown", {
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+}>, import("effect/Cause").YieldableError>;
+/** No delegation budget was registered for this parent Run. */
+declare class SubagentParentBudgetUnknown extends SubagentParentBudgetUnknown_base {}
+declare const SubagentParentBudgetConflict_base: Schema.Class<SubagentParentBudgetConflict, Schema.TaggedStruct<"SubagentParentBudgetConflict", {
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+}>, import("effect/Cause").YieldableError>;
+/** The parent Run is already registered with different caps; neither set may win silently. */
+declare class SubagentParentBudgetConflict extends SubagentParentBudgetConflict_base {}
+declare const SubagentParentBudgetActive_base: Schema.Class<SubagentParentBudgetActive, Schema.TaggedStruct<"SubagentParentBudgetActive", {
+  readonly parentRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly openReservations: Schema.Natural;
+}>, import("effect/Cause").YieldableError>;
+/** A parent budget cannot retire while one of its child reservations is unsettled. */
+declare class SubagentParentBudgetActive extends SubagentParentBudgetActive_base {}
+declare const SubagentReservations_base: Context.ServiceClass<SubagentReservations, "@effect-agent/capabilities/SubagentReservations", {
+  /**
+   * Register the finite delegable budget of one parent Run. Re-registering
+   * identical caps returns the existing registration; different caps fail
+   * rather than silently winning.
+   */
+  readonly registerParent: (parentRunId: RunId, caps: SubagentDelegationCaps) => Effect.Effect<SubagentParentBudgetView, SubagentParentBudgetConflict>;
+  /**
+   * Atomically reserve an all-or-nothing child allocation from the parent's
+   * remaining delegable budget, checking every dimension before committing
+   * any. The same key with the same allocation is idempotent and never
+   * double-reserves; a distinct key charges the monotonic total-invocation
+   * counter by one plus its reserved descendant slots, which release never refunds.
+   */
+  readonly reserve: (request: SubagentReservationRequest) => Effect.Effect<SubagentReservationView, SubagentBudgetExhausted | SubagentReservationConflict | SubagentParentBudgetUnknown>;
+  /**
+   * Record observed child usage against a reservation. Usage above the
+   * reserved amount is recorded as overrun and charged to the parent
+   * aggregate, never clipped. Usage observed after settlement begins is
+   * pure overrun and cannot create budget.
+   */
+  readonly observe: (reservationId: BudgetReservationId, usage: SubagentObservedUsage) => Effect.Effect<SubagentReservationView, SubagentReservationUnknown>;
+  /**
+   * `reserved → releasePending`: freeze the settlement decision. A dimension
+   * with no observed usage conservatively consumes its reserved amount.
+   * Idempotent once settlement has begun.
+   */
+  readonly beginRelease: (reservationId: BudgetReservationId) => Effect.Effect<SubagentReservationView, SubagentReservationUnknown>;
+  /**
+   * `releasePending → released`: return the unused allocation to the parent
+   * exactly once. Called on a still-reserved reservation it settles through
+   * `releasePending` in the same atomic update. Idempotent once released.
+   */
+  readonly release: (reservationId: BudgetReservationId) => Effect.Effect<SubagentReservationView, SubagentReservationUnknown>;
+  /**
+   * Acquire bounded child execution slots as a Scope-owned resource, so
+   * an interrupted child always frees its slot. The Semaphore bounds only
+   * concurrent children; a subtree holds one plus its possible descendants up front.
+   * Total invocations are enforced separately by
+   * `reserve`'s monotonic counter. A configured cap of zero fails closed
+   * instead of queueing forever; an unconfigured cap leaves execution
+   * ungated by this service.
+   */
+  readonly acquireChildSlot: (parentRunId: RunId, slots?: number) => Effect.Effect<void, SubagentParentBudgetUnknown | SubagentBudgetExhausted, Scope.Scope>;
+  /**
+   * Reclaim one terminal parent registration and all of its released child
+   * reservations. Retirement is idempotent; an unknown parent is already
+   * retired. Open reservations fail typed and leave the ledger unchanged.
+   * The Run owner must call this after its final accounting snapshot no
+   * longer needs to be observable.
+   */
+  readonly retireParent: (parentRunId: RunId) => Effect.Effect<void, SubagentParentBudgetActive>;
+  /** Read the aggregate parent view for auditing and conservation checks. */
+  readonly parentSnapshot: (parentRunId: RunId) => Effect.Effect<SubagentParentBudgetView, SubagentParentBudgetUnknown>;
+}>;
+/**
+ * Parent-owned hierarchical Subagent budget reservation authority.
+ *
+ * Every transition is a single atomic `Ref` update, so parallel children can
+ * never observe and spend the same remainder. The post-response usage hook in
+ * `budget.ts` is deliberately not reused here: it accounts after the fact and
+ * is not a reservation service.
+ */
+declare class SubagentReservations extends SubagentReservations_base {}
+/**
+ * In-memory reservation ledger. All state lives in one `Ref` owned by the
+ * Layer's Scope; every transition is a single atomic `Ref.modify`.
+ */
+declare const SubagentReservationsMemoryLive: Layer.Layer<SubagentReservations>;
+//#endregion
+export { BudgetReservationId, SubagentAvailableAmounts, SubagentBudgetDimension, SubagentBudgetExhausted, SubagentObservedUsage, SubagentParentBudgetActive, SubagentParentBudgetConflict, SubagentParentBudgetUnknown, SubagentParentBudgetView, SubagentReservationConflict, SubagentReservationRequest, SubagentReservationStatus, SubagentReservationUnknown, SubagentReservationView, SubagentReservations, SubagentReservationsMemoryLive, makeBudgetReservationId, SubagentReservations_d_exports as t };
+//# sourceMappingURL=SubagentReservations.d.mts.map