@rivus/gateway 0.16.2

package/dist/index.js

@@ -0,0 +1,1215 @@
+import { $ as FeishuCotProtocolError, $n as AUTOMATION_SUPPRESSION_PREFIX, $t as UnsupportedFeishuMessage, A as DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS, An as readPiModelManagementGrant, At as createFeishuCardRolloverSupervisor, B as createBackgroundSessionService$1, Bn as ModelChangeRequestConflict, Bt as isRetryableFeishuMessageError, C as DEFAULT_BACKGROUND_SESSION_LEASE_MS, Cn as openPiModelManagementDeployment, Ct as FeishuOpenApiError, D as DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES, Dn as RIVUS_MODEL_SOCKET_ENV, Dt as createFeishuTenantAccessTokenProvider, E as DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS, En as RIVUS_MODEL_CONTEXT_ENV, Et as FeishuTenantAccessTokenError, F as BACKGROUND_SESSION_DELIVERY_JSONL_VERSION, Fn as createModelChangeAuthorization, Ft as activeCardPresentation, G as createFeishuPresentationPreparation, Gn as toEffectAgentHostRuntime, Gt as createFeishuMessageWorker, H as BackgroundSessionRepositoryCorrupted, Hn as ModelStateCorrupted, Ht as createFeishuCardActionCallbackResponse, I as openJsonlBackgroundSessionDeliveryStore, In as MODEL_STATE_SCHEMA_VERSION, It as isCardPresentationHandoffDue, J as openJsonlRecoveryControl, Jn as runAgentHostSyncEffect, Jt as createFeishuAgentDaemon, K as createFeishuDeploymentEndpoint, Kn as toEffectAgentRuntimeInput, Kt as shouldAcceptFeishuEndpointMessage, L as createBackgroundSessionDeliveryStore, Ln as ModelChangeAuthorizationRejected, Lt as createFeishuWebSocketDaemon, M as createBackgroundSessionSupervisor, Mn as ModelChangeBoundaryDeadlineError, Mt as DEFAULT_CARD_STREAM_LEASE_MS, N as createBackgroundSessionRepository, Nn as createModelChangeRunBoundary, Nt as CardPresentationTransitionDenied, O as DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS, On as createPiModelManagementBashSpawnHook, Ot as createRateLimitedFeishuPublisher, P as openJsonlBackgroundSessionRepository, Pn as createModelChangeCoordinator, Pt as acceptsCardPresentationProgress, Q as createAgentsMdInstructionsProvider, Qn as readAutomationPresentation, Qt as InvalidFeishuMessageContent, R as BACKGROUND_SESSION_JSONL_VERSION, Rn as ModelChangeBusy, Rt as createLazyFeishuWebSocketEventDispatcher, S as resolveFeishuDeliveryChatId, Sn as createPiManagedRunGatewayProvider, St as createFeishuAgentRunCard, T as DEFAULT_BACKGROUND_SESSION_LIFETIME_MS, Tn as RIVUS_MODEL_CHANGE_TOOL_ID, Tt as createFeishuOpenApiClient, U as AgentMemoryError, Un as createBackgroundSessionHostTools, Ut as createFeishuCardActionErrorResponse, V as BackgroundSessionRepositoryConflict, Vn as ModelChangeRevisionConflict, Vt as createFeishuEventHandlers, W as createAgentMemoryService, Wn as toCompatibilityAgentRuntimeInput, Wt as createFeishuWorkerLoop, X as ToolInvocationDenied, Xn as InvalidAutomationPresentation, Xt as describeFeishuMessageIntake, Y as openJsonlToolOperationLedger, Yn as AUTOMATION_PRESENTATION_SCHEMA_VERSION, Yt as createAgentCommandFromFeishuMessage, Z as createToolBroker, Zn as createAutomationPresentation, Zt as readFeishuSessionResetDirective, _ as openJsonAutomationTickRepository, _n as openJsonlFeishuCardDeliveryLedger, _t as createConfiguredFeishuCardKitPublisher, a as createInMemoryHumanInteractionRepository, an as UnsupportedFeishuCardAction, ar as BackgroundSessionCallerDenied, at as createInMemoryCardPresentationRepository, b as createBackgroundSessionCard, bn as createFeishuStreamProjector, bt as FEISHU_AGENT_CARD_ELEMENT_ID, c as createConfiguredFeishuAutomationCardSender, cn as SessionSchedulerCapacityExceeded, cr as sessionIdFromSessionKey, ct as InvalidFeishuTopicContext, d as createHumanInteractionToolApprovalGateway, dn as openJsonFeishuSessionStore, dr as createBackgroundSession$1, dt as createConfiguredFeishuMessageReactionSender, en as readFeishuMessageContent, er as createAutomationScheduler, et as createFeishuCotPublisher, f as createHumanInteractionEndpointRegistry, fn as createFeishuSessionStore, fr as createMessageGateway, ft as createConfiguredFeishuTextReplySender, g as runDeploymentControlEffect, gn as createFeishuInboxRepository, gr as hasInspectableRunProgress, gt as createFeishuCardTargetPreparation, h as loadRivusDeploymentManifest, hn as createRecoveryControl, hr as RUN_PRESENTATION_SCHEMA_VERSION, ht as createFeishuCardKitOpenApiTargetCreator, i as createFeishuHumanInteractionPresenter, in as InvalidFeishuCardAction, ir as createHumanInteractionService, it as createJsonFileFeishuCardTargetRegistry, j as resolveBackgroundSessionSupervisorIntervalMs, jn as createModelManagementControl, jt as createFeishuCardRollover, k as DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS, kn as createPiModelRunContextRegistry, kt as createCoalescingFeishuPublisher, l as createRoutedHumanInteractionToolApprovalService, ln as SessionSchedulerDisposed, lr as terminalDeliveryId, lt as createFeishuTopicContextResolver, m as toHumanInteractionSnapshot, mn as readTenantKey, mr as createPresentedValue, mt as createConfiguredFeishuCardKitTargetCreator, n as createConfiguredFeishuHumanInteractionPresenter, nn as createFeishuConversationId, nr as AutomationMandateError, nt as FeishuCardTargetRegistryStoreError, o as createJsonlHumanInteractionRepository, on as createAgentCommandFromFeishuCardAction, or as createBackgroundSessionService, ot as CardPresentationNotFound, p as toHumanInteractionAggregate, pn as openJsonlFeishuInboxRepository, pr as createRunPresentationProjector$1, pt as createConfiguredFeishuCardRolloverRuntime, q as createAgentHarnessPooledRuntime, qn as runAgentHostEffect, qt as createFeishuMessageQueue, r as createFeishuHumanInteractionCard, rn as createFeishuSessionKey, rr as createAutomationMandateStore$1, rt as createInMemoryFeishuCardTargetRegistry, s as HumanInteractionRepositoryError, sn as createJsonFetchRequest, sr as progressDeliveryId, st as createCardPresentationService, t as createHumanInteractionService$1, tn as InvalidFeishuSessionReference, tr as createDailyAutomationSchedule, tt as FeishuCardTargetNotFound, u as createHumanInteractionModelChangeApproval, un as createSessionScheduler, ur as restoreBackgroundSession, ut as composeFeishuTopicPrompt, v as createScheduledAutomation, vn as createFeishuCardDeliveryLedger, vt as createFeishuCardKitPublisher, w as DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS, wn as PiModelRunContextError, wt as createConfiguredFeishuOpenApiClient, x as createConfiguredFeishuBackgroundSessionDelivery, xn as DEFAULT_CONVERSATION_PROGRESS_DISPLAY, xt as FEISHU_AGENT_CARD_PROGRESS_ELEMENT_ID, y as openJsonlAgentMemoryService, yn as createFeishuCardDeliveryReconciler, yt as createFeishuCardKitOpenApiClient, z as isBackgroundSessionState, zn as ModelChangeNotFound, zt as createInterruptedRunReplayGuard } from "./chunks/service.js";
+import { a as backgroundSessionToolIds, c as isBackgroundSessionToolId, d as createBackgroundSessionKey, f as createBackgroundSessionStepSourceMessageId, i as BACKGROUND_SESSION_TOOL_VERSION, l as narrowBackgroundSessionDefinition$1, n as BACKGROUND_SESSION_TOOL_IDS, o as createBackgroundSessionToolContracts, r as BACKGROUND_SESSION_TOOL_PLUGIN_ID, s as extendBackgroundSessionDefinition$1, t as BACKGROUND_SESSION_START_TOOL_ID, u as BACKGROUND_SESSION_SESSION_KEY_PREFIX } from "./chunks/background-session-authority.js";
+import { A as InvalidRivusPlugin, C as createRivusHostToolDescriptorProvider, D as validateRivusCatalogIdentifier, E as createRivusPluginCatalog$1, F as InvalidAgentHostBinding, I as createEffectAgentHost, L as AgentInstanceConflict, M as AgentInstanceBusy, N as AgentRuntimeDisposed, O as validateRivusCatalogRegistration, P as createAgentHostRuntimePool, R as createEffectAgentInstanceRegistry, S as initializeRivusProject, T as createRivusToolGrantSetOperations, _ as formatRivusEnvFile, a as resolveRivusProjectSpace, b as loadNodeRivusPluginModule$1, c as RivusDeploymentReadinessError, d as RivusPluginLoadError, f as resolveRivusDeployment, g as createRivusEnvFromOpenClawConfig, h as OpenClawEnvImportError, i as createRivusDeploymentCliProcess, j as RIVUS_PLUGIN_API_VERSION, k as validateRivusPluginManifest, l as createRivusDeploymentControl, m as createRivusDaemonShutdownController, n as runRivusCli, o as RivusDeploymentAutomationReadinessError, p as createProcessDeploymentControlPorts, r as runRivusDaemonCli, s as RivusDeploymentBackgroundSessionReadinessError, t as runRivusNodeEntrypoint, u as RivusDeploymentDaemonLifecycleError, v as diagnoseRivusProject, w as createRivusAgentCatalog$1, x as resolveRivusPluginModule, y as createNodeRivusPluginModuleLoader$1 } from "./chunks/rivus-node-entrypoint.js";
+import { D as deepFreeze, E as runDeploymentProcessEffect, a as InvalidRivusProjectSpace, c as RIVUS_RELEASE_DESCRIPTOR, i as resolveFeishuEndpointCredentials, k as toEffectAgentRuntimeInput$1, m as loadRivusDaemonConfig, o as validateRivusDeploymentManifest, p as RivusDaemonConfigError, r as FeishuEndpointCredentialError, t as RivusDeploymentManifestError } from "./chunks/node-rivus-deployment-manifest.js";
+import { Cause, Effect, Exit, Option } from "effect";
+import { InvalidInvocationAuthority, createInvocationAuthority, createLegacyAgentHarness, resolveInvocationAuthority, restoreAgentHistory } from "@rivus/runtime";
+import { createRandomId, createSha256Digest, createStableId } from "@rivus/platform/identity";
+import { dirname } from "node:path";
+import { createServer } from "node:http";
+//#region src/core/application/automation/outcome/commit-automation-outcome.ts
+function commitAutomationOutcome(command) {
+	return command.repository.commit({
+		outcome: command.outcome,
+		stateUpdate: command.stateUpdate,
+		tickId: command.tickId
+	});
+}
+//#endregion
+//#region src/adapters/compatibility/agent-host/agent-instance-registry.ts
+function createAgentInstanceRegistry(options = {}) {
+	const registry = createEffectAgentInstanceRegistry({
+		createInstanceId: (input) => createStableId("instance", input),
+		createRuntimeGenerationId: (input) => createStableId("generation", input)
+	}, options);
+	return {
+		resolveAutomation: (automationId, definition) => runAgentHostSyncEffect(registry.resolveAutomation(automationId, definition)),
+		resolveBackgroundSession: (agentId, definition) => runAgentHostSyncEffect(registry.resolveBackgroundSession(agentId, definition)),
+		resolveEndpoint: (endpointId, definition) => runAgentHostSyncEffect(registry.resolveEndpoint(endpointId, definition)),
+		snapshot: () => runAgentHostSyncEffect(registry.snapshot())
+	};
+}
+//#endregion
+//#region src/adapters/compatibility/agent-host/agent-runtime-pool.ts
+function createAgentRuntimePool(options) {
+	const pool = createAgentHostRuntimePool({ create: (instance) => Effect.tryPromise({
+		try: async () => toEffectAgentHostRuntime(await options.createRuntime(instance)),
+		catch: (error) => error
+	}) }, options.disposeTimeoutMs);
+	return {
+		registry: options.registry,
+		cancel: (instance, input) => runAgentHostEffect(pool.cancel(instance, input)),
+		disposeAll: () => runAgentHostEffect(pool.disposeAll().pipe(Effect.mapError(toCompatibilityDisposalError))),
+		run: (instance, input) => runAgentHostEffect(pool.run(instance, toEffectAgentRuntimeInput(input))),
+		steer: (instance, input) => runAgentHostEffect(pool.steer(instance, input))
+	};
+}
+function toCompatibilityDisposalError(error) {
+	if (error instanceof AggregateError && error.errors.length === 1) return error.errors[0];
+	if (error instanceof AgentRuntimeDisposed) return new Error(error.message.replace(/^agent runtime /, "Agent runtime "));
+	return error;
+}
+//#endregion
+//#region src/adapters/compatibility/agent-host/rivus-agent-host.ts
+var InvalidRivusEndpointBinding = class extends Error {
+	name = "InvalidRivusEndpointBinding";
+};
+function createRivusAgentHost(options) {
+	const host = runAgentHostSyncEffect(createEffectAgentHost({
+		...options.automations ? { automations: options.automations } : {},
+		...options.backgroundSessions ? { backgroundSessions: options.backgroundSessions } : {},
+		definitions: options.definitions,
+		endpoints: options.endpoints,
+		registry: toEffectRegistry(options.runtimePool),
+		runtime: toEffectRuntimePort(options.runtimePool)
+	}).pipe(Effect.mapError(mapHostError)));
+	return {
+		cancelBackgroundSession: (agentId, input) => runHostEffect(host.cancelBackgroundSession(agentId, input)),
+		cancelEndpoint: (endpointId, input) => runHostEffect(host.cancelEndpoint(endpointId, input)),
+		handleAutomation: (automationId, input) => runHostEffect(host.handleAutomation(automationId, toEffectAgentRuntimeInput(input))),
+		handleBackgroundSession: (agentId, input) => runHostEffect(host.handleBackgroundSession(agentId, toEffectAgentRuntimeInput(input))),
+		handleEndpoint: (endpointId, input) => runHostEffect(host.handleEndpoint(endpointId, toEffectAgentRuntimeInput(input))),
+		resolveAutomation: (automationId) => runHostSync(host.resolveAutomation(automationId)),
+		resolveBackgroundSession: (agentId) => runHostSync(host.resolveBackgroundSession(agentId)),
+		resolveEndpoint: (endpointId) => runHostSync(host.resolveEndpoint(endpointId)),
+		steerEndpoint: (endpointId, input) => runHostEffect(host.steerEndpoint(endpointId, input))
+	};
+}
+function toEffectRegistry(pool) {
+	const registry = pool.registry;
+	const sync = (read) => Effect.try({
+		try: read,
+		catch: (error) => error instanceof AgentInstanceConflict ? error : new AgentInstanceConflict(String(error))
+	});
+	return {
+		resolveAutomation: (automationId, definition) => sync(() => registry.resolveAutomation(automationId, definition)),
+		resolveBackgroundSession: (agentId, definition) => sync(() => registry.resolveBackgroundSession(agentId, definition)),
+		resolveEndpoint: (endpointId, definition) => sync(() => registry.resolveEndpoint(endpointId, definition)),
+		snapshot: () => Effect.sync(() => registry.snapshot())
+	};
+}
+function toEffectRuntimePort(pool) {
+	return {
+		cancel: (instance, input) => Effect.tryPromise({
+			try: () => pool.cancel(instance, input),
+			catch: (error) => error
+		}),
+		disposeAll: () => Effect.tryPromise({
+			try: () => pool.disposeAll(),
+			catch: (error) => error
+		}),
+		run: (instance, input) => Effect.tryPromise({
+			try: () => pool.run(instance, toCompatibilityAgentRuntimeInput(input)),
+			catch: (error) => error
+		}),
+		steer: (instance, input) => Effect.tryPromise({
+			try: () => pool.steer(instance, input),
+			catch: (error) => error
+		})
+	};
+}
+function runHostEffect(effect) {
+	return runAgentHostEffect(effect.pipe(Effect.mapError(mapHostError)));
+}
+function runHostSync(effect) {
+	return runAgentHostSyncEffect(effect.pipe(Effect.mapError(mapHostError)));
+}
+function mapHostError(error) {
+	return error instanceof InvalidAgentHostBinding ? new InvalidRivusEndpointBinding(error.message) : error;
+}
+//#endregion
+//#region src/adapters/compatibility/agent-catalog/rivus-agent-catalog.ts
+const runtime = Object.freeze({
+	digest: createSha256Digest,
+	deepFreeze
+});
+function createRivusPluginCatalog() {
+	return createRivusPluginCatalog$1(runtime);
+}
+function createRivusAgentCatalog(options = {}) {
+	return createRivusAgentCatalog$1(options.toolDescriptorProviders ?? [], runtime);
+}
+function createCompatibleRivusAgentCatalog(options = {}) {
+	return createRivusAgentCatalog$1([createRivusHostToolDescriptorProvider({ backgroundSessions: options.backgroundSessions === true })], runtime);
+}
+function resolveRivusAgentDefinition(catalog, deployment, options = {}) {
+	return createCompatibleRivusAgentCatalog(options).resolve(catalog, deployment);
+}
+//#endregion
+//#region src/platform/daemon/process/rivus-daemon-process.ts
+function createRivusDaemonProcess(options) {
+	let running = false;
+	let stopped = false;
+	return {
+		running: () => running,
+		start: () => Effect.tryPromise({
+			try: async () => {
+				if (running) return;
+				stopped = false;
+				await options.transport.start();
+				try {
+					options.workerLoop.start();
+					running = true;
+				} catch (error) {
+					await options.transport.stop();
+					running = false;
+					throw error;
+				}
+			},
+			catch: (error) => error
+		}),
+		stop: () => Effect.tryPromise({
+			try: async () => {
+				if (!running && stopped) return;
+				if (running) await Promise.resolve(options.workerLoop.stop());
+				await options.transport.stop();
+				running = false;
+				stopped = true;
+			},
+			catch: (error) => error
+		})
+	};
+}
+//#endregion
+//#region src/platform/daemon/transport/rivus-daemon-transport.ts
+function createCompositeRivusDaemonTransport(options) {
+	const transports = [...options.transports];
+	let running = false;
+	let stopped = false;
+	return {
+		running: () => running,
+		start: async () => {
+			if (running) return;
+			stopped = false;
+			const started = [];
+			try {
+				for (const transport of transports) {
+					await transport.start();
+					started.push(transport);
+				}
+				running = true;
+			} catch (error) {
+				for (const transport of started.reverse()) await transport.stop();
+				running = false;
+				throw error;
+			}
+		},
+		stop: async () => {
+			if (!running && stopped) return;
+			for (const transport of [...transports].reverse()) await transport.stop();
+			running = false;
+			stopped = true;
+		}
+	};
+}
+//#endregion
+//#region src/platform/daemon/status/daemon-status-reporter.ts
+function createDaemonStatusReporter(options) {
+	return { status: () => options.restoreHistory().pipe(Effect.map((history) => {
+		const availability = options.availability?.();
+		const activeRun = availability?.busy ? availability.activeRun : options.activeRun?.();
+		const activeRunId = availability?.busy ? availability.activeRunId : activeRun?.runId ?? options.activeRunId?.();
+		const activeRunState = availability?.busy ? availability.activeState : options.activeRunState?.();
+		const activeSessionKey = availability?.busy ? availability.activeSessionKey : activeRun?.sessionKey;
+		return {
+			agentId: options.agentId,
+			...options.cardPresentations ? { cards: options.cardPresentations() } : {},
+			harness: {
+				...activeRunId !== void 0 ? { activeRunId } : {},
+				...activeRunState !== void 0 ? { activeRunState } : {},
+				...activeSessionKey !== void 0 ? { activeSessionKey } : {},
+				busy: activeRunId !== void 0
+			},
+			history,
+			process: { running: options.processRunning() },
+			queue: { pending: options.pending() },
+			...options.receiveStatus ? { receive: options.receiveStatus() } : {},
+			transport: { running: options.transportRunning() },
+			workerLoop: { running: options.workerLoopRunning() }
+		};
+	})) };
+}
+//#endregion
+//#region src/adapters/compatibility/daemon/rivus-daemon-status.ts
+function createRivusDaemonStatusReporter(options) {
+	return createDaemonStatusReporter(options);
+}
+//#endregion
+//#region src/adapters/http/daemon/rivus-daemon-status-http-server.ts
+function createDaemonStatusHttpServer(options) {
+	const host = options.host ?? "127.0.0.1";
+	const path = options.path ?? "/status";
+	let server;
+	let running = false;
+	return {
+		running: () => running,
+		start: async () => {
+			if (running) return;
+			server = createServer((request, response) => {
+				handleRequest(request, response, path, options.statusReporter);
+			});
+			await listen(server, host, options.port);
+			running = true;
+		},
+		stop: async () => {
+			if (!running || !server) return;
+			await close(server);
+			running = false;
+			server = void 0;
+		},
+		url: () => {
+			const address = server?.address();
+			if (!running || !address || typeof address === "string") return;
+			return `http://${host}:${address.port}`;
+		}
+	};
+}
+async function handleRequest(request, response, path, statusReporter) {
+	if (request.method !== "GET" || requestPath(request) !== path) {
+		writeJson(response, 404, { error: "not_found" });
+		return;
+	}
+	try {
+		writeJson(response, 200, await Effect.runPromise(statusReporter.status()));
+	} catch (error) {
+		writeJson(response, 500, { error: error instanceof Error ? error.message : String(error) });
+	}
+}
+function requestPath(request) {
+	return new URL(request.url ?? "/", "http://localhost").pathname;
+}
+function writeJson(response, statusCode, body) {
+	response.writeHead(statusCode, {
+		"cache-control": "no-store",
+		"content-type": "application/json; charset=utf-8"
+	});
+	response.end(`${JSON.stringify(body)}\n`);
+}
+function listen(server, host, port) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.off("error", onError);
+			resolve();
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen(port, host);
+	});
+}
+function close(server) {
+	return new Promise((resolve, reject) => {
+		server.close((error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+//#endregion
+//#region src/adapters/compatibility/daemon/rivus-daemon-status-http-server.ts
+function createRivusDaemonStatusHttpServer(options) {
+	return createDaemonStatusHttpServer(options);
+}
+//#endregion
+//#region src/adapters/feishu/runtime/feishu-receive-runtime.ts
+function createFeishuReceiveRuntime(options) {
+	let lastAccepted;
+	let lastHandled;
+	const handleMessage = (payload, handleOptions) => {
+		const effect = options.daemon.handleMessage(payload, handleOptions).pipe(Effect.tap((result) => describeHandledFeishuMessage(payload, result, options.harness, options.observation.agentId, options.observation.botOpenId, options.sessionStore).pipe(Effect.tap((intake) => Effect.gen(function* () {
+			const observedAt = yield* options.observation.clock.now;
+			lastHandled = {
+				intake,
+				messageId: payload.event.message.message_id,
+				observedAt,
+				result
+			};
+		})))));
+		return options.observation.periodicFlush ? options.observation.periodicFlush.withPeriodicFlush(effect) : effect;
+	};
+	const accept = (delivery, payload, acceptOptions) => delivery.accept(payload, acceptOptions).pipe(Effect.tap((accepted) => Effect.gen(function* () {
+		const observedAt = yield* options.observation.clock.now;
+		lastAccepted = {
+			accepted,
+			message: summarizeReceiveMessage(payload),
+			observedAt
+		};
+	})));
+	const createEventHandlers = (delivery) => createFeishuEventHandlers({
+		cardActions: options.daemon,
+		queue: {
+			accept: (payload) => accept(delivery, payload),
+			pending: () => delivery.pending()
+		}
+	});
+	const replayReceiveMessage = (delivery, payload, replayOptions) => Effect.gen(function* () {
+		const intakeOptions = {
+			agentId: options.observation.agentId,
+			...options.observation.botOpenId ? { botOpenId: options.observation.botOpenId } : {},
+			sessionStore: options.sessionStore
+		};
+		const reset = yield* readFeishuSessionResetDirective(payload, intakeOptions);
+		const initialIntake = reset ? void 0 : yield* describeFeishuMessageIntake(payload, intakeOptions);
+		const accepted = yield* accept(delivery, payload, replayOptions);
+		const drained = yield* delivery.drainAvailable();
+		const handledIntake = lastHandled?.messageId === payload.event.message.message_id ? lastHandled.intake : void 0;
+		let intake;
+		if (handledIntake) intake = handledIntake;
+		else if (reset) {
+			const sessionKey = yield* options.sessionStore.current(reset.baseSessionKey);
+			intake = reset.prompt ? {
+				commandType: "prompt",
+				messageId: payload.event.message.message_id,
+				sessionKey,
+				sessionReference: reset.sessionReference,
+				text: reset.prompt
+			} : {
+				commandType: "new_session",
+				messageId: payload.event.message.message_id,
+				previousSessionKey: reset.previousSessionKey,
+				sessionKey,
+				sessionReference: reset.sessionReference
+			};
+		} else intake = initialIntake;
+		return {
+			accepted,
+			drained,
+			intake
+		};
+	});
+	return {
+		accept,
+		createEventHandlers,
+		handleMessage,
+		receiveStatus: () => ({
+			...lastAccepted ? { lastAccepted } : {},
+			...lastHandled ? { lastHandled } : {}
+		}),
+		replayReceiveMessage
+	};
+}
+function describeHandledFeishuMessage(payload, result, harness, agentId, botOpenId, sessionStore) {
+	const sessionReference = {
+		agentId,
+		chatId: payload.event.message.chat_id,
+		tenantKey: readTenantKey(payload),
+		...payload.event.message.thread_id ? { threadId: payload.event.message.thread_id } : {}
+	};
+	if ("finalText" in result) {
+		const state = harness.getRunState(result.runId);
+		if (state?.sessionKey && state.prompt !== void 0) return Effect.succeed({
+			commandType: "prompt",
+			messageId: result.messageId,
+			sessionKey: state.sessionKey,
+			sessionReference,
+			text: state.prompt
+		});
+	}
+	if ("reset" in result) return Effect.succeed({
+		commandType: "new_session",
+		messageId: result.messageId,
+		previousSessionKey: result.previousSessionKey,
+		sessionKey: result.sessionKey,
+		sessionReference
+	});
+	return describeFeishuMessageIntake(payload, {
+		agentId,
+		...botOpenId ? { botOpenId } : {},
+		sessionStore
+	});
+}
+function summarizeReceiveMessage(payload) {
+	const tenantKey = readTenantKey(payload);
+	return {
+		chatId: payload.event.message.chat_id,
+		messageId: payload.event.message.message_id,
+		...tenantKey ? { tenantKey } : {},
+		...payload.event.message.thread_id ? { threadId: payload.event.message.thread_id } : {}
+	};
+}
+//#endregion
+//#region src/bootstrap/feishu/agent-runtime.ts
+function createFeishuAgentRuntime(options) {
+	const sessionStore = options.sessionStore ?? createFeishuSessionStore();
+	const harness = createLegacyAgentHarness({
+		clock: options.clock,
+		...options.eventSinks ? { eventSinks: options.eventSinks } : {},
+		...options.initialEvents ? { initialEvents: options.initialEvents } : {},
+		...options.initialRunStates ? { initialRunStates: options.initialRunStates } : {},
+		loop: options.loop,
+		...options.runTimeoutMs === void 0 ? {} : { runTimeoutMs: options.runTimeoutMs },
+		runIds: options.runIds
+	});
+	const daemon = createFeishuAgentDaemon({
+		...options.acknowledgeSteering ? { acknowledgeSteering: options.acknowledgeSteering } : {},
+		agentId: options.agentId,
+		...options.botOpenId ? { botOpenId: options.botOpenId } : {},
+		dedupe: true,
+		...options.finalizeRun ? { finalizeRun: options.finalizeRun } : {},
+		harness,
+		...options.prepareRun ? { prepareRun: options.prepareRun } : {},
+		...options.promptContext ? { promptContext: options.promptContext } : {},
+		publish: options.publish,
+		...options.reply ? { reply: options.reply } : {},
+		sessionStore
+	});
+	const receive = createFeishuReceiveRuntime({
+		observation: options,
+		daemon,
+		harness,
+		sessionStore
+	});
+	const queue = createFeishuMessageQueue({
+		handleMessage: (payload, handleOptions) => receive.handleMessage(payload, handleOptions),
+		prepareControl: (payload) => daemon.prepareControlMessage(payload),
+		...options.inboxRepository ? { repository: options.inboxRepository } : {},
+		...options.initialEvents ? { shouldSkipReplay: createInterruptedRunReplayGuard(options.initialEvents, {
+			agentId: options.agentId,
+			...options.botOpenId ? { botOpenId: options.botOpenId } : {},
+			sessionStore
+		}) } : {},
+		shouldRetryError: isRetryableFeishuMessageError
+	});
+	const worker = createFeishuMessageWorker({ queue });
+	const delivery = {
+		accept: (payload, handleOptions) => queue.accept(payload, handleOptions),
+		drainAvailable: () => worker.drainAvailable(),
+		pending: () => queue.pending()
+	};
+	return {
+		drainAvailable: () => worker.drainAvailable(),
+		drainOne: () => queue.drainOne(),
+		handlers: receive.createEventHandlers(delivery),
+		harness,
+		pending: () => queue.pending(),
+		queue,
+		receiveStatus: () => receive.receiveStatus(),
+		replayReceiveMessage: (payload, replayOptions) => receive.replayReceiveMessage(delivery, payload, replayOptions),
+		worker
+	};
+}
+//#endregion
+//#region src/bootstrap/feishu/rivus-daemon-bootstrap.ts
+const DEFAULT_WORKER_INTERVAL_MS = 250;
+function restoreConfiguredRivusDaemonBootstrap(options) {
+	return options.eventLog.readAll().pipe(Effect.map((events) => createConfiguredRivusDaemonBootstrap({
+		...options,
+		initialEvents: [...options.initialEvents ?? [], ...events]
+	})));
+}
+function createConfiguredRivusDaemonBootstrap(options) {
+	const openApiClient = createConfiguredFeishuOpenApiClient({
+		config: options.config,
+		request: options.request
+	});
+	const cardRollover = createConfiguredFeishuCardRolloverRuntime({
+		cardTargets: options.cardTargets,
+		client: openApiClient,
+		clock: options.clock,
+		config: options.config,
+		...options.cardLedger ? { ledger: options.cardLedger } : {},
+		...options.flushIntervalMs === void 0 ? {} : { flushIntervalMs: options.flushIntervalMs },
+		...options.observeCardRollover ? { observe: options.observeCardRollover } : {},
+		...options.onWorkerError ? { onError: options.onWorkerError } : {},
+		sleep: options.sleep,
+		...options.cardRolloverIntervalMs === void 0 ? {} : { supervisorIntervalMs: options.cardRolloverIntervalMs }
+	});
+	const publisher = cardRollover.rollover;
+	const replies = createConfiguredFeishuTextReplySender({
+		client: openApiClient,
+		config: options.config
+	});
+	const reactions = createConfiguredFeishuMessageReactionSender({
+		client: openApiClient,
+		config: options.config
+	});
+	const promptContext = createFeishuTopicContextResolver({
+		baseUrl: options.config.feishu.baseUrl,
+		client: openApiClient
+	});
+	const prepareRun = (run) => cardRollover.prepareRun(run);
+	const runtime = createFeishuAgentRuntime({
+		acknowledgeSteering: (messageId) => reactions.add(messageId),
+		agentId: options.config.agentId,
+		...options.botOpenId ? { botOpenId: options.botOpenId } : {},
+		clock: options.clock,
+		eventSinks: [options.eventLog],
+		finalizeRun: (runId) => cardRollover.rollover.releaseRun(runId),
+		...options.inboxRepository ? { inboxRepository: options.inboxRepository } : {},
+		...options.initialEvents ? { initialEvents: options.initialEvents } : {},
+		...options.initialRunStates ? { initialRunStates: options.initialRunStates } : {},
+		loop: options.loop,
+		prepareRun,
+		promptContext,
+		publish: (action) => publisher.publish(action),
+		reply: (messageId, text) => replies.reply(messageId, text),
+		...options.runTimeoutMs === void 0 ? {} : { runTimeoutMs: options.runTimeoutMs },
+		runIds: options.runIds
+	});
+	const websocketTransport = createFeishuWebSocketDaemon({
+		client: options.websocketClient,
+		eventDispatcher: options.eventDispatcher,
+		runtime
+	});
+	const workerLoop = createFeishuWorkerLoop({
+		drainAvailable: () => runtime.drainAvailable(),
+		intervalMs: options.workerIntervalMs ?? DEFAULT_WORKER_INTERVAL_MS,
+		...options.onWorkerError ? { onError: options.onWorkerError } : {},
+		sleep: options.sleep
+	});
+	const restoreHistoryFromLog = () => restoreAgentHistory(options.eventLog);
+	let processRef;
+	let transport = createCompositeRivusDaemonTransport({ transports: [websocketTransport, cardRollover.transport] });
+	const statusReporter = createDaemonStatusReporter({
+		agentId: options.config.agentId,
+		availability: () => runtime.harness.getAvailability(),
+		pending: () => runtime.pending(),
+		processRunning: () => processRef?.running() ?? false,
+		cardPresentations: () => cardRollover.rollover.status(),
+		receiveStatus: () => runtime.receiveStatus(),
+		restoreHistory: restoreHistoryFromLog,
+		transportRunning: () => transport.running(),
+		workerLoopRunning: () => workerLoop.running()
+	});
+	const statusTransport = options.createStatusTransport?.(statusReporter);
+	if (statusTransport) transport = createCompositeRivusDaemonTransport({ transports: [
+		websocketTransport,
+		cardRollover.transport,
+		statusTransport
+	] });
+	const process = createRivusDaemonProcess({
+		transport,
+		workerLoop
+	});
+	processRef = process;
+	return {
+		cardRollover,
+		cardTargets: options.cardTargets,
+		eventLog: options.eventLog,
+		process,
+		promptText: (command) => runtime.harness.promptText(command),
+		publisher,
+		restoreHistory: restoreHistoryFromLog,
+		runtime,
+		status: () => statusReporter.status(),
+		statusReporter,
+		transport,
+		websocketTransport,
+		workerLoop
+	};
+}
+//#endregion
+//#region src/adapters/compatibility/run-presentation/run-presentation-projector.ts
+function createRunPresentationProjector() {
+	const projector = createRunPresentationProjector$1();
+	return {
+		apply: (event, canonicalText) => projector.apply(event, canonicalText),
+		snapshot: (runId) => projector.snapshot(runId)
+	};
+}
+//#endregion
+//#region src/adapters/compatibility/card-presentation/feishu-card-presentation-store.ts
+var FeishuCardPresentationNotFound = class {
+	runId;
+	_tag = "FeishuCardPresentationNotFound";
+	constructor(runId) {
+		this.runId = runId;
+	}
+};
+function createFeishuCardPresentationStore(options = {}) {
+	const persist = options.persist;
+	return translateService(createCardPresentationService(createInMemoryCardPresentationRepository({
+		...options.initial === void 0 ? {} : { initial: options.initial },
+		...persist === void 0 ? {} : { persist: (chains) => Effect.tryPromise({
+			try: () => persist(chains),
+			catch: (error) => error
+		}) }
+	})));
+}
+function translateService(service) {
+	const translate = (effect) => effect.pipe(Effect.mapError((error) => error instanceof CardPresentationNotFound ? new FeishuCardPresentationNotFound(error.runId) : error));
+	return {
+		bind: (binding) => translate(service.bind(binding)),
+		beginHandoff: (input) => translate(service.beginHandoff(input)).pipe(Effect.map((result) => ({
+			presentation: result.presentation,
+			started: result.started
+		}))),
+		chain: (runId) => service.chain(runId),
+		chains: () => service.chains(),
+		compensateInterruptedHandoffs: (compensatedAt) => translate(service.compensateInterruptedHandoffs(compensatedAt)),
+		completeHandoff: (input) => translate(service.completeHandoff(input)),
+		failHandoff: (input) => translate(service.failHandoff(input)),
+		markTerminal: (input) => translate(service.markTerminal(input)),
+		release: (runId) => translate(service.release(runId)),
+		size: () => service.size()
+	};
+}
+//#endregion
+//#region src/adapters/feishu/delivery/cot/feishu-periodic-flush.ts
+function createFeishuPeriodicFlush(options) {
+	const loop = Effect.forever(Effect.gen(function* () {
+		yield* options.sleep(options.intervalMs);
+		yield* options.flush();
+	}));
+	return { withPeriodicFlush: (effect) => Effect.raceFirst(effect, loop) };
+}
+//#endregion
+//#region src/core/application/background-session/ports/background-session-delivery-store.ts
+var BackgroundSessionDeliveryConflict = class extends Error {
+	name = "BackgroundSessionDeliveryConflict";
+	constructor(deliveryId, message) {
+		super(`${deliveryId}: ${message}`);
+	}
+};
+//#endregion
+//#region src/adapters/compatibility/background-session/authority.ts
+function extendBackgroundSessionDefinition(definition) {
+	return extendBackgroundSessionDefinition$1(definition, createSha256Digest);
+}
+function narrowBackgroundSessionDefinition(definition) {
+	return narrowBackgroundSessionDefinition$1(definition, createSha256Digest);
+}
+//#endregion
+//#region src/adapters/compatibility/background-session/transitions.ts
+function isBackgroundSessionTerminalPhase(phase) {
+	return phase === "stopped" || phase === "completed" || phase === "failed" || phase === "reconciliation-required";
+}
+var BackgroundSessionTransitionDenied = class extends Error {
+	sessionId;
+	name = "BackgroundSessionTransitionDenied";
+	constructor(sessionId, message) {
+		super(message);
+		this.sessionId = sessionId;
+	}
+};
+function isDomainTransitionError(error) {
+	if (!(error instanceof Error) || error.name !== "BackgroundSessionTransitionDenied") return false;
+	return typeof error.sessionId === "string";
+}
+function mapDomainError(error) {
+	if (isDomainTransitionError(error)) throw new BackgroundSessionTransitionDenied(error.sessionId, error.message);
+	throw error;
+}
+function runTransition(operation) {
+	try {
+		return operation();
+	} catch (error) {
+		mapDomainError(error);
+	}
+}
+function createBackgroundSession(input) {
+	return runTransition(() => createBackgroundSession$1(input).toSnapshot());
+}
+function claimBackgroundSession(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).claim(input).state.toSnapshot());
+}
+function renewBackgroundSessionLease(state, lease) {
+	return runTransition(() => restoreBackgroundSession(state).renewLease(lease).state.toSnapshot());
+}
+function releaseBackgroundSessionLease(state) {
+	return runTransition(() => restoreBackgroundSession(state).releaseLease().state.toSnapshot());
+}
+function suspendBackgroundSession(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).suspend(input).state.toSnapshot());
+}
+function completeBackgroundSessionStep(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).completeStep(input).state.toSnapshot());
+}
+function failBackgroundSessionStep(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).failStep(input).state.toSnapshot());
+}
+function requestBackgroundSessionStop(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).requestStop(input).state.toSnapshot());
+}
+function completeBackgroundSessionStop(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).completeStop(input).state.toSnapshot());
+}
+function parkBackgroundSessionForReconciliation(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).parkForReconciliation(input).state.toSnapshot());
+}
+function resolveBackgroundSessionReconciliation(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).resolveReconciliation(input).state.toSnapshot());
+}
+function appendBackgroundSessionInput(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).appendInput(input).state.toSnapshot());
+}
+function requeueInterruptedBackgroundSessionStep(state, input) {
+	return runTransition(() => restoreBackgroundSession(state).requeueInterruptedStep(input).state.toSnapshot());
+}
+function isBackgroundSessionDue(state, now) {
+	return restoreBackgroundSession(state).isDue(now);
+}
+function isBackgroundSessionLeaseExpired(state, now) {
+	return restoreBackgroundSession(state).isLeaseExpired(now);
+}
+//#endregion
+//#region src/adapters/compatibility/automation/automation-mandate-store.ts
+function createAutomationMandateStore() {
+	return createAutomationMandateStore$1({
+		mandateId: (binding) => createStableId("mandate", binding),
+		tickId: (mandateId, occurrence) => createStableId("tick", {
+			id: mandateId,
+			occurrence
+		})
+	});
+}
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/outcome-transaction.ts
+const preparePluginState = Symbol("preparePluginState");
+const commitPluginState = Symbol("commitPluginState");
+const prepareDeliveryJob = Symbol("prepareDeliveryJob");
+const commitDeliveryJob = Symbol("commitDeliveryJob");
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/plugin-state-store.ts
+var PluginStateConflict = class extends Error {
+	name = "PluginStateConflict";
+};
+function createPluginStateStore() {
+	const records = /* @__PURE__ */ new Map();
+	const id = (p, a, k) => `${p}/${a}/${k}`;
+	const store = {
+		[commitPluginState]: (prepared) => {
+			records.set(prepared.key, prepared.record);
+		},
+		[preparePluginState]: (input) => {
+			const key = id(input.pluginId, input.agentId, input.key);
+			if ((records.get(key)?.revision ?? 0) !== input.expectedRevision) throw new PluginStateConflict("plugin state revision conflict");
+			return {
+				key,
+				record: Object.freeze({
+					agentId: input.agentId,
+					key: input.key,
+					pluginId: input.pluginId,
+					revision: input.expectedRevision + 1,
+					value: input.value
+				})
+			};
+		},
+		get: (pluginId, agentId, key) => records.get(id(pluginId, agentId, key)),
+		put: (input) => {
+			const prepared = store[preparePluginState](input);
+			store[commitPluginState](prepared);
+			return prepared.record;
+		}
+	};
+	return store;
+}
+//#endregion
+//#region src/core/application/automation/outcome/delivery-job-transition.ts
+var DeliveryJobTransitionDenied = class extends Error {
+	name = "DeliveryJobTransitionDenied";
+};
+function recordDeliveryJobAttempt(current, result, receiptId) {
+	if (current.status !== "pending") throw new DeliveryJobTransitionDenied(`Automation delivery job cannot transition while ${current.status}`);
+	if (result.kind === "uncertain") return Object.freeze({
+		...current,
+		status: "reconciliation-required"
+	});
+	if (!receiptId) throw new DeliveryJobTransitionDenied("delivered Automation job requires a receipt ID");
+	return Object.freeze({
+		...current,
+		receiptId,
+		status: "delivered"
+	});
+}
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/delivery-outbox.ts
+var DeliveryOutboxError = class extends Error {
+	name = "DeliveryOutboxError";
+};
+function createDeliveryOutbox() {
+	const jobs = /* @__PURE__ */ new Map();
+	const outbox = {
+		[commitDeliveryJob]: (job) => {
+			jobs.set(job.id, job);
+		},
+		[prepareDeliveryJob]: (input) => jobs.get(input.id) ?? Object.freeze({
+			...input,
+			status: "pending"
+		}),
+		enqueue: (input) => {
+			const job = outbox[prepareDeliveryJob](input);
+			outbox[commitDeliveryJob](job);
+			return job;
+		},
+		recordAttempt: (id, result) => {
+			const current = jobs.get(id);
+			if (!current) throw new DeliveryOutboxError(`unknown delivery job: ${id}`);
+			const next = recordDeliveryJobAttempt(current, result, result.kind === "delivered" ? createStableId("receipt", {
+				id,
+				providerMessageId: result.providerMessageId
+			}) : void 0);
+			jobs.set(id, next);
+			return next;
+		},
+		snapshot: () => Object.freeze([...jobs.values()])
+	};
+	return outbox;
+}
+//#endregion
+//#region src/core/application/delegation/grant/delegation-service.ts
+var DelegationDenied = class extends Error {
+	name = "DelegationDenied";
+};
+function createDelegationService$1(options) {
+	const edges = options.edges.map((edge) => Object.freeze({
+		...edge,
+		toolIds: Object.freeze([...edge.toolIds])
+	}));
+	return Object.freeze({ delegate: (request) => Effect.try({
+		catch: toDelegationFailure,
+		try: () => createGrant(edges, options.grantOperations, options.createId, request)
+	}) });
+}
+function createGrant(edges, grantOperations, createId, request) {
+	const caller = resolveInvocationAuthority(request.callerAuthority);
+	const edge = authorizePeerDelegation(edges, caller.agentId, request);
+	const toolGrantSet = grantOperations.narrow(caller.toolGrantSet, [
+		edge.toolIds,
+		request.targetToolGrantSet.toolIds,
+		request.requestedToolIds
+	]);
+	const id = `delegation:${createId()}`;
+	return Object.freeze({
+		authority: createInvocationAuthority({
+			agentId: request.targetAgentId,
+			instanceId: request.targetInstanceId,
+			runId: id,
+			sessionKey: caller.sessionKey,
+			sourceMessageId: caller.sourceMessageId,
+			tenantKey: caller.tenantKey,
+			toolGrantSet
+		}),
+		id,
+		request: Object.freeze({ ...request }),
+		toolGrantSet
+	});
+}
+function authorizePeerDelegation(edges, callerAgentId, request) {
+	const edge = edges.find((candidate) => candidate.fromAgentId === callerAgentId && candidate.toAgentId === request.targetAgentId);
+	if (!edge) throw new DelegationDenied("peer delegation edge is not configured");
+	if (!Number.isInteger(request.hopCount) || request.hopCount < 0) throw new DelegationDenied("delegation hop count must be a non-negative integer");
+	if (!Number.isFinite(request.budget) || request.budget < 0) throw new DelegationDenied("delegation budget must be a non-negative finite number");
+	if (request.hopCount > edge.maxHops) throw new DelegationDenied("delegation hop limit exceeded");
+	if (request.budget > edge.maxBudget) throw new DelegationDenied("delegation budget exceeded");
+	return edge;
+}
+function toDelegationFailure(error) {
+	if (error instanceof DelegationDenied || error instanceof InvalidInvocationAuthority) return error;
+	return new DelegationDenied("delegation grant could not be created", { cause: error });
+}
+//#endregion
+//#region src/adapters/compatibility/delegation/runtime/effect-runner.ts
+function runDelegationEffect(effect) {
+	const exit = Effect.runSyncExit(effect);
+	if (Exit.isSuccess(exit)) return exit.value;
+	const failure = Cause.failureOption(exit.cause);
+	throw Option.isSome(failure) ? failure.value : Cause.squash(exit.cause);
+}
+//#endregion
+//#region src/adapters/compatibility/delegation/delegation-service.ts
+const grantOperations$1 = createRivusToolGrantSetOperations({
+	digest: createSha256Digest,
+	deepFreeze
+});
+function createDelegationService(options) {
+	const service = createDelegationService$1({
+		...options,
+		createId: createRandomId,
+		grantOperations: grantOperations$1
+	});
+	return Object.freeze({ delegate: (request) => runDelegationEffect(service.delegate(request)) });
+}
+function intersectToolIds(sets) {
+	return grantOperations$1.intersect(sets);
+}
+//#endregion
+//#region src/core/application/delegation/subagent/subagent-coordinator.ts
+var ParentDelegationCancelled = class extends Error {
+	name = "ParentDelegationCancelled";
+};
+function createSubagentCoordinator$1(options) {
+	const records = /* @__PURE__ */ new Map();
+	const cancelledParents = /* @__PURE__ */ new Set();
+	const serial = Effect.unsafeMakeSemaphore(1);
+	return Object.freeze({
+		cancelParent: (parentRunId) => serial.withPermits(1)(Effect.gen(function* () {
+			cancelledParents.add(parentRunId);
+			const active = [...records.values()].filter((record) => record.parentRunId === parentRunId && record.status === "active");
+			yield* Effect.forEach(active, (record) => options.cancellation.cancel(record).pipe(Effect.tap(() => Effect.sync(() => {
+				records.set(record.id, Object.freeze({
+					...record,
+					status: "cancelled"
+				}));
+			}))), {
+				concurrency: 1,
+				discard: true
+			});
+		})),
+		get: (id) => records.get(id),
+		spawn: (request) => serial.withPermits(1)(Effect.try({
+			catch: toSubagentFailure,
+			try: () => prepareSubagent(request, options.grantOperations, options.createId)
+		}).pipe(Effect.flatMap((record) => {
+			if (cancelledParents.has(record.parentRunId)) return Effect.fail(new ParentDelegationCancelled(`parent run is cancelled: ${record.parentRunId}`));
+			return options.runner.start(record).pipe(Effect.tap(() => Effect.sync(() => {
+				records.set(record.id, record);
+			})), Effect.as(record));
+		})))
+	});
+}
+function prepareSubagent(request, grantOperations, createId) {
+	const parent = resolveInvocationAuthority(request.parentAuthority);
+	const id = `subagent:${createId()}`;
+	const toolGrantSet = grantOperations.narrow(parent.toolGrantSet, [
+		request.requestedToolIds,
+		request.childProfileToolIds,
+		request.childDeploymentToolIds
+	]);
+	return Object.freeze({
+		authority: createInvocationAuthority({
+			agentId: request.childAgentId,
+			instanceId: id,
+			runId: id,
+			sessionKey: parent.sessionKey,
+			sourceMessageId: parent.sourceMessageId,
+			tenantKey: parent.tenantKey,
+			toolGrantSet
+		}),
+		capabilities: Object.freeze({
+			privateMemory: false,
+			senderIdentity: false,
+			shell: false
+		}),
+		childAgentId: request.childAgentId,
+		id,
+		parentRunId: parent.runId,
+		status: "active",
+		toolGrantSet: Object.freeze({
+			revision: toolGrantSet.revision,
+			toolIds: Object.freeze([...toolGrantSet.toolIds])
+		})
+	});
+}
+function toSubagentFailure(error) {
+	return error instanceof Error ? error : new InvalidInvocationAuthority("subagent authority could not be created");
+}
+//#endregion
+//#region src/adapters/compatibility/delegation/subagent-coordinator.ts
+const grantOperations = createRivusToolGrantSetOperations({
+	digest: createSha256Digest,
+	deepFreeze
+});
+function createSubagentCoordinator() {
+	return adaptEffectSubagentCoordinator(createSubagentCoordinator$1({
+		cancellation: { cancel: () => Effect.void },
+		createId: createRandomId,
+		grantOperations,
+		runner: { start: () => Effect.void }
+	}));
+}
+function adaptEffectSubagentCoordinator(coordinator) {
+	return Object.freeze({
+		cancelParent: (parentRunId) => runDelegationEffect(coordinator.cancelParent(parentRunId)),
+		get: (id) => coordinator.get(id),
+		spawn: (request) => runDelegationEffect(coordinator.spawn(request))
+	});
+}
+//#endregion
+//#region src/adapters/compatibility/deployment-control/rivus-plugin-loader.ts
+function loadRivusDeployment(options) {
+	return runDeploymentControlEffect(resolveRivusDeployment({
+		agentCatalog: createCompatibleRivusAgentCatalog({ backgroundSessions: options.manifest.backgroundSessions?.enabled === true }),
+		createStableId,
+		deepFreeze,
+		deploymentRoot: options.deploymentRoot,
+		manifest: options.manifest,
+		pluginLoader: createCompatibilityRivusPluginLoader(options.loadModule)
+	}));
+}
+function createCompatibilityRivusPluginLoader(loadModule) {
+	return { load: (request) => Effect.tryPromise({
+		try: () => Promise.resolve(loadModule(request)),
+		catch: toError$1
+	}).pipe(Effect.flatMap(resolveRivusPluginModule)) };
+}
+function toError$1(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+//#region src/adapters/compatibility/deployment-control/node-rivus-plugin-module-loader.ts
+function createNodeRivusPluginModuleLoader(options = {}) {
+	const loader = createNodeRivusPluginModuleLoader$1(options);
+	return (request) => runDeploymentControlEffect(loader.load(request));
+}
+function loadNodeRivusPluginModule(request, options = {}) {
+	return runDeploymentControlEffect(loadNodeRivusPluginModule$1(request, options));
+}
+//#endregion
+//#region src/adapters/compatibility/deployment-control/rivus-deployment-daemon.ts
+function toCompatibilityDaemon(control) {
+	return {
+		deployment: control.deployment,
+		handleDefault: (input) => runDeploymentControlEffect(control.handleDefault(toEffectAgentRuntimeInput$1(input))),
+		handleEndpoint: (endpointId, input) => runDeploymentControlEffect(control.handleEndpoint(endpointId, toEffectAgentRuntimeInput$1(input))),
+		runDefaultAgent: (input) => runDeploymentControlEffect(control.runDefaultAgent(toEffectAgentRuntimeInput$1(input))),
+		running: () => control.running(),
+		start: () => runDeploymentControlEffect(control.start()),
+		status: () => control.status(),
+		stop: () => runDeploymentControlEffect(control.stop())
+	};
+}
+//#endregion
+//#region src/bootstrap/deployment/rivus-deployment-daemon.ts
+function createRivusDeploymentDaemon(options) {
+	const loadModule = options.loadModule;
+	const assemblyInput = {
+		...createProcessDeploymentControlPorts({
+			...options.createAutomation ? { createAutomation: options.createAutomation } : {},
+			...options.createBackgroundSession ? { createBackgroundSession: options.createBackgroundSession } : {},
+			createEndpoint: options.createEndpoint,
+			createRuntime: options.createRuntime
+		}, options.manifest.backgroundSessions?.enabled === true, runDeploymentProcessEffect),
+		deploymentRoot: options.deploymentRoot,
+		...options.initialInstanceRecords ? { initialInstanceRecords: options.initialInstanceRecords } : {},
+		manifest: options.manifest,
+		pluginLoader: createCompatibilityRivusPluginLoader(loadModule),
+		...options.resolveProjectSpace ? { projectSpaceResolver: { resolve: (input) => Effect.tryPromise({
+			try: () => Promise.resolve(options.resolveProjectSpace(input)),
+			catch: toError
+		}) } } : {}
+	};
+	return runDeploymentProcessEffect(Effect.gen(function* () {
+		const deployment = yield* resolveRivusDeployment({
+			agentCatalog: assemblyInput.agentCatalog,
+			createStableId,
+			deepFreeze,
+			deploymentRoot: assemblyInput.deploymentRoot,
+			manifest: assemblyInput.manifest,
+			pluginLoader: assemblyInput.pluginLoader
+		});
+		return yield* createRivusDeploymentControl({
+			...assemblyInput,
+			deployment,
+			digest: createSha256Digest
+		});
+	})).then(toCompatibilityDaemon);
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+//#region src/bootstrap/deployment/configured-rivus-deployment-daemon.ts
+async function createConfiguredRivusDeploymentDaemon(options) {
+	const manifest = await loadRivusDeploymentManifest(options.manifestPath, options.manifestOptions);
+	return createRivusDeploymentDaemon({
+		...options.createAutomation ? { createAutomation: options.createAutomation } : {},
+		...options.createBackgroundSession ? { createBackgroundSession: options.createBackgroundSession } : {},
+		createEndpoint: options.createEndpoint,
+		createRuntime: options.createRuntime,
+		deploymentRoot: dirname(options.manifestPath),
+		...options.initialInstanceRecords ? { initialInstanceRecords: options.initialInstanceRecords } : {},
+		loadModule: createNodeRivusPluginModuleLoader(options.pluginPackageManifestPath ? { packageManifestPath: options.pluginPackageManifestPath } : {}),
+		manifest,
+		resolveProjectSpace: (input) => resolveRivusProjectSpace(input)
+	});
+}
+//#endregion
+//#region src/adapters/compatibility/human-interaction/transitions.ts
+var HumanInteractionTransitionDenied = class extends Error {
+	name = "HumanInteractionTransitionDenied";
+};
+function transitionHumanInteraction(interaction, transition) {
+	const root = toHumanInteractionAggregate(interaction);
+	try {
+		if (transition.type === "resolve") return toHumanInteractionSnapshot(root.resolve(transition).state);
+		if (transition.type === "consume-approval") return toHumanInteractionSnapshot(root.consume(transition).state);
+		return toHumanInteractionSnapshot(root.cancel(transition).state);
+	} catch (error) {
+		if (error instanceof Error && error.name === "HumanInteractionTransitionDenied") throw new HumanInteractionTransitionDenied(error.message);
+		throw error;
+	}
+}
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/effect-runner.ts
+function runAutomationOutcomeEffect(effect) {
+	const exit = Effect.runSyncExit(effect);
+	if (Exit.isSuccess(exit)) return exit.value;
+	const failure = Cause.failureOption(exit.cause);
+	throw Option.isSome(failure) ? failure.value : Cause.squash(exit.cause);
+}
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/commit-automation-outcome.ts
+function commitAutomationOutcome$1(input) {
+	return runAutomationOutcomeEffect(commitAutomationOutcome({
+		outcome: input.outcome,
+		repository: compatibilityRepository(input),
+		stateUpdate: input.stateUpdate,
+		tickId: input.tickId
+	}));
+}
+function compatibilityRepository(input) {
+	return {
+		commit: (command) => Effect.sync(() => commitCompatibilityStores({
+			...input,
+			outcome: command.outcome,
+			stateUpdate: command.stateUpdate,
+			tickId: command.tickId
+		})),
+		recordDeliveryAttempt: () => Effect.fail(new DeliveryOutboxError("delivery attempts use the DeliveryOutbox facade"))
+	};
+}
+function commitCompatibilityStores(input) {
+	if (!isTransactionalState(input.state) || !isTransactionalOutbox(input.outbox)) return commitLegacyOutcome(input);
+	const state = input.state;
+	const preparedState = state[preparePluginState](input.stateUpdate);
+	if (input.outcome.kind === "suppressed") {
+		state[commitPluginState](preparedState);
+		return Object.freeze({ state: preparedState.record });
+	}
+	const outbox = input.outbox;
+	const preparedJob = outbox[prepareDeliveryJob](createDeliveryJob(input.outcome, input.tickId));
+	state[commitPluginState](preparedState);
+	outbox[commitDeliveryJob](preparedJob);
+	return Object.freeze({
+		job: preparedJob,
+		state: preparedState.record
+	});
+}
+function commitLegacyOutcome(input) {
+	if ((input.state.get(input.stateUpdate.pluginId, input.stateUpdate.agentId, input.stateUpdate.key)?.revision ?? 0) !== input.stateUpdate.expectedRevision) throw new DeliveryOutboxError("plugin state revision conflict before outcome commit");
+	const state = input.state.put(input.stateUpdate);
+	if (input.outcome.kind === "suppressed") return Object.freeze({ state });
+	const job = input.outbox.enqueue(createDeliveryJob(input.outcome, input.tickId));
+	return Object.freeze({
+		job,
+		state
+	});
+}
+function createDeliveryJob(outcome, tickId) {
+	return {
+		body: outcome.body,
+		id: createStableId("delivery", {
+			kind: outcome.kind,
+			target: outcome.target,
+			tickId
+		}),
+		kind: outcome.kind,
+		target: outcome.target,
+		tickId
+	};
+}
+function isTransactionalState(store) {
+	return preparePluginState in store && commitPluginState in store;
+}
+function isTransactionalOutbox(outbox) {
+	return prepareDeliveryJob in outbox && commitDeliveryJob in outbox;
+}
+//#endregion
+export { AUTOMATION_PRESENTATION_SCHEMA_VERSION, AUTOMATION_SUPPRESSION_PREFIX, AgentInstanceBusy, AgentInstanceConflict, AgentMemoryError, 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, 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, DEFAULT_CONVERSATION_PROGRESS_DISPLAY, DelegationDenied, DeliveryOutboxError, FEISHU_AGENT_CARD_ELEMENT_ID, FEISHU_AGENT_CARD_PROGRESS_ELEMENT_ID, FeishuCardPresentationNotFound, FeishuCardTargetNotFound, FeishuCardTargetRegistryStoreError, FeishuCotProtocolError, FeishuEndpointCredentialError, FeishuOpenApiError, FeishuTenantAccessTokenError, HumanInteractionRepositoryError, HumanInteractionTransitionDenied, InvalidAgentHostBinding, InvalidAutomationPresentation, InvalidFeishuCardAction, InvalidFeishuMessageContent, InvalidFeishuSessionReference, InvalidFeishuTopicContext, InvalidRivusEndpointBinding, InvalidRivusPlugin, InvalidRivusProjectSpace, MODEL_STATE_SCHEMA_VERSION, ModelChangeAuthorizationRejected, ModelChangeBoundaryDeadlineError, ModelChangeBusy, ModelChangeNotFound, ModelChangeRequestConflict, ModelChangeRevisionConflict, ModelStateCorrupted, OpenClawEnvImportError, PiModelRunContextError, PluginStateConflict, RIVUS_MODEL_CHANGE_TOOL_ID, RIVUS_MODEL_CONTEXT_ENV, RIVUS_MODEL_SOCKET_ENV, RIVUS_PLUGIN_API_VERSION, RIVUS_RELEASE_DESCRIPTOR, RUN_PRESENTATION_SCHEMA_VERSION, RivusDaemonConfigError, RivusDeploymentAutomationReadinessError, RivusDeploymentBackgroundSessionReadinessError, RivusDeploymentDaemonLifecycleError, RivusDeploymentManifestError, RivusDeploymentReadinessError, RivusPluginLoadError, SessionSchedulerCapacityExceeded, SessionSchedulerDisposed, ToolInvocationDenied, UnsupportedFeishuCardAction, UnsupportedFeishuMessage, acceptsCardPresentationProgress, activeCardPresentation, appendBackgroundSessionInput, backgroundSessionToolIds, claimBackgroundSession, commitAutomationOutcome, commitAutomationOutcome$1 as commitLegacyAutomationOutcome, completeBackgroundSessionStep, completeBackgroundSessionStop, composeFeishuTopicPrompt, createAgentCommandFromFeishuCardAction, createAgentCommandFromFeishuMessage, createAgentHarnessPooledRuntime, createAgentHostRuntimePool, createAgentInstanceRegistry, createAgentMemoryService, createAgentRuntimePool, createAgentsMdInstructionsProvider, createAutomationMandateStore, createAutomationPresentation, createAutomationScheduler, createBackgroundSession, createBackgroundSessionCard, createBackgroundSessionDeliveryStore, createBackgroundSessionHostTools, createBackgroundSessionKey, createBackgroundSessionRepository, createBackgroundSessionService, createBackgroundSessionStepSourceMessageId, createBackgroundSessionSupervisor, createBackgroundSessionToolContracts, createCoalescingFeishuPublisher, createCompatibleRivusAgentCatalog, createCompositeRivusDaemonTransport, createConfiguredFeishuAutomationCardSender, createConfiguredFeishuBackgroundSessionDelivery, createConfiguredFeishuCardKitPublisher, createConfiguredFeishuCardKitTargetCreator, createConfiguredFeishuCardRolloverRuntime, createConfiguredFeishuHumanInteractionPresenter, createConfiguredFeishuMessageReactionSender, createConfiguredFeishuOpenApiClient, createConfiguredFeishuTextReplySender, createConfiguredRivusDaemonBootstrap, createConfiguredRivusDeploymentDaemon, createDailyAutomationSchedule, createDelegationService, createDeliveryOutbox, createEffectAgentHost, createEffectAgentInstanceRegistry, 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, createFeishuSessionStore, createFeishuStreamProjector, createFeishuTenantAccessTokenProvider, createFeishuTopicContextResolver, createFeishuWebSocketDaemon, createFeishuWorkerLoop, createHumanInteractionEndpointRegistry, createHumanInteractionModelChangeApproval, createHumanInteractionService, createHumanInteractionToolApprovalGateway, createInMemoryFeishuCardTargetRegistry, createInMemoryHumanInteractionRepository, createJsonFetchRequest, createJsonFileFeishuCardTargetRegistry, createJsonlHumanInteractionRepository, createLazyFeishuWebSocketEventDispatcher, createBackgroundSessionService$1 as createLegacyBackgroundSessionService, createHumanInteractionService$1 as createLegacyHumanInteractionService, createMessageGateway, createModelChangeAuthorization, createModelChangeCoordinator, createModelChangeRunBoundary, createModelManagementControl, createPiManagedRunGatewayProvider, createPiModelManagementBashSpawnHook, createPiModelRunContextRegistry, createPluginStateStore, createPresentedValue, createRateLimitedFeishuPublisher, createRecoveryControl, createRivusAgentCatalog, createRivusAgentHost, createRivusDaemonProcess, createRivusDaemonShutdownController, createRivusDaemonStatusHttpServer, createRivusDaemonStatusReporter, createRivusDeploymentCliProcess, createRivusDeploymentDaemon, createRivusEnvFromOpenClawConfig, createRivusPluginCatalog, createRoutedHumanInteractionToolApprovalService, createRunPresentationProjector, createScheduledAutomation, createSessionScheduler, createSubagentCoordinator, createToolBroker, describeFeishuMessageIntake, diagnoseRivusProject, extendBackgroundSessionDefinition, failBackgroundSessionStep, formatRivusEnvFile, hasInspectableRunProgress, initializeRivusProject, intersectToolIds, isBackgroundSessionDue, isBackgroundSessionLeaseExpired, isBackgroundSessionState, isBackgroundSessionTerminalPhase, isBackgroundSessionToolId, isCardPresentationHandoffDue, loadNodeRivusPluginModule, loadRivusDaemonConfig, loadRivusDeployment, loadRivusDeploymentManifest, narrowBackgroundSessionDefinition, openJsonAutomationTickRepository, openJsonFeishuSessionStore, openJsonlAgentMemoryService, openJsonlBackgroundSessionDeliveryStore, openJsonlBackgroundSessionRepository, openJsonlFeishuCardDeliveryLedger, openJsonlFeishuInboxRepository, openJsonlRecoveryControl, openJsonlToolOperationLedger, openPiModelManagementDeployment, parkBackgroundSessionForReconciliation, progressDeliveryId, readAutomationPresentation, readFeishuMessageContent, readPiModelManagementGrant, releaseBackgroundSessionLease, renewBackgroundSessionLease, requestBackgroundSessionStop, requeueInterruptedBackgroundSessionStep, resolveBackgroundSessionReconciliation, resolveBackgroundSessionSupervisorIntervalMs, resolveFeishuDeliveryChatId, resolveFeishuEndpointCredentials, resolveRivusAgentDefinition, resolveRivusProjectSpace, restoreConfiguredRivusDaemonBootstrap, runRivusCli, runRivusDaemonCli, runRivusNodeEntrypoint, sessionIdFromSessionKey, shouldAcceptFeishuEndpointMessage, suspendBackgroundSession, terminalDeliveryId, transitionHumanInteraction, validateRivusCatalogIdentifier, validateRivusCatalogRegistration, validateRivusDeploymentManifest, validateRivusPluginManifest };