@rivus/agent 0.13.2 → 0.14.0

package/README.md

@@ -10,6 +10,7 @@ The first milestone is intentionally narrow: make the agent loop and agent harne
 
 - TypeScript ESM package.
 - Public Plugin SDK with atomic Plugin registration, immutable Catalog snapshots, deterministic Agent Deployment resolution, an explicit Required/Optional Plugin Loader, safe Node module resolution from a Deployment Root, and a manifest-driven Multi-agent Deployment Daemon. Concrete Agent products remain external packages.
+- Revisioned Pi native Runtime Tool grants with a closed seven-Tool vocabulary, exact Profile ∩ Deployment narrowing, fail-closed defaults, and explicit full capability only in the Personal Home starter. Pi Skill discovery accepts an empty catalog and is limited to user-global plus explicit Project Space roots; project-ambient resources stay disabled.
 - Host-bound Workspace Instructions API and built-in `AGENTS.md` provider with deterministic root-to-target discovery, immutable source digests, nested mutation refresh diagnostics, UTF-8/path/symlink checks, and whole-source byte budgeting. The deployment example injects the root View into Pi while Tool-target refresh remains enforced by the provider boundary.
 - Host-issued invocation authority and a call-time Tool Broker that checks exact grants, pinned versions, online revocation, stable operation IDs, durable side-effect fencing, and one-time approval receipts bound to canonical input digests. The Pi Tool Proxy and Feishu Human Interaction gateway are wired in the deployment example.
 - Multi-agent Host primitives with trusted Endpoint bindings, stable Runtime Generation/Instance identities, lazy per-instance Runtime pooling, isolated active-run gates, and restart restoration from persisted registry records.
@@ -54,22 +55,23 @@ npm install @rivus/agent
 npx rivus --help
 ```
 
-Create a standalone one-Agent project without cloning this repository:
+Create the default Personal Agent Home without cloning this repository or installing another local Rivus copy:
 
 ```bash
-npm install --global @rivus/agent
-rivus init my-rivus-agent
-cd my-rivus-agent
-npm install
-cp .env.example .env.local
-# Fill the Feishu and model-provider values in .env.local.
-npm run doctor
-npm start
+npm install --global \
+  @rivus/agent \
+  @earendil-works/pi-coding-agent@^0.80.6 \
+  @larksuiteoapi/node-sdk@^1.70.0
+rivus setup
+cp "$HOME/.rivus-agent/.env.example" "$HOME/.rivus-agent/.env"
+# Fill the Feishu and model-provider values in ~/.rivus-agent/.env.
+rivus doctor
+rivus start
 ```
 
-`init` refuses to overwrite any generated path. `doctor` checks Node, project files, local dependencies, the deployment manifest, and enabled Endpoint credentials without importing Plugin code or contacting external services. See the [local deployment runbook](docs/en/operations/local-deployment.md) for foreground verification and the generated systemd/launchd templates.
+`setup` refuses to overwrite existing Home files. `start`, `status`, and `check-config` read `RIVUS_HOME` or `~/.rivus-agent`, use its configured Workspace as cwd, and keep state outside npm installation files. `doctor` checks the Home, global modules, manifest, Workspace, and enabled Endpoint credential references without importing Plugin code or contacting external services. Existing standalone projects remain supported through `rivus init <directory>` and `rivus doctor <directory>`. See the [local deployment runbook](docs/en/operations/local-deployment.md).
 
-The Pi plus Feishu example is application-edge code: install `@earendil-works/pi-coding-agent` and `@larksuiteoapi/node-sdk` in the daemon app that uses it. The `@rivus/agent` core package keeps those SDKs out of its runtime dependency graph.
+The Pi plus Feishu Bootstrap is an application-edge package export: install `@earendil-works/pi-coding-agent` and `@larksuiteoapi/node-sdk` beside the global Rivus package. The `@rivus/agent` core keeps those SDKs out of its mandatory runtime dependency graph.
 
 ```bash
 npm install @earendil-works/pi-coding-agent@^0.80.6 @larksuiteoapi/node-sdk@^1.70.0
