@rivus/agent 0.6.2 → 0.7.0

package/dist/index.js

@@ -1,13 +1,13 @@
 import { a as createAgentLoopSkillExecutionStart, c as createAgentLoopToolExecutionEnd, d as createAsyncIterableAgentLoop, f as createEventAgentLoop, i as createAgentLoopSkillExecutionEnd, l as createAgentLoopToolExecutionStart, m as createTextAgentLoopFromCallback, n as createAgentLoopModelExecutionEnd, o as createAgentLoopTextDelta, p as createTextAgentLoop, r as createAgentLoopModelExecutionStart, s as createAgentLoopThinkingDelta, t as createAgentLoopFromCallback, u as createAgentLoopToolExecutionUpdate } from "./agent-loop.js";
 import { a as createMemoryNamespace, c as InvalidRivusPlugin, d as requiresToolApproval, i as RIVUS_MEMORY_TOOL_VERSION, l as RIVUS_PLUGIN_API_VERSION, n as RIVUS_MEMORY_TOOL_ID, o as createRivusMemoryToolContract, r as RIVUS_MEMORY_TOOL_PLUGIN_ID, s as restrictMemoryScopesForAudience, t as MEMORY_SCOPES, u as RivusToolInputRejected } from "./agent-memory.js";
-import { n as resolveRivusAgentDefinition, t as createRivusPluginCatalog } from "./rivus-plugin-registry.js";
-import { A as CardPresentationTransitionDenied, B as FeishuEndpointCredentialError, C as loadRivusDaemonConfig, D as loadRivusDeploymentManifest, E as RivusDeploymentManifestError, F as completeCardPresentationHandoff, G as validateRivusDeploymentManifest, I as createCardPresentationChain, L as failCardPresentationHandoff, M as activeCardPresentation, N as beginCardPresentationHandoff, O as DEFAULT_CARD_STREAM_LEASE_MS, P as compensateCardPresentationHandoff, R as isCardPresentationHandoffDue, S as RivusDaemonConfigError, U as RivusPluginLoadError, V as resolveFeishuEndpointCredentials, W as loadRivusDeployment, _ as createStableId, a as InvalidRivusProjectSpace, b as createRivusEnvFromOpenClawConfig, c as RivusDeploymentReadinessError, d as createRivusAgentHost, f as AgentInstanceBusy, g as createAgentInstanceRegistry, h as AgentInstanceConflict, i as resolveRivusProjectSpace, j as acceptsCardPresentationProgress, k as createFeishuCardRollover, l as createRivusDeploymentDaemon, m as createAgentRuntimePool, n as createRivusDeploymentCliProcess, o as RivusDeploymentAutomationReadinessError, p as AgentRuntimeDisposed, r as createConfiguredRivusDeploymentDaemon, s as RivusDeploymentDaemonLifecycleError, t as runRivusDaemonCli, u as InvalidRivusEndpointBinding, v as createRivusDaemonShutdownController, w as loadNodeRivusPluginModule, x as formatRivusEnvFile, y as OpenClawEnvImportError, z as markCardPresentationTerminal } from "./rivus-daemon-cli.js";
+import { a as BACKGROUND_SESSION_START_TOOL_ID, c as BACKGROUND_SESSION_TOOL_VERSION, d as createBackgroundSessionStepSourceMessageId, f as createBackgroundSessionToolContracts, h as narrowBackgroundSessionDefinition, i as BACKGROUND_SESSION_SESSION_KEY_PREFIX, l as backgroundSessionToolIds, m as isBackgroundSessionToolId, n as resolveRivusAgentDefinition, o as BACKGROUND_SESSION_TOOL_IDS, p as extendBackgroundSessionDefinition, s as BACKGROUND_SESSION_TOOL_PLUGIN_ID, t as createRivusPluginCatalog, u as createBackgroundSessionKey } from "./rivus-plugin-registry.js";
+import { $ as loadRivusDeployment, A as DEFAULT_BACKGROUND_SESSION_LIFETIME_MS, B as acceptsCardPresentationProgress, C as loadRivusDaemonConfig, D as loadRivusDeploymentManifest, E as RivusDeploymentManifestError, F as DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS, G as createCardPresentationChain, H as beginCardPresentationHandoff, I as resolveBackgroundSessionSupervisorIntervalMs, J as markCardPresentationTerminal, K as failCardPresentationHandoff, L as DEFAULT_CARD_STREAM_LEASE_MS, M as DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES, N as DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS, O as DEFAULT_BACKGROUND_SESSION_LEASE_MS, P as DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS, Q as RivusPluginLoadError, R as createFeishuCardRollover, S as RivusDaemonConfigError, U as compensateCardPresentationHandoff, V as activeCardPresentation, W as completeCardPresentationHandoff, X as resolveFeishuEndpointCredentials, Y as FeishuEndpointCredentialError, _ as createStableId, a as InvalidRivusProjectSpace, b as createRivusEnvFromOpenClawConfig, c as RivusDeploymentReadinessError, d as createRivusAgentHost, et as validateRivusDeploymentManifest, f as AgentInstanceBusy, g as createAgentInstanceRegistry, h as AgentInstanceConflict, i as resolveRivusProjectSpace, j as DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS, k as DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS, l as createRivusDeploymentDaemon, m as createAgentRuntimePool, n as createRivusDeploymentCliProcess, o as RivusDeploymentAutomationReadinessError, p as AgentRuntimeDisposed, q as isCardPresentationHandoffDue, r as createConfiguredRivusDeploymentDaemon, s as RivusDeploymentDaemonLifecycleError, t as runRivusDaemonCli, u as InvalidRivusEndpointBinding, v as createRivusDaemonShutdownController, w as loadNodeRivusPluginModule, x as formatRivusEnvFile, y as OpenClawEnvImportError, z as CardPresentationTransitionDenied } from "./rivus-daemon-cli.js";
 import { a as InvalidInvocationAuthority, i as normalizeStableJson, n as InvalidToolInput, o as createInvocationAuthority, r as createToolInputDigest, s as resolveInvocationAuthority, t as InvalidStableJson } from "./tool-input-digest.js";
 import { n as assertRivusPluginConforms, r as createFakeRivusPlugin, t as RivusPluginConformanceError } from "./rivus-plugin-testkit.js";
 import { Cause, Deferred, Effect, Either, Exit, Fiber, Option, Stream } from "effect";
 import { createHash, randomUUID } from "node:crypto";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { appendFile, lstat, mkdir, readFile, readdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { appendFile, lstat, mkdir, readFile, readdir, realpath, rename, stat, truncate, unlink, writeFile } from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import { createServer } from "node:http";
 import { Buffer as Buffer$1 } from "node:buffer";
@@ -3443,36 +3443,36 @@ function parseAgentDomainEvent(value, lineNumber) {
 	switch (value.type) {
 		case "agent_run_accepted": return {
 			occurredAt,
-			prompt: readString(value, "prompt", lineNumber),
-			runId: readString(value, "runId", lineNumber),
-			sessionKey: readString(value, "sessionKey", lineNumber),
+			prompt: readString$1(value, "prompt", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
+			sessionKey: readString$1(value, "sessionKey", lineNumber),
 			type: value.type
 		};
 		case "agent_turn_started": return {
 			occurredAt,
-			runId: readString(value, "runId", lineNumber),
-			sessionKey: readString(value, "sessionKey", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
+			sessionKey: readString$1(value, "sessionKey", lineNumber),
 			type: value.type
 		};
 		case "assistant_text_delta": return {
-			delta: readString(value, "delta", lineNumber),
+			delta: readString$1(value, "delta", lineNumber),
 			occurredAt,
-			runId: readString(value, "runId", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
 			type: value.type
 		};
 		case "assistant_thinking_delta": return {
-			delta: readString(value, "delta", lineNumber),
+			delta: readString$1(value, "delta", lineNumber),
 			occurredAt,
-			runId: readString(value, "runId", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
 			type: value.type
 		};
 		case "agent_model_execution_started": return {
-			api: readString(value, "api", lineNumber),
-			model: readString(value, "model", lineNumber),
-			modelCallId: readString(value, "modelCallId", lineNumber),
+			api: readString$1(value, "api", lineNumber),
+			model: readString$1(value, "model", lineNumber),
+			modelCallId: readString$1(value, "modelCallId", lineNumber),
 			occurredAt,
-			provider: readString(value, "provider", lineNumber),
-			runId: readString(value, "runId", lineNumber),
+			provider: readString$1(value, "provider", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
 			type: value.type
 		};
 		case "agent_model_execution_ended": {
@@ -3481,15 +3481,15 @@ function parseAgentDomainEvent(value, lineNumber) {
 			const responseModel = readOptionalString(value, "responseModel", lineNumber);
 			const reasoning = readOptionalNumber(usage, "reasoning", lineNumber);
 			return {
-				api: readString(value, "api", lineNumber),
+				api: readString$1(value, "api", lineNumber),
 				...errorMessage ? { errorMessage } : {},
-				model: readString(value, "model", lineNumber),
-				modelCallId: readString(value, "modelCallId", lineNumber),
+				model: readString$1(value, "model", lineNumber),
+				modelCallId: readString$1(value, "modelCallId", lineNumber),
 				occurredAt,
-				provider: readString(value, "provider", lineNumber),
+				provider: readString$1(value, "provider", lineNumber),
 				...responseModel ? { responseModel } : {},
-				runId: readString(value, "runId", lineNumber),
-				stopReason: readString(value, "stopReason", lineNumber),
+				runId: readString$1(value, "runId", lineNumber),
+				stopReason: readString$1(value, "stopReason", lineNumber),
 				type: value.type,
 				usage: {
 					cacheRead: readNumber(usage, "cacheRead", lineNumber),
@@ -3519,10 +3519,10 @@ function parseAgentDomainEvent(value, lineNumber) {
 			} : {
 				...common,
 				contentLength: readNumber(value, "contentLength", lineNumber),
-				digest: readString(value, "digest", lineNumber),
+				digest: readString$1(value, "digest", lineNumber),
 				isError: false,
-				title: readString(value, "title", lineNumber),
-				version: readString(value, "version", lineNumber)
+				title: readString$1(value, "title", lineNumber),
+				version: readString$1(value, "version", lineNumber)
 			};
 		}
 		case "agent_tool_execution_started": return {
@@ -3546,21 +3546,21 @@ function parseAgentDomainEvent(value, lineNumber) {
 			type: value.type
 		};
 		case "agent_turn_completed": return {
-			finalText: readString(value, "finalText", lineNumber),
+			finalText: readString$1(value, "finalText", lineNumber),
 			occurredAt,
-			runId: readString(value, "runId", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
 			type: value.type
 		};
 		case "agent_run_completed": return {
-			finalText: readString(value, "finalText", lineNumber),
+			finalText: readString$1(value, "finalText", lineNumber),
 			occurredAt,
-			runId: readString(value, "runId", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
 			type: value.type
 		};
 		case "agent_run_failed": return {
-			errorMessage: readString(value, "errorMessage", lineNumber),
+			errorMessage: readString$1(value, "errorMessage", lineNumber),
 			occurredAt,
-			runId: readString(value, "runId", lineNumber),
+			runId: readString$1(value, "runId", lineNumber),
 			type: value.type
 		};
 		case "agent_run_cancelled": {
@@ -3568,7 +3568,7 @@ function parseAgentDomainEvent(value, lineNumber) {
 			return {
 				occurredAt,
 				...reason ? { reason } : {},
-				runId: readString(value, "runId", lineNumber),
+				runId: readString$1(value, "runId", lineNumber),
 				type: value.type
 			};
 		}
@@ -3577,19 +3577,19 @@ function parseAgentDomainEvent(value, lineNumber) {
 }
 function readSkillExecutionIdentity(value, lineNumber) {
 	return {
-		runId: readString(value, "runId", lineNumber),
-		skillCallId: readString(value, "skillCallId", lineNumber),
-		skillId: readString(value, "skillId", lineNumber)
+		runId: readString$1(value, "runId", lineNumber),
+		skillCallId: readString$1(value, "skillCallId", lineNumber),
+		skillId: readString$1(value, "skillId", lineNumber)
 	};
 }
 function readToolExecutionIdentity(value, lineNumber) {
 	return {
-		runId: readString(value, "runId", lineNumber),
-		toolCallId: readString(value, "toolCallId", lineNumber),
-		toolName: readString(value, "toolName", lineNumber)
+		runId: readString$1(value, "runId", lineNumber),
+		toolCallId: readString$1(value, "toolCallId", lineNumber),
+		toolName: readString$1(value, "toolName", lineNumber)
 	};
 }
-function readString(value, field, lineNumber) {
+function readString$1(value, field, lineNumber) {
 	const fieldValue = value[field];
 	if (typeof fieldValue !== "string") throw new Error(`Invalid agent event field '${field}' at line ${lineNumber}.`);
 	return fieldValue;
@@ -4760,7 +4760,7 @@ function unwrapResult(value) {
 }
 function presentResult(toolName, value) {
 	if (isTruncated(value)) return "结果过长，已省略。";
-	if (!isRecord(value)) return truncate(presentValue(value) ?? "工具执行完成。", 2e3);
+	if (!isRecord(value)) return truncate$1(presentValue(value) ?? "工具执行完成。", 2e3);
 	const tool = resolveTool(toolName);
 	const orderedKeys = tool.fields?.map(([key]) => key) ?? [];
 	const lines = Object.entries(value).sort(([left], [right]) => {
@@ -4772,7 +4772,7 @@ function presentResult(toolName, value) {
 		const presented = presentValue(item, field?.[2]);
 		return presented ? [`${clean(field?.[1] ?? humanizeKey(key), 80)}：${presented}`] : [];
 	}).slice(0, 12);
-	return truncate(lines.length > 0 ? lines.join("\n") : "工具执行完成。", 2e3);
+	return truncate$1(lines.length > 0 ? lines.join("\n") : "工具执行完成。", 2e3);
 }
 function presentValue(value, unit) {
 	if (value === REDACTED || value === TRUNCATED || value === void 0) return void 0;
@@ -4796,9 +4796,9 @@ function humanizeKey(key) {
 	return `${text.slice(0, 1).toUpperCase()}${text.slice(1)}` || "结果";
 }
 function clean(value, maxLength) {
-	return truncate(value.replace(/[\p{Cc}\p{Cf}]+/gu, " ").replace(/\s+/gu, " ").trim(), maxLength);
+	return truncate$1(value.replace(/[\p{Cc}\p{Cf}]+/gu, " ").replace(/\s+/gu, " ").trim(), maxLength);
 }
-function truncate(value, maxLength) {
+function truncate$1(value, maxLength) {
 	return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}…`;
 }
 function isRecord(value) {
@@ -5346,7 +5346,14 @@ function createToolBroker(options) {
 			runId: authority.runId,
 			sessionKey: authority.sessionKey,
 			toolId: tool.id,
-			toolVersion: tool.version
+			toolVersion: tool.version,
+			...authority.endpointId ? { origin: Object.freeze({
+				...authority.allowedActorOpenIds ? { allowedActorOpenIds: authority.allowedActorOpenIds } : { allowedActorOpenIds: Object.freeze([]) },
+				endpointId: authority.endpointId,
+				tenantKey: authority.tenantKey,
+				...authority.conversationId ? { conversationId: authority.conversationId } : {}
+			}) } : {},
+			...authority.sourceMessageId ? { sourceMessageId: authority.sourceMessageId } : {}
 		});
 		const replayCompleted = (result) => "replayCompleted" in tool && tool.replayCompleted ? tool.replayCompleted(request.input, result, context) : result;
 		if (request.operationId) {
@@ -5881,6 +5888,1483 @@ function isVisibleMemory(record) {
 	return record.scope !== "shared-user-profile" && record.scope !== "project" || record.state === "confirmed";
 }
 //#endregion
+//#region src/domain/background-agent-session.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;
+	}
+};
+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);
+}
+function isValidBackgroundSessionTransition(previous, nextState) {
+	if (nextState.sessionId !== previous.sessionId) return "session id must not change";
+	if (nextState.revision !== previous.revision + 1) return "revision must increase by exactly one";
+	if (nextState.authority.agentId !== previous.authority.agentId) return "authority agent must not change";
+	if (nextState.authority.profileRevision !== previous.authority.profileRevision) return "authority profile revision must not change";
+	if (nextState.authority.toolGrantRevision !== previous.authority.toolGrantRevision) return "authority tool grant revision must not change";
+	if (nextState.authority.sessionKey !== previous.authority.sessionKey) return "authority session key must not change";
+	if (nextState.origin.endpointId !== previous.origin.endpointId) return "origin endpoint must not change";
+	if (nextState.origin.tenantKey !== previous.origin.tenantKey) return "origin tenant must not change";
+	if (nextState.origin.conversationId !== previous.origin.conversationId) return "origin conversation must not change";
+	if (nextState.parentRunId !== previous.parentRunId) return "parent run must not change";
+	if (nextState.sourceMessageId !== previous.sourceMessageId) return "source message must not change";
+	if (nextState.prompt !== previous.prompt) return "prompt must not change";
+	if (nextState.stepCount < previous.stepCount) return "step count must not decrease";
+	if (nextState.wakeCount < previous.wakeCount) return "wake count must not decrease";
+	if (nextState.consecutiveFailures < previous.consecutiveFailures) {
+		if (previous.consecutiveFailures > 0 && nextState.phase === "completed" && nextState.consecutiveFailures === 0) return;
+		return "failure count must not decrease";
+	}
+	if (nextState.createdAt !== previous.createdAt) return "created time must not change";
+	if (previous.phase === "running") {
+		if (nextState.phase === "running") return holdsSameLease(previous, nextState) ? void 0 : "running lease owner or epoch must not change";
+		if (nextState.phase === "waiting" || nextState.phase === "input-required") return holdsSameLease(previous, nextState) ? void 0 : "suspension requires the same lease";
+		if (nextState.phase === "completed" && nextState.result !== void 0 && nextState.lease === void 0) return;
+		if (nextState.phase === "failed" && nextState.errorMessage !== void 0 && nextState.lease === void 0) return;
+		if (nextState.phase === "stopping" && nextState.cancellation !== void 0) return void 0;
+		if (nextState.phase === "reconciliation-required" && nextState.lease === void 0) return void 0;
+		if (nextState.phase === "queued" && nextState.lease === void 0 && nextState.wakeAt !== void 0) return;
+		return `running session cannot transition to ${nextState.phase}`;
+	}
+	if (previous.phase === "stopping") {
+		if (nextState.phase === "stopped" && nextState.lease === void 0 && nextState.cancellation !== void 0) return;
+		if (nextState.phase === "reconciliation-required" && nextState.lease === void 0) return void 0;
+		return `stopping session cannot transition to ${nextState.phase}`;
+	}
+	if (previous.phase === "queued") {
+		if (nextState.phase === "running" && nextState.lease !== void 0) return void 0;
+		if (nextState.phase === "queued" && nextState.lease === void 0 && nextState.wakeAt === previous.wakeAt) return;
+		if (nextState.phase === "stopped" && nextState.lease === void 0) return void 0;
+		if (nextState.phase === "reconciliation-required" && nextState.lease === void 0) return void 0;
+		return `queued session cannot transition to ${nextState.phase}`;
+	}
+	if (previous.phase === "waiting") {
+		if (nextState.phase === "running" && nextState.lease !== void 0) return void 0;
+		if (nextState.phase === "waiting" && nextState.lease === void 0 && nextState.wakeAt === previous.wakeAt) return;
+		if (nextState.phase === "queued" && nextState.wakeAt !== void 0) return void 0;
+		if (nextState.phase === "stopped" && nextState.lease === void 0) return void 0;
+		if (nextState.phase === "reconciliation-required" && nextState.lease === void 0) return void 0;
+		return `waiting session cannot transition to ${nextState.phase}`;
+	}
+	if (previous.phase === "input-required") {
+		if (nextState.phase === "input-required" && nextState.lease === void 0) return void 0;
+		if (nextState.phase === "queued" && nextState.wakeAt !== void 0) return void 0;
+		if (nextState.phase === "stopped" && nextState.lease === void 0) return void 0;
+		if (nextState.phase === "reconciliation-required" && nextState.lease === void 0) return void 0;
+		return `input-required session cannot transition to ${nextState.phase}`;
+	}
+	if (isBackgroundSessionTerminalPhase(previous.phase)) {
+		if (previous.phase === "reconciliation-required") {
+			if (nextState.phase !== "queued" && nextState.phase !== "stopped") return "reconciliation-required session can only continue or stop";
+			return;
+		}
+		return `terminal ${previous.phase} session cannot transition`;
+	}
+}
+function holdsSameLease(previous, nextState) {
+	return nextState.lease !== void 0 && previous.lease !== void 0 && nextState.lease.owner === previous.lease.owner && nextState.lease.epoch === previous.lease.epoch;
+}
+//#endregion
+//#region src/application/background-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/application/background-session/background-session-repository.ts
+var BackgroundSessionRepositoryConflict = class extends Error {
+	name = "BackgroundSessionRepositoryConflict";
+	constructor(sessionId, message) {
+		super(`${sessionId}: ${message}`);
+	}
+};
+var BackgroundSessionRepositoryCorrupted = class extends Error {
+	name = "BackgroundSessionRepositoryCorrupted";
+};
+function createBackgroundSessionRepository(options = {}) {
+	const serial = createSerialExecutor();
+	const states = /* @__PURE__ */ new Map();
+	for (const state of options.initial ?? []) states.set(state.sessionId, structuredClone(state));
+	const persist = async (state) => {
+		if (options.persist) await options.persist(state);
+	};
+	return {
+		create: (state) => serial.run(async () => {
+			if (states.has(state.sessionId)) throw new BackgroundSessionRepositoryConflict(state.sessionId, "duplicate background session id");
+			states.set(state.sessionId, structuredClone(state));
+			await persist(state);
+			return structuredClone(state);
+		}),
+		get: (sessionId) => serial.run(async () => {
+			const state = states.get(sessionId);
+			return state ? structuredClone(state) : void 0;
+		}),
+		list: (options) => serial.run(async () => {
+			let results = [...states.values()];
+			if (options?.phase !== void 0) results = results.filter((state) => state.phase === options.phase);
+			results.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+			if (options?.limit !== void 0) results = results.slice(0, options.limit);
+			return results.map((state) => structuredClone(state));
+		}),
+		update: (input) => serial.run(async () => {
+			const previous = states.get(input.sessionId);
+			if (!previous) return void 0;
+			if (previous.revision !== input.expectedRevision) throw new BackgroundSessionRepositoryConflict(input.sessionId, `revision conflict: expected ${input.expectedRevision}, found ${previous.revision}`);
+			if (input.expectedLease !== void 0) {
+				const leaseMismatch = leaseConflict(input.sessionId, previous.lease, input.expectedLease, input.now);
+				if (leaseMismatch) throw new BackgroundSessionRepositoryConflict(input.sessionId, leaseMismatch);
+			}
+			const nextState = input.build(previous);
+			const invalid = isValidBackgroundSessionTransition(previous, nextState);
+			if (invalid) throw new BackgroundSessionRepositoryConflict(input.sessionId, `invalid transition: ${invalid}`);
+			states.set(input.sessionId, structuredClone(nextState));
+			await persist(nextState);
+			return structuredClone(nextState);
+		})
+	};
+}
+function leaseConflict(_sessionId, lease, expected, now) {
+	if (expected.kind === "absent") {
+		if (lease !== void 0) return `lease conflict: expected no lease, found owner ${lease.owner} epoch ${lease.epoch}`;
+		return;
+	}
+	if (expected.kind === "absent-or-stale") {
+		if (lease !== void 0 && !isExpired(lease, now)) return `lease conflict: expected absent or stale lease, found live lease owner ${lease.owner} epoch ${lease.epoch}`;
+		return;
+	}
+	if (lease === void 0 || lease.owner !== expected.owner || lease.epoch !== expected.epoch) return `lease conflict: expected owner ${expected.owner} epoch ${expected.epoch}`;
+}
+function isExpired(lease, now) {
+	return lease !== void 0 && lease.expiresAt <= (now ?? (/* @__PURE__ */ new Date()).toISOString());
+}
+//#endregion
+//#region src/application/background-session/background-session-delivery-store.ts
+var BackgroundSessionDeliveryConflict = class extends Error {
+	name = "BackgroundSessionDeliveryConflict";
+	constructor(deliveryId, message) {
+		super(`${deliveryId}: ${message}`);
+	}
+};
+function createBackgroundSessionDeliveryStore(options = {}) {
+	const serial = createSerialExecutor();
+	const records = /* @__PURE__ */ new Map();
+	for (const record of options.initial ?? []) records.set(record.deliveryId, structuredClone(record));
+	const persist = async (record) => {
+		if (options.persist) await options.persist(record);
+	};
+	return {
+		enqueue: (input) => serial.run(async () => {
+			const existing = records.get(input.deliveryId);
+			if (existing) return structuredClone(existing);
+			const record = {
+				createdAt: input.createdAt,
+				deliveryId: input.deliveryId,
+				kind: input.kind,
+				revision: 1,
+				sessionId: input.sessionId,
+				state: "pending",
+				text: input.text
+			};
+			records.set(input.deliveryId, structuredClone(record));
+			await persist(record);
+			return structuredClone(record);
+		}),
+		pending: () => serial.run(async () => {
+			return [...records.values()].filter((record) => record.state === "pending").sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map((record) => structuredClone(record));
+		}),
+		markDelivered: (deliveryId, providerMessageId) => serial.run(async () => {
+			const previous = records.get(deliveryId);
+			if (!previous) return void 0;
+			if (previous.state !== "pending") return structuredClone(previous);
+			const nextState = {
+				...previous,
+				providerMessageId,
+				revision: previous.revision + 1,
+				state: "delivered"
+			};
+			records.set(deliveryId, structuredClone(nextState));
+			await persist(nextState);
+			return structuredClone(nextState);
+		})
+	};
+}
+//#endregion
+//#region src/application/background-session/background-session-supervisor.ts
+function createBackgroundSessionSupervisor(options) {
+	const owner = `supervisor:${randomUUID()}`;
+	const inFlight = /* @__PURE__ */ new Map();
+	const stepControllers = /* @__PURE__ */ new Map();
+	const counters = {
+		completed: 0,
+		deliveriesDelivered: 0,
+		failed: 0,
+		started: 0,
+		staleLeaseEventsDropped: 0,
+		stopped: 0
+	};
+	let repositoryHealthy = true;
+	let snapshot = emptyPhaseCounts();
+	let oldestDueAt;
+	const requeuedInPass = /* @__PURE__ */ new Set();
+	const refreshSnapshot = async () => {
+		const counts = {
+			completed: 0,
+			failed: 0,
+			"input-required": 0,
+			queued: 0,
+			"reconciliation-required": 0,
+			running: 0,
+			stopped: 0,
+			stopping: 0,
+			waiting: 0
+		};
+		let oldest;
+		const now = options.clock.now();
+		for (const session of await options.repository.list()) {
+			counts[session.phase] += 1;
+			if (isBackgroundSessionDue(session, now)) {
+				const dueAt = session.wakeAt ?? session.createdAt;
+				if (oldest === void 0 || dueAt < oldest) oldest = dueAt;
+			}
+		}
+		snapshot = Object.freeze(counts);
+		oldestDueAt = oldest;
+	};
+	const supervisionPass = async () => {
+		try {
+			await resolveStaleLeases();
+			await expireLifetime();
+			await stopStoppingSessions();
+			await drainDeliveries();
+			await startDueSessions();
+			await refreshSnapshot();
+			repositoryHealthy = true;
+		} catch (error) {
+			repositoryHealthy = false;
+			throw error;
+		}
+	};
+	const resolveStaleLeases = async () => {
+		const now = options.clock.now();
+		for (const session of await options.repository.list()) {
+			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") {
+				await options.repository.update({
+					build: (state) => requeueInterruptedBackgroundSessionStep(state, {
+						now,
+						wakeText: interruptedStepWakeText(state)
+					}),
+					expectedLease,
+					expectedRevision: session.revision,
+					sessionId: session.sessionId
+				});
+				requeuedInPass.add(session.sessionId);
+				continue;
+			}
+			if (session.phase === "stopping") {
+				await completeStop(session, expectedLease);
+				continue;
+			}
+			await options.repository.update({
+				build: (state) => releaseBackgroundSessionLease(state),
+				expectedLease,
+				expectedRevision: session.revision,
+				sessionId: session.sessionId
+			});
+		}
+	};
+	const expireLifetime = async () => {
+		const now = options.clock.now();
+		const cutoff = Date.parse(now) - options.config.sessionLifetimeMs;
+		for (const session of await options.repository.list()) {
+			if (isBackgroundSessionTerminalPhase(session.phase)) continue;
+			if (Date.parse(session.createdAt) > cutoff) continue;
+			const nextState = requestBackgroundSessionStop(session, {
+				now,
+				reason: "background session lifetime exceeded"
+			});
+			const stored = await options.repository.update({
+				build: () => nextState,
+				expectedRevision: session.revision,
+				sessionId: session.sessionId
+			});
+			if (stored?.phase === "stopped") {
+				counters.stopped += 1;
+				await enqueueDelivery(stored.sessionId, "stopped", stopNotice(stored), stored);
+			} else stepControllers.get(session.sessionId)?.abort(/* @__PURE__ */ new Error("background session lifetime exceeded"));
+		}
+	};
+	const stopStoppingSessions = async () => {
+		for (const session of await options.repository.list()) {
+			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" };
+			await completeStop(session, expectedLease);
+		}
+	};
+	const completeStop = async (state, expectedLease) => {
+		const stopped = await options.repository.update({
+			build: (current) => completeBackgroundSessionStop(current, { now: options.clock.now() }),
+			expectedLease,
+			expectedRevision: state.revision,
+			sessionId: state.sessionId
+		});
+		if (stopped) {
+			counters.stopped += 1;
+			await enqueueDelivery(stopped.sessionId, "stopped", stopNotice(stopped), stopped);
+		}
+	};
+	const startDueSessions = async () => {
+		const now = options.clock.now();
+		for (const session of await options.repository.list()) {
+			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;
+			const step = runStep(session).finally(() => {
+				inFlight.delete(session.sessionId);
+			});
+			inFlight.set(session.sessionId, step);
+			step.catch((error) => {
+				options.onError?.(error);
+			});
+		}
+	};
+	const runStep = async (session) => {
+		const now = options.clock.now();
+		const stepCount = session.stepCount + 1;
+		const wakeText = requeuedInPass.has(session.sessionId) ? interruptedStepWakeText(session) : buildWakeText(session);
+		requeuedInPass.delete(session.sessionId);
+		const lease = {
+			epoch: (session.lease?.epoch ?? 0) + 1,
+			expiresAt: toIso(Date.parse(now) + options.config.leaseMs),
+			owner
+		};
+		const claimed = await options.repository.update({
+			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);
+		let outcome;
+		try {
+			let settled = false;
+			const renewal = (async () => {
+				while (!settled) {
+					await Effect.runPromise(options.sleep(options.config.leaseRenewalIntervalMs)).catch(() => void 0);
+					if (settled) break;
+					try {
+						const current = await options.repository.get(session.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"));
+							break;
+						}
+						if (!await options.repository.update({
+							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: session.sessionId
+						})) controller.abort(/* @__PURE__ */ new Error("background session lease renewal was denied"));
+					} catch {
+						controller.abort(/* @__PURE__ */ new Error("background session lease renewal failed"));
+					}
+				}
+			})();
+			outcome = await options.runStep({
+				session: claimed,
+				signal: controller.signal,
+				wakeText
+			}).then((result) => ({
+				ok: true,
+				result
+			}), (error) => ({
+				error,
+				ok: false
+			}));
+			settled = true;
+			renewal.catch(() => void 0);
+		} finally {
+			stepControllers.delete(session.sessionId);
+		}
+		try {
+			await commitStep(claimed, outcome, lease);
+		} catch (error) {
+			options.onError?.(error);
+			await requeueAfterFailedCommit(session.sessionId, lease, error);
+		}
+	};
+	const requeueAfterFailedCommit = async (sessionId, lease, error) => {
+		try {
+			const current = await options.repository.get(sessionId);
+			if (!current || current.phase !== "running") return;
+			await options.repository.update({
+				build: (state) => requeueInterruptedBackgroundSessionStep(state, {
+					now: options.clock.now(),
+					wakeText: `步骤结果提交失败（${errorMessageOf(error)}），将重试`
+				}),
+				expectedLease: {
+					kind: "held",
+					owner: lease.owner,
+					epoch: lease.epoch
+				},
+				expectedRevision: current.revision,
+				sessionId
+			});
+		} catch (commitError) {
+			options.onError?.(commitError);
+		}
+	};
+	const commitStep = async (claimed, outcome, lease) => {
+		const now = options.clock.now();
+		const current = await options.repository.get(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 : "";
+			await options.repository.update({
+				build: (state) => releaseBackgroundSessionLease(state),
+				expectedLease,
+				expectedRevision: current.revision,
+				sessionId: current.sessionId
+			});
+			if (text.trim() !== "") await enqueueDelivery(current.sessionId, "progress", text, current);
+			return;
+		}
+		if (current.phase === "stopping") {
+			await completeStop(current, expectedLease);
+			return;
+		}
+		if (current.phase !== "running") return;
+		if (outcome.ok) {
+			const completed = await options.repository.update({
+				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;
+				await enqueueDelivery(completed.sessionId, "final", completed.result?.text ?? "", completed);
+			}
+			return;
+		}
+		const errorMessage = errorMessageOf(outcome.error);
+		if (isFencedOperationError(outcome.error)) {
+			const parked = await options.repository.update({
+				build: (state) => parkBackgroundSessionForReconciliation(state, {
+					now,
+					reason: `step failed on a fenced operation: ${errorMessage}`
+				}),
+				expectedLease,
+				expectedRevision: current.revision,
+				sessionId: current.sessionId
+			});
+			if (parked) await enqueueDelivery(parked.sessionId, "reconciliation", `后台会话「${parked.displayName}」需要人工对账：${parked.reconciliationNote ?? errorMessage}`, parked);
+			return;
+		}
+		if (isRetryableStepError(outcome.error) && current.consecutiveFailures + 1 < options.config.maxConsecutiveFailures) {
+			const backoff = options.config.retryBackoffMs * 2 ** current.consecutiveFailures;
+			await options.repository.update({
+				build: (state) => failBackgroundSessionStep(state, {
+					errorMessage,
+					now,
+					retryable: true,
+					wakeAt: toIso(Date.parse(now) + backoff)
+				}),
+				expectedLease,
+				expectedRevision: current.revision,
+				sessionId: current.sessionId
+			});
+			return;
+		}
+		const failed = await options.repository.update({
+			build: (state) => failBackgroundSessionStep(state, {
+				errorMessage,
+				now,
+				retryable: false
+			}),
+			expectedLease,
+			expectedRevision: current.revision,
+			sessionId: current.sessionId
+		});
+		if (failed) {
+			counters.failed += 1;
+			await enqueueDelivery(failed.sessionId, "failed", `后台会话「${failed.displayName}」失败：${failed.errorMessage ?? errorMessage}`, failed);
+		}
+	};
+	const drainDeliveries = async () => {
+		const pending = await options.deliveries.pending();
+		for (const record of pending) try {
+			const { providerMessageId } = await options.deliver(record);
+			if (await options.deliveries.markDelivered(record.deliveryId, providerMessageId)) counters.deliveriesDelivered += 1;
+		} catch (error) {
+			options.onError?.(error);
+		}
+	};
+	const enqueueDelivery = async (sessionId, kind, text, session) => {
+		if (text.trim() === "") return;
+		const deliveryId = kind === "progress" ? progressDeliveryId(sessionId, session.stepCount) : terminalDeliveryId(sessionId, kind);
+		await options.deliveries.enqueue({
+			createdAt: options.clock.now(),
+			deliveryId,
+			kind,
+			sessionId,
+			text
+		});
+	};
+	const buildWakeText = (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");
+	};
+	const interruptedStepWakeText = (session) => `你的上一步在后台会话中被守护进程重启打断，未产生确定的工具副作用（副作用由工具账本保护）。继续先前的工作（历史在会话记录中）。` + (session.pendingInput.length > 0 ? `\n\n用户新的输入：\n${session.pendingInput.join("\n---\n")}` : "");
+	const tick = () => Effect.promise(() => 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.promise(async () => {
+			for (const controller of stepControllers.values()) controller.abort(/* @__PURE__ */ new Error("background session supervisor is stopping"));
+			await Promise.allSettled(inFlight.values());
+			await loop.stop();
+		}),
+		tick
+	};
+}
+function isFencedOperationError(error) {
+	const message = errorMessageOf(error).toLowerCase();
+	return message.includes("fenced") || message.includes("reconciliation-required");
+}
+function isRetryableStepError(error) {
+	if (!(error instanceof Error)) return false;
+	if (error.name === "AgentRunCancelled") return true;
+	if (error.name === "AgentHarnessBusy" || error.name === "AgentInstanceBusy") return true;
+	return false;
+}
+function errorMessageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function toIso(timeMs) {
+	return new Date(timeMs).toISOString();
+}
+function stopNotice(session) {
+	return `后台会话「${session.displayName}」已停止。${session.cancellation ? `原因：${session.cancellation.reason}` : ""}`.trim();
+}
+function emptyPhaseCounts() {
+	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/application/background-session/background-session-tools.ts
+function createBackgroundSessionHostTools(options) {
+	const contracts = createBackgroundSessionToolContracts();
+	const executors = new Map(contracts.map((contract) => [contract.id, createExecutor(contract, options)]));
+	return contracts.map((contract) => Object.freeze({
+		...contract,
+		createExecutor: () => ({ execute: (input, context) => asToolInputRejection$1(() => executors.get(contract.id)(input, context)) }),
+		replayCompleted: (input, completedResult, context) => asToolInputRejection$1(() => replayCompleted(contract.id, input, completedResult, context, options))
+	}));
+}
+function createExecutor(contract, options) {
+	switch (contract.id) {
+		case "background.start": return (input, context) => {
+			const { prompt, displayName } = readObject(input, ["prompt", "displayName"]);
+			if (typeof prompt !== "string" || prompt.trim() === "") throw new BackgroundSessionCallerDenied("background.start requires a non-empty prompt");
+			if (displayName !== void 0 && typeof displayName !== "string") throw new BackgroundSessionCallerDenied("background.start displayName must be a string");
+			const sessionId = options.createSessionId();
+			return options.service.start({
+				authority: buildAuthority(options.definition, context, sessionId),
+				context,
+				sessionId,
+				...displayName === void 0 ? {} : { displayName },
+				prompt
+			});
+		};
+		case "background.wait": return (input, context) => {
+			const { delayMs, reason, until } = readObject(input, [
+				"delayMs",
+				"reason",
+				"until"
+			]);
+			return options.service.wait({
+				context,
+				...delayMs === void 0 ? {} : { delayMs: readInteger(delayMs, "delayMs") },
+				...reason === void 0 ? {} : { reason: readString(reason, "reason") },
+				...until === void 0 ? {} : { until: readString(until, "until") }
+			});
+		};
+		case "background.list": return async (input, context) => {
+			const { limit, phase } = readObject(input, ["limit", "phase"]);
+			return { sessions: await options.service.list({
+				context,
+				...limit === void 0 ? {} : { limit: readInteger(limit, "limit") },
+				...phase === void 0 ? {} : { phase: readPhase(phase) }
+			}) };
+		};
+		case "background.status": return (input, context) => {
+			const { sessionId } = readObject(input, ["sessionId"]);
+			return options.service.status({
+				context,
+				sessionId: readString(sessionId, "sessionId")
+			});
+		};
+		case "background.send": return (input, context) => {
+			const { message, sessionId } = readObject(input, ["message", "sessionId"]);
+			return options.service.send({
+				context,
+				message: readString(message, "message"),
+				sessionId: readString(sessionId, "sessionId")
+			});
+		};
+		case "background.stop": return (input, context) => {
+			const { reason, sessionId } = readObject(input, ["reason", "sessionId"]);
+			return options.service.stop({
+				context,
+				...reason === void 0 ? {} : { reason: readString(reason, "reason") },
+				sessionId: readString(sessionId, "sessionId")
+			});
+		};
+		default: throw new BackgroundSessionCallerDenied(`unknown background tool: ${contract.id}`);
+	}
+}
+function replayCompleted(toolId, input, completedResult, context, options) {
+	switch (toolId) {
+		case "background.start": {
+			const sessionId = readReplayedSessionId(completedResult);
+			return options.service.status({
+				context,
+				sessionId
+			});
+		}
+		case "background.wait": return completedResult;
+		case "background.list": return completedResult;
+		case "background.status": {
+			const sessionId = readReplayedSessionId(input);
+			return options.service.status({
+				context,
+				sessionId
+			});
+		}
+		case "background.send": {
+			const sessionId = readReplayedSessionId(input);
+			return options.service.status({
+				context,
+				sessionId
+			});
+		}
+		case "background.stop": {
+			const sessionId = readReplayedSessionId(input);
+			return options.service.status({
+				context,
+				sessionId
+			});
+		}
+		default: return completedResult;
+	}
+}
+function buildAuthority(definition, context, sessionId) {
+	return Object.freeze({
+		agentId: definition.agentId,
+		memoryScopes: definition.memory.scopes,
+		policyEpoch: context.policyEpoch,
+		profileRevision: definition.profileRevision,
+		...definition.projectSpaceId === void 0 ? {} : { projectSpaceId: definition.projectSpaceId },
+		sessionKey: createBackgroundSessionKey(sessionId),
+		toolGrantRevision: definition.toolGrantSet.revision
+	});
+}
+function readObject(input, allowed) {
+	if (input === null || typeof input !== "object" || Array.isArray(input)) throw new BackgroundSessionCallerDenied("background tool input must be an object");
+	const record = input;
+	const unknown = Object.keys(record).find((key) => !allowed.includes(key));
+	if (unknown) throw new BackgroundSessionCallerDenied(`field is not allowed: ${unknown}`);
+	return record;
+}
+function readString(value, name) {
+	if (typeof value !== "string" || value.trim() === "") throw new BackgroundSessionCallerDenied(`${name} must be a non-empty string`);
+	return value;
+}
+function readInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new BackgroundSessionCallerDenied(`${name} must be a positive integer`);
+	return value;
+}
+function readPhase(value) {
+	const phases = [
+		"queued",
+		"running",
+		"waiting",
+		"input-required",
+		"stopping",
+		"stopped",
+		"completed",
+		"failed",
+		"reconciliation-required"
+	];
+	if (typeof value !== "string" || !phases.includes(value)) throw new BackgroundSessionCallerDenied(`phase must be one of ${phases.join(", ")}`);
+	return value;
+}
+function readReplayedSessionId(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new BackgroundSessionCallerDenied("replayed background tool result is invalid");
+	return readString(value.sessionId, "sessionId");
+}
+async function asToolInputRejection$1(operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (error instanceof BackgroundSessionCallerDenied || error instanceof BackgroundSessionTransitionDenied) throw new RivusToolInputRejected(error.message);
+		throw error;
+	}
+}
+//#endregion
+//#region src/infrastructure/persistence/jsonl-snapshot-store.ts
+var JsonlSnapshotStoreCorrupted = class extends Error {
+	name = "JsonlSnapshotStoreCorrupted";
+};
+async function loadJsonlSnapshotStore(options) {
+	const raw = await readPersistenceFile(options.filePath);
+	if (raw === void 0) return [];
+	const lines = raw.split("\n");
+	const latest = /* @__PURE__ */ new Map();
+	let lineCount = 0;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		if (!line.trim()) continue;
+		lineCount += 1;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			if (index === lines.length - 1) {
+				await truncateAtLine(options.filePath, lines, index);
+				break;
+			}
+			throw new JsonlSnapshotStoreCorrupted(`${options.errorLabel} JSONL at line ${index + 1} is not valid JSON`);
+		}
+		if (!isRecord$4(parsed) || parsed.version !== options.version) throw new JsonlSnapshotStoreCorrupted(`unsupported ${options.errorLabel} version at line ${index + 1}`);
+		if (isRecord$4(parsed.snapshot)) {
+			if (!Array.isArray(parsed.snapshot.records)) throw new JsonlSnapshotStoreCorrupted(`invalid ${options.errorLabel} snapshot at line ${index + 1}`);
+			latest.clear();
+			for (const value of parsed.snapshot.records) {
+				if (!options.isRecord(value)) throw new JsonlSnapshotStoreCorrupted(`invalid ${options.errorLabel} snapshot at line ${index + 1}`);
+				latest.set(options.keyOf(value), structuredClone(value));
+			}
+			continue;
+		}
+		if (!options.isRecord(parsed.record)) throw new JsonlSnapshotStoreCorrupted(`invalid ${options.errorLabel} record at line ${index + 1}`);
+		const record = parsed.record;
+		const previous = latest.get(options.keyOf(record));
+		const invalid = options.validateSequence(previous, record, index + 1);
+		if (invalid) throw new JsonlSnapshotStoreCorrupted(`invalid ${options.errorLabel} ${invalid} at line ${index + 1}`);
+		latest.set(options.keyOf(record), structuredClone(record));
+	}
+	if (lineCount >= options.compactThreshold) await writeJsonlSnapshot(options.filePath, options.version, [...latest.values()]);
+	return [...latest.values()];
+}
+async function appendJsonlRecord(filePath, version, record) {
+	await mkdir(dirname(filePath), { recursive: true });
+	await appendFile(filePath, `${JSON.stringify({
+		record,
+		version
+	})}\n`, "utf8");
+}
+async function writeJsonlSnapshot(filePath, version, records) {
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, `${JSON.stringify({
+		snapshot: { records },
+		version
+	})}\n`, "utf8");
+}
+async function truncateAtLine(filePath, lines, lineIndex) {
+	let offset = 0;
+	for (let index = 0; index < lineIndex; index += 1) offset += (lines[index] ?? "").length + 1;
+	await truncate(filePath, offset);
+}
+//#endregion
+//#region src/infrastructure/persistence/jsonl-background-session-repository.ts
+const BACKGROUND_SESSION_JSONL_VERSION = 1;
+async function openJsonlBackgroundSessionRepository(options) {
+	return createBackgroundSessionRepository({
+		initial: await loadJsonlSnapshotStore({
+			compactThreshold: options.compactThreshold ?? 5e3,
+			errorLabel: "background session",
+			filePath: options.filePath,
+			isRecord: isBackgroundSessionState,
+			keyOf: (record) => record.sessionId,
+			validateSequence: validateSessionSequence,
+			version: 1
+		}),
+		persist: (record) => appendJsonlRecord(options.filePath, 1, record)
+	});
+}
+function validateSessionSequence(previous, record, _lineNumber) {
+	if (previous === void 0) {
+		if (record.revision !== 1 || record.phase !== "queued") return "first record";
+		return;
+	}
+	if (record.revision !== previous.revision + 1) return "revision";
+	return isValidBackgroundSessionTransition(previous, record);
+}
+function isBackgroundSessionState(value) {
+	if (!isRecord$4(value)) return false;
+	const phases = [
+		"queued",
+		"running",
+		"waiting",
+		"input-required",
+		"stopping",
+		"stopped",
+		"completed",
+		"failed",
+		"reconciliation-required"
+	];
+	if (typeof value.sessionId !== "string" || value.sessionId.trim() === "") return false;
+	if (typeof value.displayName !== "string") return false;
+	if (!phases.includes(value.phase)) return false;
+	if (!Number.isInteger(value.revision) || value.revision < 1) return false;
+	if (typeof value.parentRunId !== "string" || value.parentRunId.trim() === "") return false;
+	if (typeof value.sourceMessageId !== "string" || value.sourceMessageId.trim() === "") return false;
+	if (!isRecord$4(value.origin)) return false;
+	const origin = value.origin;
+	if (typeof origin.endpointId !== "string" || origin.endpointId.trim() === "") return false;
+	if (typeof origin.tenantKey !== "string") return false;
+	if (!Array.isArray(origin.allowedActorOpenIds) || origin.allowedActorOpenIds.some((id) => typeof id !== "string")) return false;
+	if (origin.conversationId !== void 0 && typeof origin.conversationId !== "string") return false;
+	if (origin.memory !== void 0 && !isRecord$4(origin.memory)) return false;
+	if (!isRecord$4(value.authority)) return false;
+	const authority = value.authority;
+	if (typeof authority.agentId !== "string" || authority.agentId.trim() === "") return false;
+	if (typeof authority.profileRevision !== "string" || authority.profileRevision.trim() === "") return false;
+	if (typeof authority.toolGrantRevision !== "string" || authority.toolGrantRevision.trim() === "") return false;
+	if (!Number.isInteger(authority.policyEpoch) || authority.policyEpoch < 0) return false;
+	if (!Array.isArray(authority.memoryScopes) || authority.memoryScopes.some((scope) => typeof scope !== "string")) return false;
+	if (typeof authority.sessionKey !== "string" || authority.sessionKey.trim() === "") return false;
+	if (authority.projectSpaceId !== void 0 && typeof authority.projectSpaceId !== "string") return false;
+	if (typeof value.prompt !== "string") return false;
+	if (!Number.isInteger(value.stepCount) || value.stepCount < 0) return false;
+	if (!Number.isInteger(value.wakeCount) || value.wakeCount < 0) return false;
+	if (!Number.isInteger(value.consecutiveFailures) || value.consecutiveFailures < 0) return false;
+	if (!Array.isArray(value.pendingInput) || value.pendingInput.some((entry) => typeof entry !== "string")) return false;
+	if (value.currentStepRunId !== void 0 && typeof value.currentStepRunId !== "string") return false;
+	if (value.lastWakeText !== void 0 && typeof value.lastWakeText !== "string") return false;
+	if (value.wakeAt !== void 0 && typeof value.wakeAt !== "string") return false;
+	if (value.errorMessage !== void 0 && typeof value.errorMessage !== "string") return false;
+	if (value.reconciliationNote !== void 0 && typeof value.reconciliationNote !== "string") return false;
+	if (typeof value.createdAt !== "string" || !isIso(value.createdAt)) return false;
+	if (typeof value.updatedAt !== "string" || !isIso(value.updatedAt)) return false;
+	if (value.lease !== void 0 && !isLease(value.lease)) return false;
+	if (value.cancellation !== void 0) {
+		if (!isRecord$4(value.cancellation)) return false;
+		if (typeof value.cancellation.reason !== "string" || !isIso(value.cancellation.requestedAt)) return false;
+	}
+	if (value.result !== void 0) {
+		if (!isRecord$4(value.result)) return false;
+		if (typeof value.result.text !== "string" || typeof value.result.stepRunId !== "string" || !isIso(value.result.completedAt)) return false;
+	}
+	return true;
+}
+function isLease(value) {
+	if (!isRecord$4(value)) return false;
+	return typeof value.owner === "string" && value.owner.trim() !== "" && Number.isInteger(value.epoch) && value.epoch >= 0 && isIso(value.expiresAt);
+}
+function isIso(value) {
+	return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+//#endregion
+//#region src/infrastructure/persistence/jsonl-background-session-delivery-store.ts
+const BACKGROUND_SESSION_DELIVERY_JSONL_VERSION = 1;
+async function openJsonlBackgroundSessionDeliveryStore(options) {
+	return createBackgroundSessionDeliveryStore({
+		initial: await loadJsonlSnapshotStore({
+			compactThreshold: options.compactThreshold ?? 2e3,
+			errorLabel: "background session delivery",
+			filePath: options.filePath,
+			isRecord: isDeliveryRecord,
+			keyOf: (record) => record.deliveryId,
+			validateSequence: validateDeliverySequence,
+			version: 1
+		}),
+		persist: (record) => appendJsonlRecord(options.filePath, 1, record)
+	});
+}
+function validateDeliverySequence(previous, record, _lineNumber) {
+	if (previous === void 0) return record.revision === 1 && record.state === "pending" ? void 0 : "first record";
+	if (record.revision !== previous.revision + 1) return "revision";
+	return previous.state === "pending" && record.state === "delivered" ? void 0 : "transition";
+}
+function isDeliveryRecord(value) {
+	if (!isRecord$4(value)) return false;
+	if (typeof value.deliveryId !== "string" || value.deliveryId.trim() === "" || typeof value.sessionId !== "string" || value.sessionId.trim() === "") return false;
+	if (typeof value.kind !== "string" || ![
+		"progress",
+		"final",
+		"stopped",
+		"failed",
+		"reconciliation"
+	].includes(value.kind)) return false;
+	if (typeof value.text !== "string") return false;
+	if (value.state !== "pending" && value.state !== "delivered") return false;
+	if (!Number.isInteger(value.revision) || value.revision < 1) return false;
+	if (value.providerMessageId !== void 0 && typeof value.providerMessageId !== "string") return false;
+	return typeof value.createdAt === "string" && Number.isFinite(Date.parse(value.createdAt));
+}
+//#endregion
+//#region src/infrastructure/feishu/feishu-interactive-card-send.ts
+function sendFeishuInteractiveCard(client, request, errorMessage) {
+	return Effect.gen(function* () {
+		const response = yield* client.request(request, errorMessage);
+		const providerMessageId = readMessageId(response.body.data);
+		if (!providerMessageId) return yield* Effect.fail(new FeishuOpenApiError(response.status, response.body.code, "Feishu send response missing message_id"));
+		return Object.freeze({ providerMessageId });
+	});
+}
+function readMessageId(data) {
+	if (data === null || typeof data !== "object" || Array.isArray(data)) return void 0;
+	const value = data.message_id;
+	return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+//#endregion
+//#region src/infrastructure/feishu/feishu-background-session-delivery.ts
+function createConfiguredFeishuBackgroundSessionDelivery(options) {
+	const baseUrl = options.config.feishu.baseUrl.replace(/\/$/, "");
+	return { deliver: (input) => Effect.runPromise(sendFeishuInteractiveCard(options.client, {
+		body: {
+			content: JSON.stringify(createBackgroundSessionCard(input)),
+			msg_type: "interactive",
+			receive_id: input.chatId,
+			uuid: deliveryUuid$1(input.deliveryId)
+		},
+		method: "POST",
+		url: `${baseUrl}/open-apis/im/v1/messages?receive_id_type=chat_id`
+	}, "Feishu background session delivery failed")) };
+}
+function createBackgroundSessionCard(input) {
+	const title = cardTitle(input.kind);
+	const headerTemplate = cardHeaderTemplate(input.kind);
+	return {
+		body: { elements: [
+			{
+				content: `**${escapeCardText(title)}** · ${escapeCardText(input.displayName)}`,
+				tag: "markdown"
+			},
+			{
+				content: input.text,
+				tag: "markdown"
+			},
+			{
+				content: `会话 ${escapeCardText(input.sessionId)} · _由 Rivus 后台会话生成_`,
+				tag: "markdown"
+			}
+		] },
+		config: { update_multi: true },
+		header: {
+			template: headerTemplate,
+			title: {
+				content: title,
+				tag: "plain_text"
+			}
+		},
+		schema: "2.0"
+	};
+}
+function cardTitle(kind) {
+	switch (kind) {
+		case "progress": return "后台会话进展";
+		case "final": return "后台会话完成";
+		case "failed": return "后台会话失败";
+		case "stopped": return "后台会话已停止";
+		case "reconciliation": return "后台会话需对账";
+	}
+}
+function cardHeaderTemplate(kind) {
+	switch (kind) {
+		case "final": return "green";
+		case "failed":
+		case "reconciliation": return "red";
+		case "stopped": return "orange";
+		case "progress": return "blue";
+	}
+}
+function escapeCardText(value) {
+	return value.replace(/([*_~`|<>])/g, "\\$1");
+}
+function deliveryUuid$1(deliveryId) {
+	return `rivus-${createHash("sha256").update(`background-session:${deliveryId}`).digest("hex").slice(0, 32)}`;
+}
+//#endregion
 //#region src/application/memory/rivus-memory-tool.ts
 function createRivusMemoryTool(memory) {
 	const handles = Array.isArray(memory) ? [...memory] : [memory];
@@ -7051,21 +8535,16 @@ function createConfiguredFeishuTextReplySender(options) {
 //#region src/infrastructure/feishu/feishu-automation-card-sender.ts
 function createConfiguredFeishuAutomationCardSender(options) {
 	const baseUrl = options.config.feishu.baseUrl.replace(/\/$/, "");
-	return { send: (input) => Effect.gen(function* () {
-		const response = yield* options.client.request({
-			body: {
-				content: JSON.stringify(createAutomationCard(input.markdown)),
-				msg_type: "interactive",
-				receive_id: input.receiveId,
-				uuid: deliveryUuid(input.idempotencyKey)
-			},
-			method: "POST",
-			url: `${baseUrl}/open-apis/im/v1/messages?receive_id_type=${encodeURIComponent(input.receiveIdType)}`
-		}, "Feishu send failed");
-		const providerMessageId = readMessageId(response.body.data);
-		if (!providerMessageId) return yield* Effect.fail(new FeishuOpenApiError(response.status, response.body.code, "Feishu send response missing message_id"));
-		return Object.freeze({ providerMessageId });
-	}) };
+	return { send: (input) => sendFeishuInteractiveCard(options.client, {
+		body: {
+			content: JSON.stringify(createAutomationCard(input.markdown)),
+			msg_type: "interactive",
+			receive_id: input.receiveId,
+			uuid: deliveryUuid(input.idempotencyKey)
+		},
+		method: "POST",
+		url: `${baseUrl}/open-apis/im/v1/messages?receive_id_type=${encodeURIComponent(input.receiveIdType)}`
+	}, "Feishu send failed") };
 }
 function createAutomationCard(markdown) {
 	const presentation = splitPresentation(markdown);
@@ -7104,11 +8583,6 @@ function splitPresentation(markdown) {
 function deliveryUuid(idempotencyKey) {
 	return `rivus-${createHash("sha256").update(idempotencyKey).digest("hex").slice(0, 32)}`;
 }
-function readMessageId(data) {
-	if (data === null || typeof data !== "object" || Array.isArray(data)) return void 0;
-	const value = data.message_id;
-	return typeof value === "string" && value.trim() !== "" ? value : void 0;
-}
 //#endregion
 //#region src/application/interaction/human-interaction-repository.ts
 var HumanInteractionRepositoryError = class extends Error {
@@ -7462,4 +8936,4 @@ function validateDecisionInput(input) {
 	if (input.recommendedOptionId && !optionIds.includes(input.recommendedOptionId)) throw new Error("recommended user decision option must be available");
 }
 //#endregion
-export { AgentContextBudgetExceeded, AgentEventHandlerFailed, AgentEventLogStoreError, AgentEventSinkFailed, AgentHarnessBusy, AgentInstanceBusy, AgentInstanceConflict, AgentLoopFailed, AgentMemoryError, AgentRunCancelled, AgentRuntimeDisposed, AutomationMandateError, CardPresentationTransitionDenied, CompactionError, DEFAULT_CARD_STREAM_LEASE_MS, DelegationDenied, DeliveryOutboxError, FeishuCardPresentationNotFound, FeishuCardTargetNotFound, FeishuCardTargetRegistryStoreError, FeishuCotProtocolError, FeishuEndpointCredentialError, FeishuOpenApiError, FeishuTenantAccessTokenError, HumanInteractionRepositoryError, HumanInteractionTransitionDenied, InvalidFeishuCardAction, InvalidFeishuMessageContent, InvalidFeishuSessionReference, InvalidInvocationAuthority, InvalidProjectSkillCatalog, InvalidRecoveryAction, InvalidRivusEndpointBinding, InvalidRivusPlugin, InvalidRivusProjectSpace, InvalidStableJson, InvalidToolInput, InvalidWorkspaceRoot, LangfuseTelemetryConfigError, MEMORY_SCOPES, OpenClawEnvImportError, PluginStateConflict, RIVUS_MEMORY_TOOL_ID, RIVUS_MEMORY_TOOL_PLUGIN_ID, RIVUS_MEMORY_TOOL_VERSION, RIVUS_PLUGIN_API_VERSION, RivusDaemonConfigError, RivusDeploymentAutomationReadinessError, RivusDeploymentDaemonLifecycleError, RivusDeploymentManifestError, RivusDeploymentReadinessError, RivusPluginConformanceError, RivusPluginLoadError, RivusToolInputRejected, SessionSchedulerCapacityExceeded, SessionSchedulerDisposed, ToolInvocationDenied, UnsupportedFeishuCardAction, UnsupportedFeishuMessage, WorkspaceInstructionsSourceError, acceptsCardPresentationProgress, activeCardPresentation, assembleAgentContext, assertRivusPluginConforms, commitAutomationOutcome, createAgentCommandFromFeishuCardAction, createAgentCommandFromFeishuMessage, createAgentConversationMessages, createAgentDomainEventHandler, createAgentDomainEventSink, createAgentDomainEventSinkFromCallback, createAgentHarness, createAgentHarnessClient, createAgentHarnessPooledRuntime, createAgentInstanceRegistry, createAgentLoopFromCallback, createAgentLoopModelExecutionEnd, createAgentLoopModelExecutionStart, createAgentLoopPromptTransformer, createAgentLoopSkillExecutionEnd, createAgentLoopSkillExecutionStart, createAgentLoopTextDelta, createAgentLoopThinkingDelta, createAgentLoopToolExecutionEnd, createAgentLoopToolExecutionStart, createAgentLoopToolExecutionUpdate, createAgentMemoryService, createAgentRunUpdateHandler, createAgentRuntime, createAgentRuntimePool, createAgentTranscriptMessages, createAgentTranscriptTurn, createAgentsMdInstructionsProvider, createAsyncIterableAgentLoop, createAutomationMandateStore, createCoalescingFeishuPublisher, createCompactionService, createCompositeRivusDaemonTransport, createConfiguredFeishuAutomationCardSender, createConfiguredFeishuCardKitPublisher, createConfiguredFeishuCardKitTargetCreator, createConfiguredFeishuCardRolloverRuntime, createConfiguredFeishuHumanInteractionPresenter, createConfiguredFeishuOpenApiClient, createConfiguredFeishuTextReplySender, createConfiguredRivusDaemonBootstrap, createConfiguredRivusDeploymentDaemon, createDailyAutomationSchedule, createDefaultAgentHarness, createDefaultAgentHarnessClient, createDefaultAgentHarnessClientFromCallback, createDefaultAgentHarnessClientFromTextCallback, createDefaultAgentHarnessFromCallback, createDefaultAgentHarnessFromTextCallback, createDefaultAgentRuntime, createDefaultAgentRuntimeFromCallback, createDefaultAgentRuntimeFromTextCallback, createDelegationService, createDeliveryOutbox, createEventAgentLoop, createFakeRivusPlugin, createFeishuAgentDaemon, createFeishuAgentRunCard, createFeishuAgentRuntime, createFeishuCardActionCallbackResponse, createFeishuCardActionErrorResponse, createFeishuCardDeliveryLedger, createFeishuCardDeliveryReconciler, createFeishuCardKitOpenApiClient, createFeishuCardKitOpenApiTargetCreator, createFeishuCardKitPublisher, createFeishuCardPresentationStore, createFeishuCardRollover, createFeishuCardRolloverSupervisor, createFeishuCardTargetPreparation, createFeishuConversationId, createFeishuCotPublisher, createFeishuDeploymentEndpoint, createFeishuEventHandlers, createFeishuHumanInteractionCard, createFeishuHumanInteractionPresenter, createFeishuInboxRepository, createFeishuMessageQueue, createFeishuMessageWorker, createFeishuOpenApiClient, createFeishuPeriodicFlush, createFeishuPresentationPreparation, createFeishuSessionKey, createFeishuStreamProjector, createFeishuTenantAccessTokenProvider, createFeishuWebSocketDaemon, createFeishuWorkerLoop, createFixedClock, createHumanInteractionEndpointRegistry, createHumanInteractionService, createHumanInteractionToolApprovalGateway, createInMemoryFeishuCardTargetRegistry, createInMemoryHumanInteractionRepository, createInvocationAuthority, createJsonFetchRequest, createJsonFileFeishuCardTargetRegistry, createJsonlAgentEventLog, createJsonlHumanInteractionRepository, createLangfuseAgentTelemetry, createLazyFeishuWebSocketEventDispatcher, createMemoryNamespace, createOpenTelemetryAgentEventSink, createOpenTelemetryAgentTelemetry, createPiAgentLoop, createPiSdkAgentLoop, createPiSessionRegistry, createPluginStateStore, createProjectMemoryPromptPreparer, createRateLimitedFeishuPublisher, createRecoveryAction, createRecoveryControl, createRivusAgentHost, createRivusDaemonProcess, createRivusDaemonShutdownController, createRivusDaemonStatusHttpServer, createRivusDaemonStatusReporter, createRivusDeploymentCliProcess, createRivusDeploymentDaemon, createRivusEnvFromOpenClawConfig, createRivusMemoryTool, createRivusMemoryToolContract, createRivusMemoryToolDescriptor, createRivusPluginCatalog, createRoutedHumanInteractionToolApprovalService, createScheduledAutomation, createSequenceRunIds, createSessionScheduler, createSubagentCoordinator, createSystemClock, createTelemetryContentRedactor, createTestClock, createTextAgentLoop, createTextAgentLoopFromCallback, createToolBroker, createToolInputDigest, createToolOperationLedger, createUuidRunIds, createWorkspaceRootHandle, describeFeishuMessageIntake, evolveAgentRun, formatRivusEnvFile, initialAgentRunState, intersectToolIds, isAgentToolExecutionEvent, isAssistantTextDeltaEvent, isAssistantThinkingDeltaEvent, isCardPresentationHandoffDue, isTerminalAgentDomainEvent, isTerminalAgentRunPhase, loadNodeRivusPluginModule, loadRivusDaemonConfig, loadRivusDeployment, loadRivusDeploymentManifest, normalizeStableJson, openJsonAutomationTickRepository, openJsonlAgentMemoryService, openJsonlFeishuCardDeliveryLedger, openJsonlFeishuInboxRepository, openJsonlRecoveryControl, openJsonlToolOperationLedger, replayAgentHistory, replayAgentTranscript, requiresToolApproval, resolveFeishuEndpointCredentials, resolveLangfuseTelemetryConfig, resolveRivusAgentDefinition, resolveRivusProjectSpace, restoreAgentHistory, restoreConfiguredRivusDaemonBootstrap, restrictMemoryScopesForAudience, runRivusDaemonCli, shouldAcceptFeishuEndpointMessage, transitionHumanInteraction, validateProjectSkillCatalog, validateProjectSkillCommand, validateRivusDeploymentManifest };
+export { AgentContextBudgetExceeded, AgentEventHandlerFailed, AgentEventLogStoreError, AgentEventSinkFailed, AgentHarnessBusy, AgentInstanceBusy, AgentInstanceConflict, AgentLoopFailed, AgentMemoryError, AgentRunCancelled, AgentRuntimeDisposed, AutomationMandateError, BACKGROUND_SESSION_DELIVERY_JSONL_VERSION, BACKGROUND_SESSION_JSONL_VERSION, BACKGROUND_SESSION_SESSION_KEY_PREFIX, BACKGROUND_SESSION_START_TOOL_ID, BACKGROUND_SESSION_TOOL_IDS, BACKGROUND_SESSION_TOOL_PLUGIN_ID, BACKGROUND_SESSION_TOOL_VERSION, BackgroundSessionCallerDenied, BackgroundSessionDeliveryConflict, BackgroundSessionRepositoryConflict, BackgroundSessionRepositoryCorrupted, BackgroundSessionTransitionDenied, CardPresentationTransitionDenied, CompactionError, DEFAULT_BACKGROUND_SESSION_LEASE_MS, DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS, DEFAULT_BACKGROUND_SESSION_LIFETIME_MS, DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS, DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES, DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS, DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS, DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS, DEFAULT_CARD_STREAM_LEASE_MS, DelegationDenied, DeliveryOutboxError, FeishuCardPresentationNotFound, FeishuCardTargetNotFound, FeishuCardTargetRegistryStoreError, FeishuCotProtocolError, FeishuEndpointCredentialError, FeishuOpenApiError, FeishuTenantAccessTokenError, HumanInteractionRepositoryError, HumanInteractionTransitionDenied, InvalidFeishuCardAction, InvalidFeishuMessageContent, InvalidFeishuSessionReference, InvalidInvocationAuthority, InvalidProjectSkillCatalog, InvalidRecoveryAction, InvalidRivusEndpointBinding, InvalidRivusPlugin, InvalidRivusProjectSpace, InvalidStableJson, InvalidToolInput, InvalidWorkspaceRoot, LangfuseTelemetryConfigError, MEMORY_SCOPES, OpenClawEnvImportError, PluginStateConflict, RIVUS_MEMORY_TOOL_ID, RIVUS_MEMORY_TOOL_PLUGIN_ID, RIVUS_MEMORY_TOOL_VERSION, RIVUS_PLUGIN_API_VERSION, RivusDaemonConfigError, RivusDeploymentAutomationReadinessError, RivusDeploymentDaemonLifecycleError, RivusDeploymentManifestError, RivusDeploymentReadinessError, RivusPluginConformanceError, RivusPluginLoadError, RivusToolInputRejected, SessionSchedulerCapacityExceeded, SessionSchedulerDisposed, ToolInvocationDenied, UnsupportedFeishuCardAction, UnsupportedFeishuMessage, WorkspaceInstructionsSourceError, acceptsCardPresentationProgress, activeCardPresentation, appendBackgroundSessionInput, assembleAgentContext, assertRivusPluginConforms, backgroundSessionToolIds, claimBackgroundSession, commitAutomationOutcome, completeBackgroundSessionStep, completeBackgroundSessionStop, createAgentCommandFromFeishuCardAction, createAgentCommandFromFeishuMessage, createAgentConversationMessages, createAgentDomainEventHandler, createAgentDomainEventSink, createAgentDomainEventSinkFromCallback, createAgentHarness, createAgentHarnessClient, createAgentHarnessPooledRuntime, createAgentInstanceRegistry, createAgentLoopFromCallback, createAgentLoopModelExecutionEnd, createAgentLoopModelExecutionStart, createAgentLoopPromptTransformer, createAgentLoopSkillExecutionEnd, createAgentLoopSkillExecutionStart, createAgentLoopTextDelta, createAgentLoopThinkingDelta, createAgentLoopToolExecutionEnd, createAgentLoopToolExecutionStart, createAgentLoopToolExecutionUpdate, createAgentMemoryService, createAgentRunUpdateHandler, createAgentRuntime, createAgentRuntimePool, createAgentTranscriptMessages, createAgentTranscriptTurn, createAgentsMdInstructionsProvider, createAsyncIterableAgentLoop, createAutomationMandateStore, createBackgroundSession, createBackgroundSessionCard, createBackgroundSessionDeliveryStore, createBackgroundSessionHostTools, createBackgroundSessionKey, createBackgroundSessionRepository, createBackgroundSessionService, createBackgroundSessionStepSourceMessageId, createBackgroundSessionSupervisor, createBackgroundSessionToolContracts, createCoalescingFeishuPublisher, createCompactionService, createCompositeRivusDaemonTransport, createConfiguredFeishuAutomationCardSender, createConfiguredFeishuBackgroundSessionDelivery, createConfiguredFeishuCardKitPublisher, createConfiguredFeishuCardKitTargetCreator, createConfiguredFeishuCardRolloverRuntime, createConfiguredFeishuHumanInteractionPresenter, createConfiguredFeishuOpenApiClient, createConfiguredFeishuTextReplySender, createConfiguredRivusDaemonBootstrap, createConfiguredRivusDeploymentDaemon, createDailyAutomationSchedule, createDefaultAgentHarness, createDefaultAgentHarnessClient, createDefaultAgentHarnessClientFromCallback, createDefaultAgentHarnessClientFromTextCallback, createDefaultAgentHarnessFromCallback, createDefaultAgentHarnessFromTextCallback, createDefaultAgentRuntime, createDefaultAgentRuntimeFromCallback, createDefaultAgentRuntimeFromTextCallback, createDelegationService, createDeliveryOutbox, createEventAgentLoop, createFakeRivusPlugin, createFeishuAgentDaemon, createFeishuAgentRunCard, createFeishuAgentRuntime, createFeishuCardActionCallbackResponse, createFeishuCardActionErrorResponse, createFeishuCardDeliveryLedger, createFeishuCardDeliveryReconciler, createFeishuCardKitOpenApiClient, createFeishuCardKitOpenApiTargetCreator, createFeishuCardKitPublisher, createFeishuCardPresentationStore, createFeishuCardRollover, createFeishuCardRolloverSupervisor, createFeishuCardTargetPreparation, createFeishuConversationId, createFeishuCotPublisher, createFeishuDeploymentEndpoint, createFeishuEventHandlers, createFeishuHumanInteractionCard, createFeishuHumanInteractionPresenter, createFeishuInboxRepository, createFeishuMessageQueue, createFeishuMessageWorker, createFeishuOpenApiClient, createFeishuPeriodicFlush, createFeishuPresentationPreparation, createFeishuSessionKey, createFeishuStreamProjector, createFeishuTenantAccessTokenProvider, createFeishuWebSocketDaemon, createFeishuWorkerLoop, createFixedClock, createHumanInteractionEndpointRegistry, createHumanInteractionService, createHumanInteractionToolApprovalGateway, createInMemoryFeishuCardTargetRegistry, createInMemoryHumanInteractionRepository, createInvocationAuthority, createJsonFetchRequest, createJsonFileFeishuCardTargetRegistry, createJsonlAgentEventLog, createJsonlHumanInteractionRepository, createLangfuseAgentTelemetry, createLazyFeishuWebSocketEventDispatcher, createMemoryNamespace, createOpenTelemetryAgentEventSink, createOpenTelemetryAgentTelemetry, createPiAgentLoop, createPiSdkAgentLoop, createPiSessionRegistry, createPluginStateStore, createProjectMemoryPromptPreparer, createRateLimitedFeishuPublisher, createRecoveryAction, createRecoveryControl, createRivusAgentHost, createRivusDaemonProcess, createRivusDaemonShutdownController, createRivusDaemonStatusHttpServer, createRivusDaemonStatusReporter, createRivusDeploymentCliProcess, createRivusDeploymentDaemon, createRivusEnvFromOpenClawConfig, createRivusMemoryTool, createRivusMemoryToolContract, createRivusMemoryToolDescriptor, createRivusPluginCatalog, createRoutedHumanInteractionToolApprovalService, createScheduledAutomation, createSequenceRunIds, createSessionScheduler, createSubagentCoordinator, createSystemClock, createTelemetryContentRedactor, createTestClock, createTextAgentLoop, createTextAgentLoopFromCallback, createToolBroker, createToolInputDigest, createToolOperationLedger, createUuidRunIds, createWorkspaceRootHandle, describeFeishuMessageIntake, evolveAgentRun, extendBackgroundSessionDefinition, failBackgroundSessionStep, formatRivusEnvFile, initialAgentRunState, intersectToolIds, isAgentToolExecutionEvent, isAssistantTextDeltaEvent, isAssistantThinkingDeltaEvent, isBackgroundSessionDue, isBackgroundSessionLeaseExpired, isBackgroundSessionState, isBackgroundSessionTerminalPhase, isBackgroundSessionToolId, isCardPresentationHandoffDue, isTerminalAgentDomainEvent, isTerminalAgentRunPhase, loadNodeRivusPluginModule, loadRivusDaemonConfig, loadRivusDeployment, loadRivusDeploymentManifest, narrowBackgroundSessionDefinition, normalizeStableJson, openJsonAutomationTickRepository, openJsonlAgentMemoryService, openJsonlBackgroundSessionDeliveryStore, openJsonlBackgroundSessionRepository, openJsonlFeishuCardDeliveryLedger, openJsonlFeishuInboxRepository, openJsonlRecoveryControl, openJsonlToolOperationLedger, parkBackgroundSessionForReconciliation, progressDeliveryId, releaseBackgroundSessionLease, renewBackgroundSessionLease, replayAgentHistory, replayAgentTranscript, requestBackgroundSessionStop, requeueInterruptedBackgroundSessionStep, requiresToolApproval, resolveBackgroundSessionReconciliation, resolveBackgroundSessionSupervisorIntervalMs, resolveFeishuEndpointCredentials, resolveLangfuseTelemetryConfig, resolveRivusAgentDefinition, resolveRivusProjectSpace, restoreAgentHistory, restoreConfiguredRivusDaemonBootstrap, restrictMemoryScopesForAudience, runRivusDaemonCli, sessionIdFromSessionKey, shouldAcceptFeishuEndpointMessage, suspendBackgroundSession, terminalDeliveryId, transitionHumanInteraction, validateProjectSkillCatalog, validateProjectSkillCommand, validateRivusDeploymentManifest };