@rivus/agent 0.14.2 → 0.14.4

package/dist/chunks/api2.js

@@ -1,1331 +0,0 @@
-import { n as createRandomId, t as createSha256Digest } from "./sha256-digest.js";
-import { Cause, Deferred, Effect, Fiber } from "effect";
-//#region src/platform/concurrency/periodic-effect-loop.ts
-function createEffectLoopDriver(loop) {
-	let running = false;
-	let fiber;
-	return {
-		running: () => running,
-		start: () => {
-			if (running) return;
-			running = true;
-			fiber = Effect.runFork(loop);
-		},
-		stop: async () => {
-			running = false;
-			const activeFiber = fiber;
-			fiber = void 0;
-			if (activeFiber) await Effect.runPromise(Fiber.interrupt(activeFiber));
-		}
-	};
-}
-function createPeriodicEffectLoop(options) {
-	const reportError = (error) => {
-		const reported = options.onError?.(error);
-		return reported instanceof Promise ? Effect.promise(() => reported) : Effect.void;
-	};
-	const continueAfterReporting = (effect) => effect.pipe(Effect.asVoid, Effect.catchAll((error) => reportError(error)));
-	const cycle = Effect.suspend(() => continueAfterReporting(options.run()).pipe(Effect.flatMap(() => continueAfterReporting(options.sleep(options.intervalMs))), Effect.flatMap(() => cycle)));
-	return createEffectLoopDriver(cycle);
-}
-//#endregion
-//#region src/modules/background-session/application/authority/background-session-identity.ts
-const BACKGROUND_SESSION_SESSION_KEY_PREFIX = "background";
-function createBackgroundSessionKey(sessionId) {
-	return `${BACKGROUND_SESSION_SESSION_KEY_PREFIX}:${sessionId}`;
-}
-function createBackgroundSessionStepSourceMessageId(sessionId, stepCount) {
-	return `bg:${sessionId}:step:${stepCount}`;
-}
-//#endregion
-//#region src/modules/background-session/application/authority/background-session-authority.ts
-const BACKGROUND_SESSION_TOOL_IDS = [
-	"background.start",
-	"background.wait",
-	"background.list",
-	"background.status",
-	"background.send",
-	"background.stop"
-];
-const BACKGROUND_SESSION_START_TOOL_ID = "background.start";
-const BACKGROUND_SESSION_TOOL_PLUGIN_ID = "rivus-core";
-const BACKGROUND_SESSION_TOOL_VERSION = "1.0.0";
-function createBackgroundSessionToolContracts() {
-	return [
-		Object.freeze({
-			description: "Start a background agent session. Use when the request must wait for external changes, observe over time, or continue working after the foreground run ends. Returns a stable session id immediately; the foreground response can finish here. The detached session continues with the granted Skills, CLI, Tools, Project Space, and Memory of this agent.",
-			digest: contractDigest("background.start"),
-			id: "background.start",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					displayName: {
-						type: "string",
-						maxLength: 200
-					},
-					prompt: {
-						type: "string",
-						minLength: 1,
-						maxLength: 2e4
-					}
-				}),
-				required: ["prompt"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Pause the current background session durably and end the current step. Call with delayMs to resume after a delay, with until to resume at an absolute ISO time, or with neither to wait for user input. After this call no further tool calls are accepted in this step.",
-			digest: contractDigest("background.wait"),
-			id: "background.wait",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					delayMs: {
-						type: "integer",
-						minimum: 1e3,
-						maximum: 864e5
-					},
-					reason: {
-						type: "string",
-						maxLength: 500
-					},
-					until: {
-						type: "string",
-						maxLength: 64
-					}
-				}),
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "List background sessions owned by this conversation, newest first. Optionally filter by phase and limit the number of results.",
-			digest: contractDigest("background.list"),
-			id: "background.list",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					limit: {
-						type: "integer",
-						minimum: 1,
-						maximum: 50
-					},
-					phase: {
-						enum: [
-							"queued",
-							"running",
-							"waiting",
-							"input-required",
-							"stopping",
-							"stopped",
-							"completed",
-							"failed",
-							"reconciliation-required"
-						],
-						type: "string"
-					}
-				}),
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "observe",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Return the current phase, step counts, wake time, and result of one background session owned by this conversation.",
-			digest: contractDigest("background.status"),
-			id: "background.status",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({ sessionId: {
-					type: "string",
-					minLength: 1,
-					maxLength: 200
-				} }),
-				required: ["sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "observe",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Send new user instruction text to a background session owned by this conversation and wake it. The input is delivered exactly once in the next step.",
-			digest: contractDigest("background.send"),
-			id: "background.send",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					message: {
-						type: "string",
-						minLength: 1,
-						maxLength: 2e4
-					},
-					sessionId: {
-						type: "string",
-						minLength: 1,
-						maxLength: 200
-					}
-				}),
-				required: ["message", "sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		}),
-		Object.freeze({
-			description: "Stop a background session owned by this conversation. Persists the cancellation, aborts the active step and its owned process, and delivers a terminal notice.",
-			digest: contractDigest("background.stop"),
-			id: "background.stop",
-			idempotency: "supported",
-			inputSchema: Object.freeze({
-				additionalProperties: false,
-				properties: Object.freeze({
-					reason: {
-						type: "string",
-						maxLength: 500
-					},
-					sessionId: {
-						type: "string",
-						minLength: 1,
-						maxLength: 200
-					}
-				}),
-				required: ["sessionId"],
-				type: "object"
-			}),
-			pluginId: BACKGROUND_SESSION_TOOL_PLUGIN_ID,
-			risk: "mutate",
-			version: BACKGROUND_SESSION_TOOL_VERSION
-		})
-	];
-}
-function backgroundSessionToolIds() {
-	return [...BACKGROUND_SESSION_TOOL_IDS];
-}
-function isBackgroundSessionToolId(toolId) {
-	return BACKGROUND_SESSION_TOOL_IDS.includes(toolId);
-}
-function extendBackgroundSessionDefinition(definition) {
-	const contracts = createBackgroundSessionToolContracts();
-	const existingIds = new Set(definition.tools.map(({ id }) => id));
-	const additions = contracts.filter((contract) => !existingIds.has(contract.id));
-	const toolGrantSet = Object.freeze({
-		revision: grantRevision(definition.toolGrantSet.revision, additions.map(({ id }) => id)),
-		toolIds: Object.freeze([...definition.toolGrantSet.toolIds, ...additions.map(({ id }) => id)].sort())
-	});
-	return Object.freeze({
-		...definition,
-		tools: Object.freeze([...definition.tools, ...additions]),
-		toolGrantSet
-	});
-}
-function narrowBackgroundSessionDefinition(definition) {
-	const childToolIds = definition.toolGrantSet.toolIds.filter((id) => id !== BACKGROUND_SESSION_START_TOOL_ID);
-	const toolGrantSet = Object.freeze({
-		revision: grantRevision(definition.toolGrantSet.revision, childToolIds),
-		toolIds: Object.freeze(childToolIds)
-	});
-	return Object.freeze({
-		...definition,
-		tools: Object.freeze(definition.tools.filter(({ id }) => id !== BACKGROUND_SESSION_START_TOOL_ID)),
-		toolGrantSet
-	});
-}
-function grantRevision(parentRevision, toolIds) {
-	return createSha256Digest(JSON.stringify({
-		parentRevision,
-		toolIds: [...toolIds].sort()
-	}));
-}
-function contractDigest(toolId) {
-	return createSha256Digest(`background-tool:${toolId}:${BACKGROUND_SESSION_TOOL_VERSION}`);
-}
-//#endregion
-//#region src/modules/background-session/application/control/background-session-control-input.ts
-function readBackgroundSessionObject(input, allowed, error) {
-	if (input === null || typeof input !== "object" || Array.isArray(input)) throw error("background tool input must be an object");
-	const record = input;
-	const unknown = Object.keys(record).find((key) => !allowed.includes(key));
-	if (unknown) throw error(`field is not allowed: ${unknown}`);
-	return record;
-}
-function readBackgroundSessionString(value, name, error) {
-	if (typeof value !== "string" || value.trim() === "") throw error(`${name} must be a non-empty string`);
-	return value;
-}
-function readBackgroundSessionInteger(value, name, error) {
-	if (!Number.isSafeInteger(value) || value < 1) throw error(`${name} must be a positive integer`);
-	return value;
-}
-function readBackgroundSessionPhase(value, error) {
-	const phases = [
-		"queued",
-		"running",
-		"waiting",
-		"input-required",
-		"stopping",
-		"stopped",
-		"completed",
-		"failed",
-		"reconciliation-required"
-	];
-	if (typeof value !== "string" || !phases.includes(value)) throw error(`phase must be one of ${phases.join(", ")}`);
-	return value;
-}
-function readBackgroundSessionWaitInput(input, error) {
-	const { delayMs, reason, until } = readBackgroundSessionObject(input, [
-		"delayMs",
-		"reason",
-		"until"
-	], error);
-	const args = {};
-	if (delayMs !== void 0) args.delayMs = readBackgroundSessionInteger(delayMs, "delayMs", error);
-	if (reason !== void 0) args.reason = readBackgroundSessionString(reason, "reason", error);
-	if (until !== void 0) args.until = readBackgroundSessionString(until, "until", error);
-	return args;
-}
-//#endregion
-//#region src/modules/background-session/application/control/background-session-control.ts
-function createBackgroundSessionControl(options) {
-	return { handle: async (command, context, input) => {
-		const executionContext = {
-			agentId: context.agentId,
-			callId: `mcp-call:${createRandomId()}`,
-			instanceId: `mcp:${context.agentId}`,
-			policyEpoch: context.policyEpoch,
-			runId: context.runId,
-			sessionKey: context.sessionKey,
-			sourceMessageId: context.sourceMessageId,
-			toolId: `background.${command}`,
-			toolVersion: "1.0.0",
-			origin: toToolOrigin(context.origin)
-		};
-		switch (command) {
-			case "start": {
-				const { displayName, prompt } = readObject(input, ["displayName", "prompt"]);
-				if (typeof prompt !== "string" || prompt.trim() === "") throw new BackgroundSessionControlError("background.start requires a non-empty prompt");
-				const sessionId = `bg-${createRandomId()}`;
-				return options.service.start({
-					authority: {
-						...context.authority,
-						sessionKey: createBackgroundSessionKey(sessionId)
-					},
-					context: executionContext,
-					...displayName === void 0 ? {} : { displayName: readString(displayName, "displayName") },
-					prompt,
-					sessionId
-				});
-			}
-			case "wait": return options.service.wait({
-				context: executionContext,
-				...readBackgroundSessionWaitInput(input, (message) => new BackgroundSessionControlError(message))
-			});
-			case "list": {
-				const { limit, phase } = readObject(input, ["limit", "phase"]);
-				return options.service.list({
-					context: executionContext,
-					...limit === void 0 ? {} : { limit: readInteger(limit, "limit") },
-					...phase === void 0 ? {} : { phase: readPhase(phase) }
-				});
-			}
-			case "status": {
-				const { sessionId } = readObject(input, ["sessionId"]);
-				return options.service.status({
-					context: executionContext,
-					sessionId: readString(sessionId, "sessionId")
-				});
-			}
-			case "send": {
-				const { message, sessionId } = readObject(input, ["message", "sessionId"]);
-				return options.service.send({
-					context: executionContext,
-					message: readString(message, "message"),
-					sessionId: readString(sessionId, "sessionId")
-				});
-			}
-			case "stop": {
-				const { reason, sessionId } = readObject(input, ["reason", "sessionId"]);
-				return options.service.stop({
-					context: executionContext,
-					...reason === void 0 ? {} : { reason: readString(reason, "reason") },
-					sessionId: readString(sessionId, "sessionId")
-				});
-			}
-		}
-	} };
-}
-var BackgroundSessionControlError = class extends Error {
-	name = "BackgroundSessionControlError";
-};
-function toControlContext(input) {
-	return {
-		agentId: input.agentId,
-		authority: input.authority,
-		origin: {
-			allowedActorOpenIds: input.origin.allowedActorOpenIds,
-			...input.origin.conversationId === void 0 ? {} : { conversationId: input.origin.conversationId },
-			endpointId: input.origin.endpointId,
-			tenantKey: input.origin.tenantKey
-		},
-		policyEpoch: input.policyEpoch,
-		runId: `mcp:${createRandomId()}`,
-		sessionKey: input.sessionKey,
-		sourceMessageId: input.sourceMessageId ?? `mcp:${createRandomId()}`
-	};
-}
-function toToolOrigin(origin) {
-	return {
-		allowedActorOpenIds: origin.allowedActorOpenIds,
-		endpointId: origin.endpointId,
-		tenantKey: origin.tenantKey,
-		...origin.conversationId === void 0 ? {} : { conversationId: origin.conversationId }
-	};
-}
-function readObject(input, allowed) {
-	return readBackgroundSessionObject(input, allowed, (message) => new BackgroundSessionControlError(message));
-}
-function readString(value, name) {
-	return readBackgroundSessionString(value, name, (message) => new BackgroundSessionControlError(message));
-}
-function readInteger(value, name) {
-	return readBackgroundSessionInteger(value, name, (message) => new BackgroundSessionControlError(message));
-}
-function readPhase(value) {
-	return readBackgroundSessionPhase(value, (message) => new BackgroundSessionControlError(message));
-}
-//#endregion
-//#region src/modules/background-session/domain/session/background-session-model.ts
-const BACKGROUND_SESSION_TERMINAL_PHASES = /* @__PURE__ */ new Set([
-	"stopped",
-	"completed",
-	"failed",
-	"reconciliation-required"
-]);
-function isBackgroundSessionTerminalPhase(phase) {
-	return BACKGROUND_SESSION_TERMINAL_PHASES.has(phase);
-}
-var BackgroundSessionTransitionDenied = class extends Error {
-	sessionId;
-	name = "BackgroundSessionTransitionDenied";
-	constructor(sessionId, message) {
-		super(message);
-		this.sessionId = sessionId;
-	}
-};
-//#endregion
-//#region src/modules/background-session/domain/session/background-session-transitions.ts
-function createBackgroundSession(input) {
-	if (!input.sessionId.trim()) throw new BackgroundSessionTransitionDenied(input.sessionId, "background session id must not be empty");
-	if (!input.authority.sessionKey.trim()) throw new BackgroundSessionTransitionDenied(input.sessionId, "background session key must not be empty");
-	if (!input.authority.agentId.trim()) throw new BackgroundSessionTransitionDenied(input.sessionId, "background session authority requires an agent id");
-	if (!input.sourceMessageId.trim()) throw new BackgroundSessionTransitionDenied(input.sessionId, "background session requires a trusted source message id");
-	return Object.freeze({
-		authority: Object.freeze({
-			...input.authority,
-			memoryScopes: Object.freeze([...input.authority.memoryScopes])
-		}),
-		consecutiveFailures: 0,
-		createdAt: input.now,
-		displayName: input.displayName,
-		origin: Object.freeze({
-			...input.origin,
-			allowedActorOpenIds: Object.freeze([...input.origin.allowedActorOpenIds])
-		}),
-		parentRunId: input.parentRunId,
-		pendingInput: Object.freeze([]),
-		phase: "queued",
-		prompt: input.prompt,
-		revision: 1,
-		sessionId: input.sessionId,
-		sourceMessageId: input.sourceMessageId,
-		stepCount: 0,
-		updatedAt: input.now,
-		wakeCount: 0
-	});
-}
-function claimBackgroundSession(state, input) {
-	if (isBackgroundSessionTerminalPhase(state.phase)) throw new BackgroundSessionTransitionDenied(state.sessionId, `terminal ${state.phase} session cannot run again`);
-	if (state.phase !== "queued" && state.phase !== "waiting") throw new BackgroundSessionTransitionDenied(state.sessionId, `background session cannot start a step while ${state.phase}`);
-	if (state.wakeAt !== void 0 && state.wakeAt > input.now) throw new BackgroundSessionTransitionDenied(state.sessionId, "background session is not due");
-	return next(state, {
-		currentStepRunId: input.stepRunId,
-		lastWakeText: input.wakeText,
-		lease: input.lease,
-		pendingInput: Object.freeze([]),
-		phase: "running",
-		stepCount: state.stepCount + 1,
-		updatedAt: input.now,
-		wakeAt: void 0,
-		wakeCount: state.wakeCount + 1
-	});
-}
-function renewBackgroundSessionLease(state, lease) {
-	if (state.lease === void 0) throw new BackgroundSessionTransitionDenied(state.sessionId, "cannot renew a lease that is not held");
-	if (state.lease.owner !== lease.owner || state.lease.epoch !== lease.epoch) throw new BackgroundSessionTransitionDenied(state.sessionId, "cannot renew a lease from another worker");
-	return next(state, { lease });
-}
-function releaseBackgroundSessionLease(state) {
-	if (state.lease === void 0) throw new BackgroundSessionTransitionDenied(state.sessionId, "no lease to release");
-	return next(state, { lease: void 0 });
-}
-function suspendBackgroundSession(state, input) {
-	if (state.phase !== "running") throw new BackgroundSessionTransitionDenied(state.sessionId, `background session cannot wait while ${state.phase}`);
-	if (input.wakeAt !== void 0 && input.wakeAt <= input.now) throw new BackgroundSessionTransitionDenied(state.sessionId, "background session wake time must be in the future");
-	return next(state, {
-		currentStepRunId: void 0,
-		phase: input.wakeAt === void 0 ? "input-required" : "waiting",
-		updatedAt: input.now,
-		...input.wakeAt === void 0 ? {} : { wakeAt: input.wakeAt }
-	});
-}
-function completeBackgroundSessionStep(state, input) {
-	if (state.phase !== "running") throw new BackgroundSessionTransitionDenied(state.sessionId, `background session cannot complete while ${state.phase}`);
-	return next(state, {
-		consecutiveFailures: 0,
-		currentStepRunId: void 0,
-		lease: void 0,
-		phase: "completed",
-		result: {
-			completedAt: input.now,
-			stepRunId: input.stepRunId,
-			text: input.text
-		},
-		updatedAt: input.now
-	});
-}
-function failBackgroundSessionStep(state, input) {
-	if (state.phase !== "running") throw new BackgroundSessionTransitionDenied(state.sessionId, `background session cannot fail while ${state.phase}`);
-	if (input.retryable) {
-		if (input.wakeAt === void 0 || input.wakeAt <= input.now) throw new BackgroundSessionTransitionDenied(state.sessionId, "retryable failure requires a future wake time");
-		return next(state, {
-			consecutiveFailures: state.consecutiveFailures + 1,
-			currentStepRunId: void 0,
-			errorMessage: input.errorMessage,
-			lease: void 0,
-			phase: "queued",
-			updatedAt: input.now,
-			wakeAt: input.wakeAt
-		});
-	}
-	return next(state, {
-		consecutiveFailures: state.consecutiveFailures + 1,
-		currentStepRunId: void 0,
-		errorMessage: input.errorMessage,
-		lease: void 0,
-		phase: "failed",
-		updatedAt: input.now
-	});
-}
-function requestBackgroundSessionStop(state, input) {
-	if (isBackgroundSessionTerminalPhase(state.phase)) throw new BackgroundSessionTransitionDenied(state.sessionId, `terminal ${state.phase} session cannot stop`);
-	if (state.phase === "stopping") throw new BackgroundSessionTransitionDenied(state.sessionId, "background session is already stopping");
-	if (state.phase === "running") return next(state, {
-		cancellation: {
-			reason: input.reason,
-			requestedAt: input.now
-		},
-		phase: "stopping",
-		updatedAt: input.now
-	});
-	return next(state, {
-		cancellation: {
-			reason: input.reason,
-			requestedAt: input.now
-		},
-		currentStepRunId: void 0,
-		lease: void 0,
-		phase: "stopped",
-		updatedAt: input.now,
-		wakeAt: void 0
-	});
-}
-function completeBackgroundSessionStop(state, input) {
-	if (state.phase !== "stopping") throw new BackgroundSessionTransitionDenied(state.sessionId, `background session cannot finish stopping while ${state.phase}`);
-	return next(state, {
-		currentStepRunId: void 0,
-		lease: void 0,
-		phase: "stopped",
-		updatedAt: input.now,
-		wakeAt: void 0
-	});
-}
-function parkBackgroundSessionForReconciliation(state, input) {
-	if (isBackgroundSessionTerminalPhase(state.phase) && state.phase !== "reconciliation-required") throw new BackgroundSessionTransitionDenied(state.sessionId, `terminal ${state.phase} session cannot be reconciled`);
-	return next(state, {
-		currentStepRunId: void 0,
-		errorMessage: input.reason,
-		lease: void 0,
-		phase: "reconciliation-required",
-		reconciliationNote: input.reason,
-		updatedAt: input.now,
-		wakeAt: void 0
-	});
-}
-function resolveBackgroundSessionReconciliation(state, input) {
-	if (state.phase !== "reconciliation-required") throw new BackgroundSessionTransitionDenied(state.sessionId, `background session cannot resolve while ${state.phase}`);
-	if (input.outcome === "continue") return next(state, {
-		errorMessage: void 0,
-		phase: "queued",
-		reconciliationNote: void 0,
-		updatedAt: input.now,
-		wakeAt: input.now
-	});
-	return next(state, {
-		errorMessage: void 0,
-		phase: "stopped",
-		reconciliationNote: void 0,
-		updatedAt: input.now,
-		wakeAt: void 0
-	});
-}
-function appendBackgroundSessionInput(state, input) {
-	if (isBackgroundSessionTerminalPhase(state.phase)) throw new BackgroundSessionTransitionDenied(state.sessionId, `terminal ${state.phase} session cannot accept input`);
-	return next(state, {
-		pendingInput: Object.freeze([...state.pendingInput, input.message]),
-		updatedAt: input.now,
-		...state.phase === "waiting" || state.phase === "input-required" ? {
-			phase: "queued",
-			wakeAt: input.now
-		} : {}
-	});
-}
-function requeueInterruptedBackgroundSessionStep(state, input) {
-	if (state.phase !== "running") throw new BackgroundSessionTransitionDenied(state.sessionId, "interrupted step recovery requires a running session");
-	return next(state, {
-		currentStepRunId: void 0,
-		lastWakeText: input.wakeText,
-		lease: void 0,
-		phase: "queued",
-		updatedAt: input.now,
-		wakeAt: input.now
-	});
-}
-function isBackgroundSessionLeaseExpired(state, now) {
-	return state.lease !== void 0 && state.lease.expiresAt <= now;
-}
-function isBackgroundSessionDue(state, now) {
-	if (state.phase !== "queued" && state.phase !== "waiting") return false;
-	return state.wakeAt === void 0 || state.wakeAt <= now;
-}
-function next(state, changes) {
-	const merged = {
-		...state,
-		...changes,
-		revision: state.revision + 1
-	};
-	for (const key of Object.keys(merged)) if (merged[key] === void 0) delete merged[key];
-	return Object.freeze(merged);
-}
-//#endregion
-//#region src/platform/concurrency/serial-executor.ts
-function createSerialExecutor() {
-	let tail = Promise.resolve();
-	return { run: (operation) => {
-		const result = tail.then(operation, operation);
-		tail = result.then(() => void 0, () => void 0);
-		return result;
-	} };
-}
-//#endregion
-//#region src/modules/background-session/application/session/background-session-service.ts
-var BackgroundSessionCallerDenied = class extends Error {
-	name = "BackgroundSessionCallerDenied";
-	constructor(message) {
-		super(message);
-	}
-};
-function createBackgroundSessionService(options) {
-	const serial = createSerialExecutor();
-	const start = async (input) => {
-		const now = options.clock.now();
-		const origin = requireOrigin(input.context);
-		const state = createBackgroundSession({
-			authority: input.authority,
-			displayName: input.displayName?.trim() || input.sessionId,
-			now,
-			origin: {
-				allowedActorOpenIds: origin.allowedActorOpenIds,
-				...origin.conversationId === void 0 ? {} : { conversationId: origin.conversationId },
-				endpointId: origin.endpointId,
-				...input.context.memory ? { memory: {
-					audience: input.context.memory.audience,
-					...input.context.memory.conversationId ? { conversationId: input.context.memory.conversationId } : {},
-					...input.context.memory.projectId ? { projectId: input.context.memory.projectId } : {},
-					subjectId: input.context.memory.subjectId,
-					tenantId: input.context.memory.tenantId
-				} } : {},
-				tenantKey: origin.tenantKey
-			},
-			parentRunId: input.context.runId,
-			prompt: input.prompt,
-			sessionId: input.sessionId,
-			sourceMessageId: requireSourceMessageId(input.context)
-		});
-		return toSummary(await options.repository.create(state));
-	};
-	const wait = async (input) => {
-		const sessionId = sessionIdFromSessionKey(input.context.sessionKey);
-		if (!sessionId) throw new BackgroundSessionCallerDenied("background.wait is only available inside a background session step");
-		if (input.delayMs !== void 0 && input.until !== void 0) throw new BackgroundSessionCallerDenied("background.wait cannot combine delayMs and until");
-		const now = options.clock.now();
-		let wakeAt;
-		if (input.delayMs !== void 0) {
-			if (!Number.isSafeInteger(input.delayMs) || input.delayMs < 1) throw new BackgroundSessionCallerDenied("background.wait delayMs must be a positive integer");
-			wakeAt = new Date(Date.parse(now) + input.delayMs).toISOString();
-		} else if (input.until !== void 0) {
-			const parsed = Date.parse(input.until);
-			if (!Number.isFinite(parsed)) throw new BackgroundSessionCallerDenied("background.wait until must be an ISO 8601 timestamp");
-			wakeAt = new Date(parsed).toISOString();
-		}
-		return toSummary(requireState(await serial.run(async () => {
-			const state = await options.repository.get(sessionId);
-			if (!state) throw new BackgroundSessionCallerDenied(`background session not found: ${sessionId}`);
-			requireMatchingOrigin(state, input.context);
-			const nextState = suspendBackgroundSession(state, {
-				now,
-				...input.reason === void 0 ? {} : { reason: input.reason },
-				...wakeAt ? { wakeAt } : {}
-			});
-			return options.repository.update({
-				build: () => nextState,
-				expectedRevision: state.revision,
-				sessionId
-			});
-		}), sessionId));
-	};
-	const list = async (input) => {
-		return (await options.repository.list(input.phase === void 0 ? void 0 : { phase: input.phase })).filter((state) => matchesOrigin(state, input.context)).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, input.limit).map(toSummary);
-	};
-	const status = async (input) => {
-		return toDetail(await requireOwnedState(input.sessionId, input.context));
-	};
-	const send = async (input) => {
-		return toSummary(requireState(await serial.run(async () => {
-			const state = await requireOwnedState(input.sessionId, input.context);
-			const nextState = appendBackgroundSessionInput(state, {
-				message: input.message,
-				now: options.clock.now()
-			});
-			return options.repository.update({
-				build: () => nextState,
-				expectedRevision: state.revision,
-				sessionId: input.sessionId
-			});
-		}), input.sessionId));
-	};
-	const stop = async (input) => {
-		return toSummary(requireState(await serial.run(async () => {
-			const state = await requireOwnedState(input.sessionId, input.context);
-			const nextState = requestBackgroundSessionStop(state, {
-				now: options.clock.now(),
-				reason: input.reason ?? "stopped by conversation"
-			});
-			return updateAndEnqueueStopped(input.sessionId, state.revision, nextState);
-		}), input.sessionId));
-	};
-	const requireOwnedState = async (sessionId, context) => {
-		const state = await options.repository.get(sessionId);
-		if (!state) throw new BackgroundSessionCallerDenied(`background session not found: ${sessionId}`);
-		requireMatchingOrigin(state, context);
-		return state;
-	};
-	const updateAndEnqueueStopped = async (sessionId, expectedRevision, nextState) => {
-		const stored = await options.repository.update({
-			build: () => nextState,
-			expectedRevision,
-			sessionId
-		});
-		if (stored?.phase === "stopped") await options.deliveries.enqueue({
-			createdAt: options.clock.now(),
-			deliveryId: terminalDeliveryId(sessionId, "stopped"),
-			kind: "stopped",
-			sessionId,
-			text: stopNotice$1(stored)
-		});
-		return stored;
-	};
-	const resolveReconciliation = async (input) => {
-		return toSummary(requireState(await serial.run(async () => {
-			const state = await options.repository.get(input.sessionId);
-			if (!state) throw new BackgroundSessionCallerDenied(`background session not found: ${input.sessionId}`);
-			const nextState = resolveBackgroundSessionReconciliation(state, {
-				now: options.clock.now(),
-				outcome: input.outcome
-			});
-			return updateAndEnqueueStopped(input.sessionId, state.revision, nextState);
-		}), input.sessionId));
-	};
-	return {
-		list,
-		resolveReconciliation,
-		send,
-		start,
-		status,
-		stop,
-		wait
-	};
-}
-function sessionIdFromSessionKey(sessionKey) {
-	const prefix = `${createBackgroundSessionKey("")}`;
-	return sessionKey.startsWith(prefix) ? sessionKey.slice(prefix.length) : void 0;
-}
-function terminalDeliveryId(sessionId, kind) {
-	return `bg-final:${sessionId}:${kind}`;
-}
-function progressDeliveryId(sessionId, stepCount) {
-	return `bg-progress:${sessionId}:${stepCount}`;
-}
-function requireOrigin(context) {
-	if (!context.origin || !context.origin.endpointId || !context.origin.tenantKey) throw new BackgroundSessionCallerDenied("background tools require a trusted invocation origin; this run has none");
-	return context.origin;
-}
-function requireSourceMessageId(context) {
-	if (!context.sourceMessageId?.trim()) throw new BackgroundSessionCallerDenied("background.start requires a trusted source message id");
-	return context.sourceMessageId;
-}
-function requireMatchingOrigin(state, context) {
-	if (!matchesOrigin(state, context)) throw new BackgroundSessionCallerDenied("background session is not owned by this conversation");
-}
-function matchesOrigin(state, context) {
-	const origin = context.origin;
-	if (!origin) return false;
-	if (context.agentId !== state.authority.agentId) return false;
-	if (state.origin.endpointId !== origin.endpointId) return false;
-	if (state.origin.tenantKey !== origin.tenantKey) return false;
-	if ((state.origin.conversationId ?? void 0) !== (origin.conversationId ?? void 0)) return false;
-	return true;
-}
-function requireState(state, sessionId) {
-	if (!state) throw new BackgroundSessionCallerDenied(`background session not found: ${sessionId}`);
-	return state;
-}
-function toSummary(state) {
-	return {
-		createdAt: state.createdAt,
-		displayName: state.displayName,
-		phase: state.phase,
-		sessionId: state.sessionId,
-		stepCount: state.stepCount,
-		updatedAt: state.updatedAt,
-		...state.wakeAt ? { wakeAt: state.wakeAt } : {}
-	};
-}
-function toDetail(state) {
-	return {
-		...toSummary(state),
-		...state.cancellation ? { cancellationReason: state.cancellation.reason } : {},
-		...state.errorMessage ? { errorMessage: state.errorMessage } : {},
-		parentRunId: state.parentRunId,
-		pendingInput: state.pendingInput,
-		...state.reconciliationNote ? { reconciliationNote: state.reconciliationNote } : {},
-		...state.result ? { result: state.result } : {}
-	};
-}
-function stopNotice$1(state) {
-	return `后台会话「${state.displayName}」已停止。${state.cancellation ? `原因：${state.cancellation.reason}` : ""}`.trim();
-}
-//#endregion
-//#region src/modules/background-session/application/supervision/background-session-config.ts
-const DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS = 300 * 1e3;
-const DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS = 4;
-const DEFAULT_BACKGROUND_SESSION_LEASE_MS = 3e4;
-const DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS = 1e4;
-const DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES = 3;
-const DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS = 3e4;
-const DEFAULT_BACKGROUND_SESSION_LIFETIME_MS = 1440 * 60 * 1e3;
-const DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS = 1e3;
-function resolveBackgroundSessionSupervisorIntervalMs(leaseMs) {
-	return Math.min(5e3, Math.max(200, Math.floor(leaseMs / 10)));
-}
-//#endregion
-//#region src/modules/background-session/application/supervision/background-session-delivery-queue.ts
-function createBackgroundSessionDeliveryQueue(options) {
-	return {
-		drain: () => Effect.gen(function* () {
-			const records = yield* fromPromise$1(() => options.deliveries.pending());
-			yield* Effect.forEach(records, (record) => fromPromise$1(() => options.deliver(record)).pipe(Effect.flatMap(({ providerMessageId }) => fromPromise$1(() => options.deliveries.markDelivered(record.deliveryId, providerMessageId))), Effect.tap((delivered) => delivered ? Effect.sync(options.onDelivered) : Effect.void), Effect.catchAll((error) => options.onError === void 0 ? Effect.void : Effect.sync(() => options.onError?.(error))), Effect.asVoid), { discard: true });
-		}),
-		enqueue: (sessionId, kind, text, session) => {
-			if (text.trim() === "") return Effect.void;
-			const deliveryId = kind === "progress" ? progressDeliveryId(sessionId, session.stepCount) : terminalDeliveryId(sessionId, kind);
-			return fromPromise$1(() => options.deliveries.enqueue({
-				createdAt: options.clock.now(),
-				deliveryId,
-				kind,
-				sessionId,
-				text
-			})).pipe(Effect.asVoid);
-		}
-	};
-}
-function fromPromise$1(evaluate) {
-	return Effect.tryPromise({
-		catch: (error) => error,
-		try: evaluate
-	});
-}
-//#endregion
-//#region src/modules/background-session/application/supervision/background-session-error-policy.ts
-function isFencedBackgroundSessionOperationError(error) {
-	const message = backgroundSessionErrorMessage(error).toLowerCase();
-	return message.includes("fenced") || message.includes("reconciliation-required");
-}
-function isRetryableBackgroundSessionStepError(error) {
-	if (!(error instanceof Error)) return false;
-	if (error.name === "AgentRunCancelled") return true;
-	return error.name === "AgentHarnessBusy" || error.name === "AgentInstanceBusy";
-}
-function backgroundSessionErrorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-//#endregion
-//#region src/modules/background-session/application/supervision/background-session-supervisor-snapshot.ts
-async function readBackgroundSessionSupervisorSnapshot(repository, now) {
-	const counts = { ...emptyBackgroundSessionPhaseCounts() };
-	let oldestDueAt;
-	for (const session of await repository.list()) {
-		counts[session.phase] += 1;
-		if (!isBackgroundSessionDue(session, now)) continue;
-		const dueAt = session.wakeAt ?? session.createdAt;
-		if (oldestDueAt === void 0 || dueAt < oldestDueAt) oldestDueAt = dueAt;
-	}
-	return Object.freeze({
-		...oldestDueAt === void 0 ? {} : { oldestDueAt },
-		phaseCounts: Object.freeze(counts)
-	});
-}
-function emptyBackgroundSessionPhaseCounts() {
-	return Object.freeze({
-		completed: 0,
-		failed: 0,
-		"input-required": 0,
-		queued: 0,
-		"reconciliation-required": 0,
-		running: 0,
-		stopped: 0,
-		stopping: 0,
-		waiting: 0
-	});
-}
-//#endregion
-//#region src/modules/background-session/application/supervision/background-session-wake-prompt.ts
-function buildBackgroundSessionWakeText(session) {
-	if (session.wakeCount === 0) return `你在一个后台会话中开始工作。任务：\n${session.prompt}\n\n继续工作直到给出最终结果；如果必须等待外部变化或用户输入，调用 background.wait。`;
-	const parts = [`后台会话第 ${session.stepCount + 1} 步。任务：\n${session.prompt}`, "继续先前的工作（历史在会话记录中）。"];
-	if (session.pendingInput.length > 0) parts.push(`用户新的输入：\n${session.pendingInput.join("\n---\n")}`);
-	parts.push("完成后给出最终结果；需要等待时调用 background.wait。");
-	return parts.join("\n\n");
-}
-function buildInterruptedBackgroundSessionWakeText(session) {
-	return `你的上一步在后台会话中被守护进程重启打断，未产生确定的工具副作用（副作用由工具账本保护）。继续先前的工作（历史在会话记录中）。` + (session.pendingInput.length > 0 ? `\n\n用户新的输入：\n${session.pendingInput.join("\n---\n")}` : "");
-}
-//#endregion
-//#region src/modules/background-session/application/supervision/background-session-supervisor.ts
-function createBackgroundSessionSupervisor(options) {
-	const owner = `supervisor:${createRandomId()}`;
-	const inFlight = /* @__PURE__ */ new Map();
-	const stepControllers = /* @__PURE__ */ new Map();
-	const supervision = Effect.unsafeMakeSemaphore(1);
-	const counters = {
-		completed: 0,
-		deliveriesDelivered: 0,
-		failed: 0,
-		started: 0,
-		staleLeaseEventsDropped: 0,
-		stopped: 0
-	};
-	let repositoryHealthy = true;
-	let snapshot = emptyBackgroundSessionPhaseCounts();
-	let oldestDueAt;
-	const requeuedInPass = /* @__PURE__ */ new Set();
-	const deliveryQueue = createBackgroundSessionDeliveryQueue({
-		clock: options.clock,
-		deliver: options.deliver,
-		deliveries: options.deliveries,
-		onDelivered: () => {
-			counters.deliveriesDelivered += 1;
-		},
-		...options.onError === void 0 ? {} : { onError: options.onError }
-	});
-	const reportError = (error) => options.onError === void 0 ? Effect.void : Effect.sync(() => options.onError?.(error)).pipe(Effect.catchAllCause(() => Effect.void));
-	const repositoryGet = (sessionId) => fromPromise(() => options.repository.get(sessionId));
-	const repositoryList = () => fromPromise(() => options.repository.list());
-	const repositoryUpdate = (input) => Effect.uninterruptible(fromPromise(() => options.repository.update(input)));
-	const refreshSnapshot = () => fromPromise(() => readBackgroundSessionSupervisorSnapshot(options.repository, options.clock.now())).pipe(Effect.tap((latest) => Effect.sync(() => {
-		snapshot = latest.phaseCounts;
-		oldestDueAt = latest.oldestDueAt;
-	})), Effect.asVoid);
-	const completeStop = (state, expectedLease) => repositoryUpdate({
-		build: (current) => completeBackgroundSessionStop(current, { now: options.clock.now() }),
-		expectedLease,
-		expectedRevision: state.revision,
-		sessionId: state.sessionId
-	}).pipe(Effect.flatMap((stopped) => {
-		if (!stopped) return Effect.void;
-		counters.stopped += 1;
-		return deliveryQueue.enqueue(stopped.sessionId, "stopped", stopNotice(stopped), stopped);
-	}));
-	const resolveStaleLeases = () => Effect.gen(function* () {
-		const now = options.clock.now();
-		for (const session of yield* repositoryList()) {
-			if (session.lease === void 0 || inFlight.has(session.sessionId)) continue;
-			if (!(session.lease.owner !== owner || isBackgroundSessionLeaseExpired(session, now))) continue;
-			counters.staleLeaseEventsDropped += 1;
-			const expectedLease = {
-				kind: "held",
-				owner: session.lease.owner,
-				epoch: session.lease.epoch
-			};
-			if (session.phase === "running") {
-				yield* repositoryUpdate({
-					build: (state) => requeueInterruptedBackgroundSessionStep(state, {
-						now,
-						wakeText: buildInterruptedBackgroundSessionWakeText(state)
-					}),
-					expectedLease,
-					expectedRevision: session.revision,
-					sessionId: session.sessionId
-				});
-				requeuedInPass.add(session.sessionId);
-				continue;
-			}
-			if (session.phase === "stopping") {
-				yield* completeStop(session, expectedLease);
-				continue;
-			}
-			yield* repositoryUpdate({
-				build: (state) => releaseBackgroundSessionLease(state),
-				expectedLease,
-				expectedRevision: session.revision,
-				sessionId: session.sessionId
-			});
-		}
-	});
-	const expireLifetime = () => Effect.gen(function* () {
-		const now = options.clock.now();
-		const cutoff = Date.parse(now) - options.config.sessionLifetimeMs;
-		for (const session of yield* repositoryList()) {
-			if (isBackgroundSessionTerminalPhase(session.phase)) continue;
-			if (Date.parse(session.createdAt) > cutoff) continue;
-			const nextState = requestBackgroundSessionStop(session, {
-				now,
-				reason: "background session lifetime exceeded"
-			});
-			const stored = yield* repositoryUpdate({
-				build: () => nextState,
-				expectedRevision: session.revision,
-				sessionId: session.sessionId
-			});
-			if (stored?.phase === "stopped") {
-				counters.stopped += 1;
-				yield* deliveryQueue.enqueue(stored.sessionId, "stopped", stopNotice(stored), stored);
-			} else stepControllers.get(session.sessionId)?.abort(/* @__PURE__ */ new Error("background session lifetime exceeded"));
-		}
-	});
-	const stopStoppingSessions = () => Effect.gen(function* () {
-		for (const session of yield* repositoryList()) {
-			if (session.phase !== "stopping") continue;
-			if (inFlight.has(session.sessionId)) {
-				stepControllers.get(session.sessionId)?.abort(/* @__PURE__ */ new Error("background session stop requested"));
-				continue;
-			}
-			const expectedLease = session.lease ? {
-				kind: "held",
-				owner: session.lease.owner,
-				epoch: session.lease.epoch
-			} : { kind: "absent" };
-			yield* completeStop(session, expectedLease);
-		}
-	});
-	const requeueAfterInterruptedFiber = (sessionId, lease) => Effect.gen(function* () {
-		const current = yield* repositoryGet(sessionId);
-		if (!current) return;
-		const expectedLease = {
-			kind: "held",
-			owner: lease.owner,
-			epoch: lease.epoch
-		};
-		if (current.phase === "stopping") {
-			yield* completeStop(current, expectedLease);
-			return;
-		}
-		if (current.phase !== "running") return;
-		yield* repositoryUpdate({
-			build: (state) => requeueInterruptedBackgroundSessionStep(state, {
-				now: options.clock.now(),
-				wakeText: buildInterruptedBackgroundSessionWakeText(state)
-			}),
-			expectedLease,
-			expectedRevision: current.revision,
-			sessionId
-		});
-	}).pipe(Effect.catchAll((error) => reportError(error)), Effect.asVoid);
-	const renewLeaseOnce = (sessionId, lease, controller) => Effect.gen(function* () {
-		const current = yield* repositoryGet(sessionId);
-		if (!current || current.lease === void 0 || current.lease.owner !== owner || current.lease.epoch !== lease.epoch) {
-			controller.abort(/* @__PURE__ */ new Error("background session lease was lost"));
-			return false;
-		}
-		if (!(yield* repositoryUpdate({
-			build: (state) => renewBackgroundSessionLease(state, {
-				expiresAt: toIso(Date.parse(options.clock.now()) + options.config.leaseMs),
-				epoch: lease.epoch,
-				owner
-			}),
-			expectedLease: {
-				kind: "held",
-				owner,
-				epoch: lease.epoch
-			},
-			expectedRevision: current.revision,
-			sessionId
-		}))) {
-			controller.abort(/* @__PURE__ */ new Error("background session lease renewal was denied"));
-			return false;
-		}
-		return true;
-	});
-	const renewLease = (sessionId, lease, controller) => {
-		const cycle = Effect.suspend(() => options.sleep(options.config.leaseRenewalIntervalMs).pipe(Effect.flatMap(() => renewLeaseOnce(sessionId, lease, controller)), Effect.flatMap((renewed) => renewed ? cycle : Effect.void), Effect.catchAllCause((cause) => {
-			if (Cause.isInterruptedOnly(cause)) return Effect.interrupt;
-			controller.abort(/* @__PURE__ */ new Error(`background session lease renewal failed: ${backgroundSessionErrorMessage(Cause.squash(cause))}`));
-			return Effect.void;
-		})));
-		return cycle;
-	};
-	const requeueAfterFailedCommit = (sessionId, lease, error) => Effect.gen(function* () {
-		const current = yield* repositoryGet(sessionId);
-		if (!current || current.phase !== "running") return;
-		yield* repositoryUpdate({
-			build: (state) => requeueInterruptedBackgroundSessionStep(state, {
-				now: options.clock.now(),
-				wakeText: `步骤结果提交失败（${backgroundSessionErrorMessage(error)}），将重试`
-			}),
-			expectedLease: {
-				kind: "held",
-				owner: lease.owner,
-				epoch: lease.epoch
-			},
-			expectedRevision: current.revision,
-			sessionId
-		});
-	}).pipe(Effect.catchAll((commitError) => reportError(commitError)), Effect.asVoid);
-	const commitStep = (claimed, outcome, lease) => Effect.gen(function* () {
-		const now = options.clock.now();
-		const current = yield* repositoryGet(claimed.sessionId);
-		if (!current) return;
-		const expectedLease = {
-			kind: "held",
-			owner: lease.owner,
-			epoch: lease.epoch
-		};
-		if (current.phase === "waiting" || current.phase === "input-required") {
-			const text = outcome.ok ? outcome.result.finalText : "";
-			yield* repositoryUpdate({
-				build: (state) => releaseBackgroundSessionLease(state),
-				expectedLease,
-				expectedRevision: current.revision,
-				sessionId: current.sessionId
-			});
-			if (text.trim() !== "") yield* deliveryQueue.enqueue(current.sessionId, "progress", text, current);
-			return;
-		}
-		if (current.phase === "stopping") {
-			yield* completeStop(current, expectedLease);
-			return;
-		}
-		if (current.phase !== "running") return;
-		if (outcome.ok) {
-			const completed = yield* repositoryUpdate({
-				build: (state) => completeBackgroundSessionStep(state, {
-					now,
-					stepRunId: outcome.result.runId,
-					text: outcome.result.finalText
-				}),
-				expectedLease,
-				expectedRevision: current.revision,
-				sessionId: current.sessionId
-			});
-			if (completed) {
-				counters.completed += 1;
-				yield* deliveryQueue.enqueue(completed.sessionId, "final", completed.result?.text ?? "", completed);
-			}
-			return;
-		}
-		const errorMessage = backgroundSessionErrorMessage(outcome.error);
-		if (isFencedBackgroundSessionOperationError(outcome.error)) {
-			const parked = yield* repositoryUpdate({
-				build: (state) => parkBackgroundSessionForReconciliation(state, {
-					now,
-					reason: `step failed on a fenced operation: ${errorMessage}`
-				}),
-				expectedLease,
-				expectedRevision: current.revision,
-				sessionId: current.sessionId
-			});
-			if (parked) yield* deliveryQueue.enqueue(parked.sessionId, "reconciliation", `后台会话「${parked.displayName}」需要人工对账：${parked.reconciliationNote ?? errorMessage}`, parked);
-			return;
-		}
-		if (isRetryableBackgroundSessionStepError(outcome.error) && current.consecutiveFailures + 1 < options.config.maxConsecutiveFailures) {
-			const backoff = options.config.retryBackoffMs * 2 ** current.consecutiveFailures;
-			yield* repositoryUpdate({
-				build: (state) => failBackgroundSessionStep(state, {
-					errorMessage,
-					now,
-					retryable: true,
-					wakeAt: toIso(Date.parse(now) + backoff)
-				}),
-				expectedLease,
-				expectedRevision: current.revision,
-				sessionId: current.sessionId
-			});
-			return;
-		}
-		const failed = yield* repositoryUpdate({
-			build: (state) => failBackgroundSessionStep(state, {
-				errorMessage,
-				now,
-				retryable: false
-			}),
-			expectedLease,
-			expectedRevision: current.revision,
-			sessionId: current.sessionId
-		});
-		if (failed) {
-			counters.failed += 1;
-			yield* deliveryQueue.enqueue(failed.sessionId, "failed", `后台会话「${failed.displayName}」失败：${failed.errorMessage ?? errorMessage}`, failed);
-		}
-	});
-	const runStep = (session) => Effect.gen(function* () {
-		const now = options.clock.now();
-		const stepCount = session.stepCount + 1;
-		const wakeText = requeuedInPass.has(session.sessionId) ? buildInterruptedBackgroundSessionWakeText(session) : buildBackgroundSessionWakeText(session);
-		requeuedInPass.delete(session.sessionId);
-		const lease = {
-			epoch: (session.lease?.epoch ?? 0) + 1,
-			expiresAt: toIso(Date.parse(now) + options.config.leaseMs),
-			owner
-		};
-		const claimed = yield* repositoryUpdate({
-			build: (state) => claimBackgroundSession(state, {
-				lease,
-				now,
-				stepRunId: `bg-step:${session.sessionId}:${stepCount}`,
-				wakeText
-			}),
-			expectedLease: { kind: "absent-or-stale" },
-			expectedRevision: session.revision,
-			now,
-			sessionId: session.sessionId
-		});
-		if (!claimed) return;
-		counters.started += 1;
-		const controller = new AbortController();
-		stepControllers.set(session.sessionId, controller);
-		yield* Effect.gen(function* () {
-			const outcome = yield* Effect.acquireUseRelease(Effect.fork(renewLease(session.sessionId, lease, controller).pipe(Effect.interruptible)), () => fromPromise(() => options.runStep({
-				session: claimed,
-				signal: controller.signal,
-				wakeText
-			})).pipe(Effect.match({
-				onFailure: (error) => ({
-					error,
-					ok: false
-				}),
-				onSuccess: (result) => ({
-					ok: true,
-					result
-				})
-			})), (fiber) => Fiber.interrupt(fiber).pipe(Effect.asVoid));
-			yield* Effect.uninterruptible(commitStep(claimed, outcome, lease).pipe(Effect.catchAll((error) => reportError(error).pipe(Effect.flatMap(() => requeueAfterFailedCommit(session.sessionId, lease, error))))));
-		}).pipe(Effect.onInterrupt(() => Effect.sync(() => controller.abort(/* @__PURE__ */ new Error("background session supervisor is stopping"))).pipe(Effect.flatMap(() => requeueAfterInterruptedFiber(session.sessionId, lease)))), Effect.ensuring(Effect.sync(() => {
-			stepControllers.delete(session.sessionId);
-		})));
-	});
-	const startStep = (session) => Effect.gen(function* () {
-		const gate = yield* Deferred.make();
-		const fiber = yield* Effect.forkDaemon(Deferred.await(gate).pipe(Effect.flatMap(() => runStep(session)), Effect.catchAllCause((cause) => Cause.isInterruptedOnly(cause) ? Effect.void : reportError(Cause.squash(cause))), Effect.ensuring(Effect.sync(() => {
-			inFlight.delete(session.sessionId);
-		}))));
-		inFlight.set(session.sessionId, fiber);
-		yield* Deferred.succeed(gate, void 0);
-	}).pipe(Effect.uninterruptible);
-	const startDueSessions = () => Effect.gen(function* () {
-		const now = options.clock.now();
-		for (const session of yield* repositoryList()) {
-			if (inFlight.size >= options.config.maxConcurrentSessions) break;
-			if (inFlight.has(session.sessionId)) continue;
-			if (!isBackgroundSessionDue(session, now)) continue;
-			if (session.lease !== void 0 && !isBackgroundSessionLeaseExpired(session, now)) continue;
-			yield* startStep(session);
-		}
-	});
-	const supervisionPass = () => Effect.gen(function* () {
-		yield* resolveStaleLeases();
-		yield* expireLifetime();
-		yield* stopStoppingSessions();
-		yield* deliveryQueue.drain();
-		yield* startDueSessions();
-		yield* refreshSnapshot();
-		repositoryHealthy = true;
-	}).pipe(Effect.tapError(() => Effect.sync(() => {
-		repositoryHealthy = false;
-	})), Effect.orDie);
-	const tick = () => supervision.withPermits(1)(supervisionPass());
-	const loop = createPeriodicEffectLoop({
-		intervalMs: options.config.intervalMs,
-		onError: (error) => {
-			options.onError?.(error);
-		},
-		run: tick,
-		sleep: options.sleep
-	});
-	const statusOf = () => Object.freeze({
-		capacity: options.config.maxConcurrentSessions,
-		counters: Object.freeze({ ...counters }),
-		inFlightSteps: inFlight.size,
-		...oldestDueAt === void 0 ? {} : { oldestDueAt },
-		owner,
-		phaseCounts: snapshot,
-		reconciliationCount: snapshot["reconciliation-required"],
-		repositoryHealthy,
-		running: loop.running()
-	});
-	return {
-		recover: tick,
-		start: () => Effect.sync(() => loop.start()),
-		status: statusOf,
-		stop: () => Effect.gen(function* () {
-			yield* fromPromise(() => loop.stop());
-			for (const controller of stepControllers.values()) controller.abort(/* @__PURE__ */ new Error("background session supervisor is stopping"));
-			yield* Effect.forEach(inFlight.values(), (fiber) => Fiber.interrupt(fiber), { discard: true });
-		}).pipe(Effect.orDie),
-		tick
-	};
-}
-function fromPromise(evaluate) {
-	return Effect.tryPromise({
-		catch: (error) => error,
-		try: evaluate
-	});
-}
-function toIso(timeMs) {
-	return new Date(timeMs).toISOString();
-}
-function stopNotice(session) {
-	return `后台会话「${session.displayName}」已停止。${session.cancellation ? `原因：${session.cancellation.reason}` : ""}`.trim();
-}
-//#endregion
-export { createBackgroundSessionStepSourceMessageId as $, resolveBackgroundSessionReconciliation as A, readBackgroundSessionString as B, isBackgroundSessionDue as C, renewBackgroundSessionLease as D, releaseBackgroundSessionLease as E, createBackgroundSessionControl as F, BACKGROUND_SESSION_TOOL_VERSION as G, BACKGROUND_SESSION_START_TOOL_ID as H, toControlContext as I, extendBackgroundSessionDefinition as J, backgroundSessionToolIds as K, readBackgroundSessionInteger as L, BackgroundSessionTransitionDenied as M, isBackgroundSessionTerminalPhase as N, requestBackgroundSessionStop as O, BackgroundSessionControlError as P, createBackgroundSessionKey as Q, readBackgroundSessionObject as R, failBackgroundSessionStep as S, parkBackgroundSessionForReconciliation as T, BACKGROUND_SESSION_TOOL_IDS as U, readBackgroundSessionWaitInput as V, BACKGROUND_SESSION_TOOL_PLUGIN_ID as W, narrowBackgroundSessionDefinition as X, isBackgroundSessionToolId as Y, BACKGROUND_SESSION_SESSION_KEY_PREFIX as Z, appendBackgroundSessionInput as _, DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS as a, completeBackgroundSessionStop as b, DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS as c, BackgroundSessionCallerDenied as d, createEffectLoopDriver as et, createBackgroundSessionService as f, createSerialExecutor as g, terminalDeliveryId as h, DEFAULT_BACKGROUND_SESSION_LIFETIME_MS as i, suspendBackgroundSession as j, requeueInterruptedBackgroundSessionStep as k, DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS as l, sessionIdFromSessionKey as m, DEFAULT_BACKGROUND_SESSION_LEASE_MS as n, DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES as o, progressDeliveryId as p, createBackgroundSessionToolContracts as q, DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS as r, DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS as s, createBackgroundSessionSupervisor as t, createPeriodicEffectLoop as tt, resolveBackgroundSessionSupervisorIntervalMs as u, claimBackgroundSession as v, isBackgroundSessionLeaseExpired as w, createBackgroundSession as x, completeBackgroundSessionStep as y, readBackgroundSessionPhase as z };