@@ -87,7 +89,7 @@ vp run check
 
 npm releases are produced only by the `Publish npm` GitHub Actions workflow after a GitHub Release is published for an exact `v<package version>` tag on `main`. The workflow uses npm Trusted Publishing through OIDC and contains no long-lived registry token. See the [npm release runbook](docs/en/operations/npm-release.md) for the one-time first-package bootstrap and normal release procedure.
 
-For a manifest-driven multi-agent deployment, keep `rivus.config.json`, its lockfile, and installed Plugin packages in one deployment project. `createConfiguredRivusDeploymentDaemon()` validates the manifest, resolves only declared modules from that directory, disables deployments belonging to failed Optional Plugins, and blocks startup when a Required Plugin fails:
+For a manifest-driven multi-agent deployment, keep `rivus.config.json` in Rivus Home and install declared Plugin packages beside the global Rivus package. `createConfiguredRivusDeploymentDaemon()` validates the manifest, resolves only declared modules from the Home or Host-trusted npm roots, disables deployments belonging to failed Optional Plugins, and blocks startup when a Required Plugin fails:
 
 ```json
 {
@@ -169,7 +171,7 @@ await daemon.start(); // rejects when an enabled Required Endpoint or Automation
 
 Endpoint factories receive a Host-bound `handle()` function. Inbound payload fields cannot select another Agent or Endpoint. `createConfiguredRivusDaemonBootstrap()` is the small, explicit single-lane Pi/Feishu composition; manifest deployments use the multi-agent path directly, without a parallel compatibility model.
 
-[`examples/rivus.config.json`](examples/rivus.config.json) and [`examples/pi-feishu-deployment.bootstrap.ts`](examples/pi-feishu-deployment.bootstrap.ts) form a concrete two-bot composition. Each `credentialRef: "env:<PREFIX>"` resolves only `<PREFIX>_APP_ID` and `<PREFIX>_APP_SECRET`; each Endpoint owns its WebSocket client, durable Inbox, bounded concurrent worker, CardKit target/delivery state, Human Interaction JSONL repository, and lifecycle. Its unique Manifest Session Namespace is prepended before the trusted Host route reaches a fair per-session Scheduler, Harness lane, and Pi Session Registry. Startup resolves the Bot Open ID, waits for the SDK `onReady` handshake, repairs missing terminal CardKit projections, and applies `groupPolicy` before the durable accept. The example restores a separate event log, Tool operation ledger, and Pi session directory per Agent Instance, plus one deployment-scoped append-only Agent Memory log. Built-in Pi tools, extensions, prompt templates, themes, and ambient Pi context discovery remain disabled. An Agent with a trusted `projectSpaceId` additionally receives only that Project Space's declared native Skill sources and bounded `AGENTS.md` View; Pi handles progressive Skill loading and `/skill:<name>`, while unknown names fail before model execution. Unbound Agents retain the previous inline Rivus Skill reader behavior.
+[`examples/rivus.config.json`](examples/rivus.config.json) and [`examples/pi-feishu-deployment.bootstrap.ts`](examples/pi-feishu-deployment.bootstrap.ts) form a concrete two-bot composition. Each `credentialRef: "env:<PREFIX>"` resolves only `<PREFIX>_APP_ID` and `<PREFIX>_APP_SECRET`; each Endpoint owns its WebSocket client, durable Inbox, bounded concurrent worker, CardKit target/delivery state, Human Interaction JSONL repository, and lifecycle. Its unique Manifest Session Namespace is prepended before the trusted Host route reaches a fair per-session Scheduler, Harness lane, and Pi Session Registry. Startup resolves the Bot Open ID, waits for the SDK `onReady` handshake, repairs missing terminal CardKit projections, and applies `groupPolicy` before the durable accept. The example restores a separate event log, Tool operation ledger, and Pi session directory per Agent Instance, plus one deployment-scoped append-only Agent Memory log. Native Pi tools default to none and are activated only by the resolved `runtimeToolGrantSet`; custom Tools come only from the resolved Agent definition. Extensions, prompt templates, themes, ambient project settings, and ambient Pi Skill discovery remain disabled. Pi loads existing user-global Skill roots plus only the selected Project Space's explicit sources, accepts an empty catalog, and validates every `/skill:<name>` before model execution. A bounded `AGENTS.md` View supplies context without granting authority.
 
 Interactive Endpoints default `progressDisplay` to `collapsed`: public assistant narration and inspectable Skill/Tool actions remain in chronological order, and every action owns a small native collapsible panel rather than being collected into one process appendix. `expanded` opens completed action panels initially and `hidden` omits them; a running action stays open so its safe parameters and current result are visible. A channel-neutral `RunPresentation` read model preserves stable steps, status, duration, and safe Tool input/result projections across streaming updates and successor cards. Sensitive fields are redacted, machine paths normalized, and long values explicitly truncated before a channel renderer sees them; private reasoning and raw Tool payloads never enter the presentation IR. Ordinary replies never gain an empty process panel. A rollover freezes the predecessor exactly as last rendered and starts a blank successor that receives only post-breakpoint content. Scheduled Automations use a separate final-only `AutomationPresentation` IR: Plugins own title, metadata, sections, items, notes, and sources, while the channel renderer owns visual components.
 
@@ -425,7 +427,7 @@ Recognized variables:
 - `RIVUS_WEATHER_DEFAULT_LOCATION` selects the example `current-weather` Tool's fallback city and defaults to `北京`; it is not a Core setting.
 - `RIVUS_TELEMETRY_ENVIRONMENT` defaults to `NODE_ENV`, then `local`; `RIVUS_TELEMETRY_SERVICE_NAME` defaults to `rivus-agent`.
 
-For both SDK bootstrap templates, `PI_MODEL` should use Pi's provider/model form when `PI_API_KEY`, `PI_API_KEY_FILE`, or `PI_BASE_URL` is set, for example `anthropic/claude-opus-4-5` or `zai/glm-5.1` for GLM BYOK. The templates apply the resolved Pi API key through Pi `AuthStorage.setRuntimeApiKey()`, resolve the model through Pi's public `ModelRegistry.find(provider, modelId)` API, and apply `PI_BASE_URL` by writing a local `.rivus/pi-models.json` provider override, matching Pi's `models.json` configuration model.
+For both SDK bootstrap templates, `PI_MODEL` should use Pi's provider/model form when `PI_API_KEY`, `PI_API_KEY_FILE`, or `PI_BASE_URL` is set, for example `anthropic/claude-opus-4-5` or `zai/glm-5.1` for GLM BYOK. The templates apply the resolved Pi API key through Pi `AuthStorage.setRuntimeApiKey()`, resolve the model through Pi's public `ModelRegistry.find(provider, modelId)` API, and apply `PI_BASE_URL` by merging a local `.rivus/pi-models.json` provider override without removing existing custom models or other providers, matching Pi's `models.json` configuration model.
 
 ## Core Usage
 
@@ -463,6 +465,7 @@ catalog.registerPlugin({
       id: "example",
       memory: { scopes: [] },
       model: { provider: "example" },
+      runtimeTools: { allow: ["read", "grep", "find", "ls"] },
       skills: { allow: [] },
       systemPrompt: "Use trusted example sources.",
       tools: { allow: ["example-agent/read"] }
@@ -475,11 +478,13 @@ const definition = resolveRivusAgentDefinition(catalog, {
   endpointIds: ["example-feishu"],
   pluginId: "example-agent",
   profileId: "example",
+  runtimeTools: { allow: ["read", "grep"] },
+  skills: { allow: [] },
   tools: { allow: ["example-agent/read"] }
 });
 ```
 
-The resolved definition exposes immutable Tool schemas and a `ToolGrantSet`; executor factories remain inside the Catalog boundary. Wildcards, duplicate identifiers, unknown references, and incompatible Plugin API versions are rejected.
+The resolved definition exposes immutable Tool schemas, a `ToolGrantSet`, and a `runtimeToolGrantSet` containing only `read` and `grep`; executor factories remain inside the Catalog boundary. Wildcards, duplicate identifiers, unknown references, and incompatible Plugin API versions are rejected. Missing Runtime Tool allowlists resolve to an empty native grant.
 
 External Plugin packages can run reusable conformance checks from the testing subpath:
 

package/dist/acp.d.ts

@@ -1,7 +1,7 @@
-import { s as AgentLoopInput, t as AgentLoop } from "./agent-loop.js";
+import { a as AgentLoopInput, t as AgentLoop } from "./chunks/agent-loop.js";
 import * as acp from "@agentclientprotocol/sdk";
 
-//#region src/infrastructure/acp/acp-agent-loop.d.ts
+//#region src/adapters/acp/runtime/acp-agent-loop.d.ts
 type AcpToolCallStatus = "pending" | "in_progress" | "completed" | "failed";
 interface AcpSessionUpdate {
   readonly content?: unknown;
@@ -25,14 +25,8 @@ interface AcpAgentSession {
   dispose?(): Promise<void> | void;
   invalidate?(): Promise<void> | void;
 }
-interface AcpAgentLoopOptions {
-  readonly cancellationSettleTimeoutMs?: number;
-  readonly disposeSessionAfterRun?: boolean;
-  readonly resolveSession: (input: AgentLoopInput) => Promise<AcpAgentSession> | AcpAgentSession;
-}
-declare function createAcpAgentLoop(options: AcpAgentLoopOptions): AgentLoop;
 //#endregion
-//#region src/infrastructure/acp/acp-permission-policy.d.ts
+//#region src/adapters/acp/runtime/acp-permission-policy.d.ts
 interface AcpPermissionOption {
   readonly kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
   readonly name: string;
@@ -64,24 +58,14 @@ interface AcpSessionPermissionContext {
 type AcpSessionPermissionPolicy = (request: AcpPermissionRequest, context: AcpSessionPermissionContext) => Promise<AcpPermissionSelection | undefined> | AcpPermissionSelection | undefined;
 declare function decideAcpPermission(request: AcpPermissionRequest, policy?: AcpPermissionPolicy): Promise<AcpPermissionDecision>;
 //#endregion
-//#region src/infrastructure/acp/acp-permission-bridge.d.ts
+//#region src/adapters/acp/runtime/acp-permission-bridge.d.ts
 interface AcpPermissionBridge {
   readonly policy: AcpSessionPermissionPolicy;
   bind(sessionKey: string, policy: AcpPermissionPolicy): () => void;
 }
 declare function createAcpPermissionBridge(): AcpPermissionBridge;
 //#endregion
-//#region src/infrastructure/acp/acp-agent-server.d.ts
-interface AcpAgentServerOptions {
-  readonly agentName?: string;
-  readonly loop: AgentLoop;
-  readonly permissionBridge?: AcpPermissionBridge;
-  readonly workingDirectory: string;
-}
-declare function createAcpAgentServer(options: AcpAgentServerOptions): acp.AgentApp;
-declare function serveAcpAgentOnStdio(app: acp.AgentApp): Promise<void>;
-//#endregion
-//#region src/infrastructure/acp/acp-session-store.d.ts
+//#region src/adapters/acp/runtime/acp-session-store.d.ts
 interface AcpSessionRecord {
   readonly sessionId: string;
 }
@@ -99,7 +83,7 @@ interface JsonAcpSessionStoreOptions {
  */
 declare function createJsonAcpSessionStore(options: JsonAcpSessionStoreOptions): AcpSessionStore;
 //#endregion
-//#region src/infrastructure/acp/acp-stdio-agent-loop.d.ts
+//#region src/adapters/acp/runtime/acp-stdio-agent-loop.d.ts
 interface AcpMcpServerEnvironmentVariable {
   readonly name: string;
   readonly value: string;
@@ -110,35 +94,51 @@ interface AcpMcpServer {
   readonly env: ReadonlyArray<AcpMcpServerEnvironmentVariable>;
   readonly name: string;
 }
+declare class AcpSessionResumeUnavailable extends Error {
+  readonly sessionId: string;
+  readonly name = "AcpSessionResumeUnavailable";
+  constructor(sessionId: string);
+}
+declare class AcpSessionResumeFailed extends Error {
+  readonly sessionId: string;
+  readonly cause: unknown;
+  readonly name = "AcpSessionResumeFailed";
+  constructor(sessionId: string, cause: unknown);
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/acp/acp-runtime.d.ts
+interface AcpAgentLoopOptions {
+  readonly cancellationSettleTimeoutMs?: number;
+  readonly disposeSessionAfterRun?: boolean;
+  readonly resolveSession: (input: AgentLoopInput) => Promise<AcpAgentSession> | AcpAgentSession;
+}
+interface AcpAgentServerOptions {
+  readonly loop: AgentLoop;
+  readonly workingDirectory: string;
+  readonly agentName?: string;
+  readonly permissionBridge?: AcpPermissionBridge;
+}
 interface AcpStdioAgentLoopOptions {
-  readonly arguments?: ReadonlyArray<string>;
-  readonly clientName?: string;
   readonly command: string;
-  readonly environment?: Readonly<Record<string, string>>;
-  readonly initializationTimeoutMs?: number;
+  readonly workingDirectory: string;
   readonly mcpServers?: (input: AgentLoopInput) => ReadonlyArray<AcpMcpServer>;
-  readonly onStderr?: (text: string) => void;
-  readonly permissionPolicy?: AcpSessionPermissionPolicy;
   /** Persist provider session IDs so a restarted ACP child can load/resume them. */
   readonly sessionStore?: AcpSessionStore;
+  readonly permissionPolicy?: AcpSessionPermissionPolicy;
+  readonly environment?: Readonly<Record<string, string>>;
+  readonly arguments?: ReadonlyArray<string>;
+  readonly clientName?: string;
+  readonly initializationTimeoutMs?: number;
   readonly terminationTimeoutMs?: number;
-  readonly workingDirectory: string;
+  readonly onStderr?: (text: string) => void;
 }
 interface AcpStdioAgentLoopHandle {
   readonly loop: AgentLoop;
   dispose(): Promise<void>;
 }
+declare function createAcpAgentLoop(options: AcpAgentLoopOptions): AgentLoop;
+declare function createAcpAgentServer(options: AcpAgentServerOptions): acp.AgentApp;
+declare function serveAcpAgentOnStdio(app: acp.AgentApp): Promise<void>;
 declare function createAcpStdioAgentLoop(options: AcpStdioAgentLoopOptions): AcpStdioAgentLoopHandle;
-declare class AcpSessionResumeUnavailable extends Error {
-  readonly sessionId: string;
-  readonly name = "AcpSessionResumeUnavailable";
-  constructor(sessionId: string);
-}
-declare class AcpSessionResumeFailed extends Error {
-  readonly sessionId: string;
-  readonly cause: unknown;
-  readonly name = "AcpSessionResumeFailed";
-  constructor(sessionId: string, cause: unknown);
-}
 //#endregion
 export { type AcpAgentLoopOptions, type AcpAgentServerOptions, type AcpAgentSession, type AcpPermissionBridge, type AcpPermissionDecision, type AcpPermissionOption, type AcpPermissionPolicy, type AcpPermissionRequest, type AcpPermissionSelection, type AcpPermissionToolCall, type AcpPromptResult, type AcpSessionPermissionContext, type AcpSessionPermissionPolicy, type AcpSessionRecord, AcpSessionResumeFailed, AcpSessionResumeUnavailable, type AcpSessionStore, type AcpSessionUpdate, type AcpStdioAgentLoopHandle, type AcpStdioAgentLoopOptions, type AcpToolCallStatus, type JsonAcpSessionStoreOptions, createAcpAgentLoop, createAcpAgentServer, createAcpPermissionBridge, createAcpStdioAgentLoop, createJsonAcpSessionStore, decideAcpPermission, serveAcpAgentOnStdio };

package/dist/acp.js

@@ -1,16 +1,16 @@
-import { c as createAgentLoopToolExecutionEnd, d as createAgentLoopTurnStart, f as createAsyncIterableAgentLoop, l as createAgentLoopToolExecutionStart, o as createAgentLoopTextDelta, s as createAgentLoopThinkingDelta, u as createAgentLoopToolExecutionUpdate } from "./agent-loop.js";
+import { B as createAgentLoopToolExecutionUpdate, I as createAgentLoopTextDelta, L as createAgentLoopThinkingDelta, R as createAgentLoopToolExecutionEnd, V as createAgentLoopTurnStart, c as toEffectAgentLoop, o as fromEffectAgentLoop, s as toCompatibilityAgentLoopInput, z as createAgentLoopToolExecutionStart } from "./chunks/agent-loop.js";
+import "./chunks/spi.js";
+import * as acp from "@agentclientprotocol/sdk";
 import { Effect, Stream } from "effect";
 import { randomUUID } from "node:crypto";
 import { Readable, Writable } from "node:stream";
-import * as acp from "@agentclientprotocol/sdk";
 import { spawn } from "node:child_process";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-//#region src/infrastructure/acp/acp-agent-loop.ts
-function createAcpAgentLoop(options) {
-	const loop = createAsyncIterableAgentLoop({ run: (input) => runAcpSession(input, options) });
+//#region src/adapters/acp/runtime/acp-agent-loop.ts
+function createAcpAgentLoop$1(options) {
 	return {
-		run: (input) => loop.run(input),
+		run: (input) => Stream.fromAsyncIterable(runAcpSession(input, options), (error) => error),
 		supportsSteering: true
 	};
 }
@@ -41,7 +41,8 @@ async function* runAcpSession(input, options) {
 		});
 	};
 	input.abortSignal.addEventListener("abort", onAbort, { once: true });
-	let steering = input.steering?.next();
+	const takeSteering = () => input.steering ? Effect.runPromise(input.steering.next()) : void 0;
+	let steering = takeSteering();
 	try {
 		if (input.abortSignal.aborted) onAbort();
 		while (!currentTurn.completed || updates.length > 0) {
@@ -68,7 +69,7 @@ async function* runAcpSession(input, options) {
 						wake?.();
 						wake = void 0;
 					});
-					steering = input.steering?.next();
+					steering = takeSteering();
 				}
 				if (signal.type === "turn_completed" && currentTurn.completed) break;
 				if (signal.type === "wake") wake = void 0;
@@ -196,8 +197,8 @@ function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
-//#region src/infrastructure/acp/acp-agent-server.ts
-function createAcpAgentServer(options) {
+//#region src/adapters/acp/runtime/acp-agent-server.ts
+function createAcpAgentServer$1(options) {
 	const sessions = /* @__PURE__ */ new Set();
 	const active = /* @__PURE__ */ new Map();
 	return acp.agent({ name: options.agentName ?? "rivus" }).onRequest(acp.methods.agent.initialize, ({ params }) => ({
@@ -254,7 +255,7 @@ function createAcpAgentServer(options) {
 		active.get(params.sessionId)?.abort();
 	});
 }
-async function serveAcpAgentOnStdio(app) {
+async function serveAcpAgentOnStdio$1(app) {
 	const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
 	await app.connect(stream).closed;
 }
@@ -305,22 +306,7 @@ function mapAgentLoopEvent(event) {
 	};
 }
 //#endregion
-//#region src/infrastructure/acp/acp-permission-bridge.ts
-function createAcpPermissionBridge() {
-	const policies = /* @__PURE__ */ new Map();
-	return {
-		bind: (sessionKey, policy) => {
-			if (policies.has(sessionKey)) throw new Error(`ACP permission bridge is already bound: ${sessionKey}`);
-			policies.set(sessionKey, policy);
-			return () => {
-				if (policies.get(sessionKey) === policy) policies.delete(sessionKey);
-			};
-		},
-		policy: async (request, context) => policies.get(context.sessionKey)?.(request)
-	};
-}
-//#endregion
-//#region src/infrastructure/acp/acp-permission-policy.ts
+//#region src/adapters/acp/runtime/acp-permission-policy.ts
 async function decideAcpPermission(request, policy) {
 	const selection = await policy?.(request);
 	if (!selection || !request.options.some((option) => option.optionId === selection.optionId)) return { outcome: "cancelled" };
@@ -330,7 +316,7 @@ async function decideAcpPermission(request, policy) {
 	};
 }
 //#endregion
-//#region src/infrastructure/acp/acp-stdio-agent-loop.ts
+//#region src/adapters/acp/runtime/acp-stdio-agent-loop.ts
 async function buildAcpSession(processConnection, options, input) {
 	const mcpServers = createMcpServers(options, input);
 	const persisted = await options.sessionStore?.load(input.sessionKey);
@@ -375,7 +361,7 @@ async function restoreAcpSession(processConnection, options, sessionId, mcpServe
 		throw new AcpSessionResumeFailed(sessionId, error);
 	}
 }
-function createAcpStdioAgentLoop(options) {
+function createAcpStdioAgentLoop$1(options) {
 	let pendingConnection;
 	let activeConnection;
 	let ownedChild;
@@ -433,7 +419,7 @@ function createAcpStdioAgentLoop(options) {
 			if (child) await terminateChild(child, options.terminationTimeoutMs);
 			await current?.catch(() => void 0);
 		},
-		loop: createAcpAgentLoop({
+		loop: createAcpAgentLoop$1({
 			disposeSessionAfterRun: false,
 			resolveSession: async (input) => {
 				const processConnection = await resolveConnection();
@@ -665,7 +651,61 @@ function withTimeout(promise, timeoutMs, message) {
 	});
 }
 //#endregion
-//#region src/infrastructure/acp/acp-session-store.ts
+//#region src/adapters/compatibility/agent-execution/acp/acp-runtime.ts
+function createAcpAgentLoop(options) {
+	return fromEffectAgentLoop(createAcpAgentLoop$1({
+		...options.cancellationSettleTimeoutMs === void 0 ? {} : { cancellationSettleTimeoutMs: options.cancellationSettleTimeoutMs },
+		...options.disposeSessionAfterRun === void 0 ? {} : { disposeSessionAfterRun: options.disposeSessionAfterRun },
+		resolveSession: (input) => options.resolveSession(toCompatibilityAgentLoopInput(input))
+	}));
+}
+function createAcpAgentServer(options) {
+	return createAcpAgentServer$1({
+		...options.agentName === void 0 ? {} : { agentName: options.agentName },
+		loop: toEffectAgentLoop(options.loop),
+		...options.permissionBridge ? { permissionBridge: options.permissionBridge } : {},
+		workingDirectory: options.workingDirectory
+	});
+}
+function serveAcpAgentOnStdio(app) {
+	return serveAcpAgentOnStdio$1(app);
+}
+function createAcpStdioAgentLoop(options) {
+	const handle = createAcpStdioAgentLoop$1({
+		...options.arguments ? { arguments: options.arguments } : {},
+		...options.clientName === void 0 ? {} : { clientName: options.clientName },
+		command: options.command,
+		...options.environment ? { environment: options.environment } : {},
+		...options.initializationTimeoutMs === void 0 ? {} : { initializationTimeoutMs: options.initializationTimeoutMs },
+		...options.mcpServers ? { mcpServers: (input) => options.mcpServers(toCompatibilityAgentLoopInput(input)) } : {},
+		...options.onStderr ? { onStderr: options.onStderr } : {},
+		...options.permissionPolicy ? { permissionPolicy: options.permissionPolicy } : {},
+		...options.sessionStore ? { sessionStore: options.sessionStore } : {},
+		...options.terminationTimeoutMs === void 0 ? {} : { terminationTimeoutMs: options.terminationTimeoutMs },
+		workingDirectory: options.workingDirectory
+	});
+	return {
+		dispose: () => handle.dispose(),
+		loop: fromEffectAgentLoop(handle.loop)
+	};
+}
+//#endregion
+//#region src/adapters/acp/runtime/acp-permission-bridge.ts
+function createAcpPermissionBridge() {
+	const policies = /* @__PURE__ */ new Map();
+	return {
+		bind: (sessionKey, policy) => {
+			if (policies.has(sessionKey)) throw new Error(`ACP permission bridge is already bound: ${sessionKey}`);
+			policies.set(sessionKey, policy);
+			return () => {
+				if (policies.get(sessionKey) === policy) policies.delete(sessionKey);
+			};
+		},
+		policy: async (request, context) => policies.get(context.sessionKey)?.(request)
+	};
+}
+//#endregion
+//#region src/adapters/acp/runtime/acp-session-store.ts
 /**
 * A small deployment-owned store for ACP provider session identities.
 * The file contains no prompts or credentials, only session-key bindings.

package/dist/bootstrap/pi-feishu.d.ts

@@ -0,0 +1,20 @@
+import { A as CreateRivusDeploymentBackgroundSessionInput, F as RivusDeploymentBackgroundSession, Fc as AgentRuntimeInput, M as CreateRivusDeploymentEndpointInput, Mc as SessionSchedulerStatus, N as CreateRivusDeploymentRuntimeInput, Pc as AgentRuntimeCancellation, Rc as AgentRuntimeSteering, aa as RivusDeploymentBootstrapContext, dt as ScheduledAutomation, k as CreateRivusDeploymentAutomationInput, la as ProcessDeploymentEndpoint, pl as RecoveryControl } from "../chunks/index.js";
+
+//#region examples/pi-feishu-deployment.bootstrap.d.ts
+declare function createRivusDeploymentAdapters(context: RivusDeploymentBootstrapContext): Promise<{
+  dispose: () => Promise<void> | undefined;
+  createRecoveryControl: () => Promise<RecoveryControl>;
+  createBackgroundSession: ((input: CreateRivusDeploymentBackgroundSessionInput) => RivusDeploymentBackgroundSession) | undefined;
+  createAutomation: (input: CreateRivusDeploymentAutomationInput) => Promise<ScheduledAutomation>;
+  createEndpoint: (input: CreateRivusDeploymentEndpointInput) => Promise<ProcessDeploymentEndpoint>;
+  createRuntime: (input: CreateRivusDeploymentRuntimeInput) => Promise<{
+    dispose: () => Promise<void>;
+    concurrency: "managed";
+    status(): SessionSchedulerStatus;
+    cancel?(input: AgentRuntimeCancellation): Promise<boolean>;
+    steer?(input: AgentRuntimeSteering): Promise<boolean>;
+    run(input: AgentRuntimeInput): Promise<unknown>;
+  }>;
+}>;
+//#endregion
+export { createRivusDeploymentAdapters };