@alfe.ai/claude-code-host 0.1.0

package/dist/host-config.js

@@ -0,0 +1,1221 @@
+import { AgentApiClient } from "@alfe.ai/agent-api-client";
+import { ChatServiceClient, resolveAlfeChat } from "@alfe.ai/chat";
+import { mkdir, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { existsSync } from "node:fs";
+import { resolveConfig } from "@alfe.ai/config";
+//#region src/child-env.ts
+/**
+* Child-process environment construction for spawned `claude` CLI processes.
+*
+* TWO non-negotiable invariants (Phase 2 plan, audit B2 + the hard
+* constraints):
+*
+* 1. **Scrub `ANTHROPIC_API_KEY` / `ANTHROPIC_BASE_URL` /
+*    `ANTHROPIC_AUTH_TOKEN`.** A self-hosted Mac very often has these set (for
+*    other tooling). If ANY of them reaches `claude`, the CLI silently switches
+*    from the user's Claude subscription (OAuth) to API-key/proxy auth — which
+*    is exactly what this whole runtime exists to avoid (no Agent SDK, no
+*    proxy, subscription only). The break is SILENT: the turn "works" but bills
+*    the wrong plane. So we strip them unconditionally from the child env.
+*
+* 2. **Set `ALFE_CLAUDE_BRIDGE=1`.** The Phase-1 CLI hooks
+*    (`alfe claude hook ...` in `packages/cli/src/commands/claude.ts`) check
+*    `process.env.ALFE_CLAUDE_BRIDGE` FIRST and no-op when set, so the host —
+*    not the interactive-session hooks — owns memory recall/capture for bridged
+*    turns. Omitting this double-captures every message. The env var NAME is a
+*    cross-phase contract; do not rename without updating the CLI.
+*/
+/** Anthropic env vars that force API-key / proxy auth and MUST be scrubbed. */
+const SCRUBBED_ANTHROPIC_ENV_VARS = [
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_BASE_URL",
+	"ANTHROPIC_AUTH_TOKEN"
+];
+/** Cross-phase contract marker (see header + packages/cli/src/commands/claude.ts). */
+const BRIDGE_ENV_VAR = "ALFE_CLAUDE_BRIDGE";
+/**
+* Build the env handed to a spawned `claude` child. Pure — takes the base env
+* explicitly so it unit-tests without touching `process.env`.
+*
+* - Every scrubbed Anthropic var is DELETED (not blanked) so `claude`'s
+*   env-detection treats it as absent.
+* - `ALFE_CLAUDE_BRIDGE=1` is set.
+* - Any caller-supplied `extra` entries are layered last (e.g. a per-turn
+*   marker) but can NEVER re-introduce a scrubbed var — the scrub runs after
+*   the merge as the final gate.
+*/
+function buildChildEnv(base, extra) {
+	const merged = {
+		...base,
+		...extra,
+		[BRIDGE_ENV_VAR]: "1"
+	};
+	const scrubbed = new Set(SCRUBBED_ANTHROPIC_ENV_VARS);
+	const env = {};
+	for (const [key, value] of Object.entries(merged)) if (!scrubbed.has(key)) env[key] = value;
+	return env;
+}
+//#endregion
+//#region src/stream-mapper.ts
+function createMapperState() {
+	return {
+		claudeSessionId: null,
+		seq: 0,
+		visibleText: "",
+		pendingTools: /* @__PURE__ */ new Map(),
+		ended: false
+	};
+}
+const MAX_ARGS_CHARS = 2e3;
+const MAX_RESULT_CHARS = 4e3;
+function capText(value, max) {
+	if (value.length <= max) return {
+		text: value,
+		truncated: false
+	};
+	return {
+		text: value.slice(0, max),
+		truncated: true
+	};
+}
+function safeJson(value, max) {
+	if (value === void 0 || value === null) return void 0;
+	let raw;
+	if (typeof value === "string") raw = value;
+	else try {
+		raw = JSON.stringify(value);
+	} catch {
+		return;
+	}
+	if (!raw) return void 0;
+	return capText(raw, max);
+}
+function asRecord(v) {
+	return v && typeof v === "object" ? v : void 0;
+}
+function asString(v) {
+	return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+/**
+* Extract text from a tool_result `content` field, which can be a plain string
+* or an array of `{type:'text', text}` parts (Anthropic block form).
+*/
+function toolResultText(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((c) => {
+		const r = asRecord(c);
+		return r?.type === "text" && typeof r.text === "string" ? r.text : "";
+	}).join("");
+}
+/**
+* Map ONE stream-json event → zero or more emissions, mutating `state`.
+*
+* `nowMs` lets the host stamp real wall-clock timestamps (Claude Code events
+* don't all carry ms epochs); the fixture test injects a fixed clock.
+*/
+function mapStreamEvent(state, raw, nowMs) {
+	const evt = asRecord(raw);
+	if (!evt) return [];
+	const type = evt.type;
+	if (type === "system" && evt.subtype === "init") {
+		const sid = asString(evt.session_id);
+		if (sid) state.claudeSessionId = sid;
+		return [];
+	}
+	if (type === "stream_event") {
+		const inner = asRecord(evt.event);
+		if (!inner) return [];
+		if (inner.type === "content_block_delta") {
+			const delta = asRecord(inner.delta);
+			if (!delta) return [];
+			if (delta.type === "thinking_delta") {
+				const text = asString(delta.thinking);
+				if (!text) return [];
+				return [{
+					type: "chat-activity",
+					seq: state.seq++,
+					ts: nowMs,
+					activity: {
+						kind: "thinking",
+						text,
+						delta: true,
+						ts: nowMs
+					}
+				}];
+			}
+			if (delta.type === "text_delta") {
+				const text = asString(delta.text);
+				if (text === void 0) return [];
+				state.visibleText += text;
+				return [{
+					type: "chat-delta",
+					seq: state.seq++,
+					ts: nowMs,
+					text: state.visibleText
+				}];
+			}
+			return [];
+		}
+		return [];
+	}
+	if (type === "assistant") {
+		const content = asRecord(evt.message)?.content;
+		if (!Array.isArray(content)) return [];
+		const emissions = [];
+		for (const block of content) {
+			const b = asRecord(block);
+			if (b?.type !== "tool_use") continue;
+			const id = asString(b.id);
+			const name = asString(b.name);
+			if (!id || !name) continue;
+			const args = safeJson(b.input, MAX_ARGS_CHARS);
+			state.pendingTools.set(id, {
+				name,
+				argsText: args?.text,
+				argsTruncated: args?.truncated,
+				startTs: nowMs
+			});
+			const activity = {
+				kind: "tool",
+				toolCallId: id,
+				name,
+				status: "running",
+				...args ? { argsText: args.text } : {},
+				...args?.truncated ? { truncated: { args: true } } : {},
+				ts: nowMs
+			};
+			emissions.push({
+				type: "chat-activity",
+				seq: state.seq++,
+				ts: nowMs,
+				activity
+			});
+		}
+		return emissions;
+	}
+	if (type === "user") {
+		const content = asRecord(evt.message)?.content;
+		if (!Array.isArray(content)) return [];
+		const emissions = [];
+		for (const block of content) {
+			const b = asRecord(block);
+			if (b?.type !== "tool_result") continue;
+			const toolUseId = asString(b.tool_use_id);
+			if (!toolUseId) continue;
+			const pending = state.pendingTools.get(toolUseId);
+			const isError = b.is_error === true;
+			const resultRaw = toolResultText(b.content);
+			const result = resultRaw !== void 0 ? capText(resultRaw, MAX_RESULT_CHARS) : void 0;
+			const durationMs = pending ? Math.max(0, nowMs - pending.startTs) : void 0;
+			const truncated = {};
+			if (pending?.argsTruncated) truncated.args = true;
+			if (result?.truncated) truncated.result = true;
+			const activity = {
+				kind: "tool",
+				toolCallId: toolUseId,
+				name: pending?.name ?? "tool",
+				status: isError ? "failed" : "done",
+				...pending?.argsText ? { argsText: pending.argsText } : {},
+				...result ? { resultText: result.text } : {},
+				isError,
+				...durationMs !== void 0 ? { durationMs } : {},
+				...truncated.args || truncated.result ? { truncated } : {},
+				ts: nowMs
+			};
+			state.pendingTools.delete(toolUseId);
+			emissions.push({
+				type: "chat-activity",
+				seq: state.seq++,
+				ts: nowMs,
+				activity
+			});
+		}
+		return emissions;
+	}
+	if (type === "result") {
+		state.ended = true;
+		const isError = evt.is_error === true;
+		const finalText = asString(evt.result) ?? state.visibleText;
+		const durationRaw = evt.duration_ms;
+		const durationMs = typeof durationRaw === "number" && Number.isFinite(durationRaw) ? durationRaw : void 0;
+		const errorMessage = isError ? asString(evt.result) ?? asString(evt.subtype) ?? "Claude Code turn failed" : void 0;
+		return [{
+			type: "turn-end",
+			seq: state.seq++,
+			ts: nowMs,
+			isError,
+			finalText: isError ? "" : finalText,
+			...durationMs !== void 0 ? { durationMs } : {},
+			...errorMessage ? { errorMessage } : {}
+		}];
+	}
+	return [];
+}
+/**
+* Convenience: run the reducer over a whole array of parsed events (e.g. a
+* fixture). Returns the final state + all emissions in order. The host does NOT
+* use this at runtime (it maps line-by-line as they stream), but it's the
+* cleanest thing to assert against in a fixture test.
+*/
+function mapStreamEvents(events, clock = () => Date.now()) {
+	const state = createMapperState();
+	const emissions = [];
+	for (const evt of events) for (const e of mapStreamEvent(state, evt, clock())) emissions.push(e);
+	return {
+		state,
+		emissions
+	};
+}
+/**
+* Terminalize the mapper's in-turn activity into persisted `ChatActivityRecord`
+* form (session store). Tools still pending at flush time (no tool_result seen)
+* are persisted as `interrupted`. Thinking deltas are concatenated into ONE
+* record. This mirrors openclaw-chat's per-turn accumulator flush.
+*/
+function collectTurnActivityRecords(emissions) {
+	const thinking = {
+		text: "",
+		ts: 0
+	};
+	const tools = /* @__PURE__ */ new Map();
+	for (const e of emissions) {
+		if (e.type !== "chat-activity") continue;
+		if (e.activity.kind === "thinking") {
+			if (!thinking.text) thinking.ts = e.ts;
+			thinking.text += e.activity.text;
+		} else {
+			const a = e.activity;
+			const prev = tools.get(a.toolCallId);
+			const status = a.status === "running" ? prev?.status ?? "interrupted" : a.status;
+			tools.set(a.toolCallId, {
+				kind: "tool",
+				toolCallId: a.toolCallId,
+				name: a.name,
+				status,
+				...prev?.argsText ?? a.argsText ? { argsText: prev?.argsText ?? a.argsText } : {},
+				...a.resultText ?? prev?.resultText ? { resultText: a.resultText ?? prev?.resultText } : {},
+				...(a.isError ?? prev?.isError) !== void 0 ? { isError: a.isError ?? prev?.isError } : {},
+				...(a.durationMs ?? prev?.durationMs) !== void 0 ? { durationMs: a.durationMs ?? prev?.durationMs } : {},
+				...a.truncated ?? prev?.truncated ? { truncated: a.truncated ?? prev?.truncated } : {},
+				ts: prev?.ts ?? a.ts ?? 0
+			});
+		}
+	}
+	const records = [];
+	if (thinking.text) records.push({
+		kind: "thinking",
+		text: thinking.text,
+		ts: thinking.ts
+	});
+	for (const tool of tools.values()) records.push(tool);
+	records.sort((a, b) => a.ts - b.ts);
+	return records;
+}
+//#endregion
+//#region src/session-driver.ts
+/**
+* SessionDriver — spawns the `claude` CLI and turns its `--output-format
+* stream-json` output into the mapper emissions the host forwards to chat.
+*
+* TWO modes (Phase 2 plan, decision 2026-07-12):
+*
+*  1. **chat (per-turn spawn):** each Alfe turn spawns a fresh
+*     `claude -p <prompt> --resume <claudeSessionId> --output-format stream-json
+*     --include-partial-messages ...`, streams its stdout line-by-line through
+*     `mapStreamEvent`, and resolves when the terminal `result` event lands (or
+*     the child exits). Each conversation carries its own claude session lineage
+*     (via `--resume`), so distinct conversations run as distinct subprocesses —
+*     real concurrency. This is the ONLY mode the chat path uses.
+*
+*  2. **voice (warm-streaming):** a single persistent `claude` process is held
+*     for the call and fed utterances over stdin as `--input-format stream-json`
+*     user messages, so each utterance skips the per-turn cold start.
+*     See `VERIFICATION` below — on the currently-pinned CLI, streaming-input
+*     did NOT behave as a persistent multi-turn channel in a headless
+*     `-p`/`--print` run, so this mode FALLS BACK to per-turn spawn and is
+*     documented as such. The seam is retained so a future CLI that supports a
+*     persistent stdin channel can light it up without touching the host.
+*
+* The driver performs NO chat-protocol work — it only runs `claude` and yields
+* `MapperEmission`s + the resolved claude session id. The host owns all wire
+* shapes, session-store writes, and memory calls.
+*
+* ── VERIFICATION (`--input-format stream-json`, 2026-07-12) ──
+* `claude -p --input-format stream-json --output-format stream-json` accepts a
+* newline-delimited stream of `{"type":"user","message":{...}}` frames on
+* stdin, but in `-p`/`--print` (headless) mode the process still terminates
+* after the FIRST turn's `result` — it does not stay open awaiting a second
+* user frame the way an interactive session does. There is no headless flag to
+* keep the process resident across turns on the pinned CLI. So warm-streaming
+* cannot preserve one continuous multi-turn `claude` process today; the voice
+* mode therefore uses the SAME per-turn spawn as chat (subscription auth +
+* correct session lineage are preserved because `--resume` threads the claude
+* session id). If a future CLI adds a resident headless stdin channel, flip
+* `WARM_STREAMING_SUPPORTED` and implement `runWarmTurn`.
+*/
+/**
+* `--input-format stream-json` does not keep a headless `claude -p` process
+* resident across turns on the pinned CLI (see header VERIFICATION). Until a
+* CLI ships a resident headless stdin channel, warm-streaming falls back to
+* per-turn spawn. Flip this (and implement a resident path) when that lands.
+*/
+const WARM_STREAMING_SUPPORTED = false;
+/** The `claude` binary name. Overridable for tests via the constructor. */
+const DEFAULT_CLAUDE_BIN = "claude";
+/**
+* Restricted tool set for unattended bridged turns (Phase 2 tool-permission
+* posture). An inbound chat message could try to induce a destructive shell
+* command, and these turns run unattended on the user's machine. We therefore
+* pass an explicit allow-list of read/analysis/edit tools and DENY Bash by
+* default, and use `--permission-mode default` (NEVER `bypassPermissions` /
+* `--dangerously-skip-permissions`). See DEVELOPING.md → "Tool-permission
+* posture". Bash is intentionally absent — a bridged turn cannot run arbitrary
+* shell. Callers that want a wider set pass `allowedTools` explicitly.
+*/
+const DEFAULT_ALLOWED_TOOLS = [
+	"Read",
+	"Grep",
+	"Glob",
+	"LS",
+	"Edit",
+	"Write",
+	"WebFetch",
+	"WebSearch",
+	"Task",
+	"TodoWrite"
+];
+/** Sane default permission posture. NEVER `bypassPermissions`. */
+const DEFAULT_PERMISSION_MODE = "default";
+/**
+* Hard cap on a single turn (E2). Deliberately BELOW the chat service's RPC
+* timeout (`AGENT_TIMEOUT_SEC=300` → 305s in daemon-server) so the host settles
+* a maxed-out turn *before* the caller rejects it — an equal cap races the
+* caller and can surface a spurious "stuck then error" flash. Inject-origin
+* turns have an even shorter caller timeout (~125s); those may over-run to this
+* cap, but the late settle is harmlessly no-op'd by the chat service.
+*/
+const TURN_TIMEOUT_MS = 3e5;
+/** Substrings that mark a subscription rate-limit → fail fast (E2). */
+const RATE_LIMIT_MARKERS = [
+	"rate limit",
+	"rate_limit",
+	"429",
+	"overloaded"
+];
+function looksRateLimited(text) {
+	const lower = text.toLowerCase();
+	return RATE_LIMIT_MARKERS.some((m) => lower.includes(m));
+}
+/**
+* Spawns and drives `claude` subprocesses. Tracks a SINGLE in-flight child, so
+* the host creates ONE driver PER TURN (`ClaudeCodeHost.makeDriver`) — a driver
+* shared across concurrent sessions would let the last spawn overwrite the
+* `child` slot and cross-abort / mis-probe the others.
+*/
+var SessionDriver = class {
+	child = null;
+	bin;
+	baseEnv;
+	log;
+	/** Injected spawn — tests replace this with a fake child. */
+	spawnImpl;
+	constructor(opts) {
+		this.bin = opts?.claudeBin ?? DEFAULT_CLAUDE_BIN;
+		this.baseEnv = opts?.baseEnv ?? process.env;
+		this.log = opts?.logger ?? console;
+		this.spawnImpl = opts?.__spawn ?? spawn;
+	}
+	/** True while a `claude` child is running — backs the host's B4 drain probe. */
+	get busy() {
+		return this.child !== null;
+	}
+	/**
+	* Abort the in-flight turn by SIGINT-ing the child (B3). No-op if idle. The
+	* child's exit drives `runTurn` to settle with `aborted: true`.
+	*/
+	abort() {
+		if (this.child) try {
+			this.child.kill("SIGINT");
+		} catch {}
+	}
+	/**
+	* Run ONE turn. Modes reconcile to the same per-turn spawn (see header
+	* VERIFICATION) — `voice` is accepted for API symmetry and future warm mode.
+	*/
+	async runTurn(params, mode = "chat") {
+		return this.runPerTurn(params);
+	}
+	buildArgs(params) {
+		const allowed = (params.allowedTools ?? DEFAULT_ALLOWED_TOOLS).join(",");
+		const args = [
+			"-p",
+			params.prompt,
+			"--output-format",
+			"stream-json",
+			"--include-partial-messages",
+			"--verbose",
+			"--permission-mode",
+			params.permissionMode ?? "default",
+			"--allowedTools",
+			allowed
+		];
+		if (params.claudeSessionId) args.push("--resume", params.claudeSessionId);
+		if (params.mcpConfigPath) args.push("--mcp-config", params.mcpConfigPath);
+		if (params.appendSystemPrompt) args.push("--append-system-prompt", params.appendSystemPrompt);
+		return args;
+	}
+	runPerTurn(params) {
+		const now = params.now ?? (() => Date.now());
+		const state = createMapperState();
+		const emissions = [];
+		let aborted = false;
+		let settled = false;
+		const stderrChunks = [];
+		const args = this.buildArgs(params);
+		const env = buildChildEnv(this.baseEnv);
+		return new Promise((resolve) => {
+			let child;
+			try {
+				child = this.spawnImpl(this.bin, args, {
+					cwd: params.cwd,
+					env,
+					stdio: [
+						"pipe",
+						"pipe",
+						"pipe"
+					]
+				});
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				resolve({
+					claudeSessionId: state.claudeSessionId,
+					emissions,
+					isError: true,
+					finalText: "",
+					errorMessage: `Failed to start claude: ${message}`,
+					aborted: false
+				});
+				return;
+			}
+			this.child = child;
+			const timeout = setTimeout(() => {
+				this.log.warn("[session-driver] turn exceeded the time cap — aborting");
+				try {
+					child.kill("SIGINT");
+				} catch {}
+				finish(true, "Turn exceeded the time cap");
+			}, TURN_TIMEOUT_MS);
+			timeout.unref();
+			const finish = (isError, errorMessage) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				this.child = null;
+				const end = emissions.find((e) => e.type === "turn-end");
+				const endIsError = end?.type === "turn-end" ? end.isError : false;
+				const endText = end?.type === "turn-end" ? end.finalText : state.visibleText;
+				const endErrMsg = end?.type === "turn-end" ? end.errorMessage : void 0;
+				const stderr = stderrChunks.join("");
+				const finalIsError = isError || endIsError;
+				const finalErrMsg = errorMessage ?? endErrMsg ?? (finalIsError ? looksRateLimited(stderr) ? "Claude subscription rate limit hit — try again shortly" : stderr.trim().slice(0, 500) || "Claude Code turn failed" : void 0);
+				resolve({
+					claudeSessionId: state.claudeSessionId,
+					emissions,
+					isError: finalIsError,
+					finalText: finalIsError ? "" : endText,
+					...finalErrMsg ? { errorMessage: finalErrMsg } : {},
+					aborted
+				});
+			};
+			createInterface({ input: child.stdout }).on("line", (line) => {
+				const trimmed = line.trim();
+				if (!trimmed) return;
+				let evt;
+				try {
+					evt = JSON.parse(trimmed);
+				} catch {
+					return;
+				}
+				for (const emission of mapStreamEvent(state, evt, now())) {
+					emissions.push(emission);
+					try {
+						params.onEmission(emission);
+					} catch (err) {
+						this.log.warn(`[session-driver] onEmission threw: ${err instanceof Error ? err.message : String(err)}`);
+					}
+				}
+			});
+			child.stderr.on("data", (chunk) => {
+				stderrChunks.push(chunk.toString("utf-8"));
+			});
+			child.on("error", (err) => {
+				finish(true, `claude process error: ${err.message}`);
+			});
+			child.on("close", (code, signal) => {
+				if (signal === "SIGINT" || signal === "SIGTERM") {
+					aborted = true;
+					finish(false);
+					return;
+				}
+				const sawResult = emissions.some((e) => e.type === "turn-end");
+				if (code !== 0 && !sawResult) {
+					finish(true);
+					return;
+				}
+				finish(false);
+			});
+		});
+	}
+};
+//#endregion
+//#region src/session/session-store.ts
+/**
+* Session Store — persists chat sessions to the local filesystem.
+*
+* COPIED from `packages/openclaw-chat/src/session-store.ts` (Phase 2 plan,
+* audit D1-D4) and trimmed for the Claude Code host:
+*   - inherits the `messages:[]` not-found stub contract and the per-session
+*     write-lock (both load-bearing — see the warm-slot crash rationale in
+*     services/chat).
+*   - OMITS `recordRoute` / `routes` — those keyed OpenClaw's own transcript,
+*     which does NOT exist here. The Claude Code host is the sole author of
+*     history: it `addMessage`s user + assistant and `appendActivity`s per
+*     turn, so `sessions.list` / `sessions.get` and memory backfill work with
+*     no external transcript.
+*
+* Storage layout (IDENTICAL to openclaw-chat — the memory backfill reads these
+* files directly):
+*   ~/.alfe/sessions/chat/{sessionId}.json
+*
+* where `sessionId = conversationId ?? sessionKey`.
+*/
+function sessionsDir() {
+	return process.env.ALFE_SESSIONS_DIR ?? join(homedir(), ".alfe", "sessions", "chat");
+}
+const MAX_SESSIONS = 1e3;
+const MAX_AGE_MS = 720 * 60 * 60 * 1e3;
+const CLEANUP_INTERVAL_MS = 36e5;
+let lastCleanupAt = 0;
+async function ensureDir() {
+	const dir = sessionsDir();
+	if (!existsSync(dir)) await mkdir(dir, { recursive: true });
+}
+function sessionPath(sessionId) {
+	const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+	return join(sessionsDir(), `${safe}.json`);
+}
+async function cleanupOldSessions() {
+	if (Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return;
+	const dir = sessionsDir();
+	try {
+		const jsonFiles = (await readdir(dir)).filter((f) => f.endsWith(".json"));
+		if (jsonFiles.length <= MAX_SESSIONS) {
+			const now = Date.now();
+			for (const file of jsonFiles) try {
+				const filePath = join(dir, file);
+				if (now - (await stat(filePath)).mtimeMs > MAX_AGE_MS) await unlink(filePath);
+			} catch {}
+			return;
+		}
+		const fileStats = [];
+		for (const file of jsonFiles) try {
+			const filePath = join(dir, file);
+			const fileStat = await stat(filePath);
+			fileStats.push({
+				path: filePath,
+				mtimeMs: fileStat.mtimeMs
+			});
+		} catch {}
+		fileStats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+		const now = Date.now();
+		let remaining = fileStats.length;
+		for (const entry of fileStats) {
+			if (!(now - entry.mtimeMs > MAX_AGE_MS) && !(remaining > MAX_SESSIONS)) break;
+			try {
+				await unlink(entry.path);
+				remaining--;
+			} catch {}
+		}
+		lastCleanupAt = Date.now();
+	} catch {}
+}
+async function getSession(sessionId) {
+	try {
+		const data = await readFile(sessionPath(sessionId), "utf-8");
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+async function saveSession(session) {
+	await ensureDir();
+	session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await writeFile(sessionPath(session.sessionId), JSON.stringify(session, null, 2), "utf-8");
+}
+async function createSession(sessionId, agentId, channel, tenantId, userId) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const session = {
+		sessionId,
+		agentId,
+		channel,
+		tenantId,
+		userId,
+		createdAt: now,
+		updatedAt: now,
+		messages: []
+	};
+	await saveSession(session);
+	cleanupOldSessions();
+	return session;
+}
+const writeLocks = /* @__PURE__ */ new Map();
+async function addMessage(sessionId, role, content, senderId, senderName, components, attachments) {
+	const next = (writeLocks.get(sessionId) ?? Promise.resolve()).then(async () => {
+		const session = await getSession(sessionId);
+		if (!session) return;
+		session.messages.push({
+			role,
+			content,
+			timestamp: Date.now(),
+			...senderId ? { senderId } : {},
+			...senderName ? { senderName } : {},
+			...components?.length ? { components } : {},
+			...attachments?.length ? { attachments } : {}
+		});
+		await saveSession(session);
+	}).finally(() => {
+		if (writeLocks.get(sessionId) === next) writeLocks.delete(sessionId);
+	});
+	writeLocks.set(sessionId, next);
+	await next;
+}
+const MAX_ACTIVITY_PER_SESSION = 500;
+const MAX_ACTIVITY_THINKING_CHARS = 16e3;
+/**
+* Append a turn's terminalized activity records. Called ONCE per turn (from the
+* dispatch `finally`) — never per-delta.
+*/
+async function appendActivity(sessionId, entries) {
+	if (entries.length === 0) return;
+	const next = (writeLocks.get(sessionId) ?? Promise.resolve()).then(async () => {
+		const session = await getSession(sessionId);
+		if (!session) return;
+		const capped = entries.map((e) => e.kind === "thinking" && e.text.length > MAX_ACTIVITY_THINKING_CHARS ? {
+			...e,
+			text: e.text.slice(0, MAX_ACTIVITY_THINKING_CHARS)
+		} : e);
+		const combined = [...session.activity ?? [], ...capped];
+		session.activity = combined.length > MAX_ACTIVITY_PER_SESSION ? combined.slice(combined.length - MAX_ACTIVITY_PER_SESSION) : combined;
+		await saveSession(session);
+	}).finally(() => {
+		if (writeLocks.get(sessionId) === next) writeLocks.delete(sessionId);
+	});
+	writeLocks.set(sessionId, next);
+	await next;
+}
+async function listSessions(filters, limit = 50) {
+	await ensureDir();
+	const dir = sessionsDir();
+	let files;
+	try {
+		files = await readdir(dir);
+	} catch {
+		return [];
+	}
+	const jsonFiles = files.filter((f) => f.endsWith(".json"));
+	const summaries = [];
+	for (const file of jsonFiles) try {
+		const data = await readFile(join(dir, file), "utf-8");
+		const session = JSON.parse(data);
+		if (filters?.agentId && session.agentId !== filters.agentId) continue;
+		if (filters?.channel && session.channel !== filters.channel) continue;
+		if (filters?.tenantId && session.tenantId !== filters.tenantId) continue;
+		if (filters?.userId && session.userId !== filters.userId) continue;
+		const lastMsg = session.messages.at(-1);
+		summaries.push({
+			sessionId: session.sessionId,
+			agentId: session.agentId,
+			channel: session.channel,
+			...session.tenantId ? { tenantId: session.tenantId } : {},
+			...session.userId ? { userId: session.userId } : {},
+			createdAt: session.createdAt,
+			lastMessageAt: lastMsg ? new Date(lastMsg.timestamp).toISOString() : void 0,
+			preview: lastMsg?.content.slice(0, 100),
+			messageCount: session.messages.length
+		});
+	} catch {}
+	summaries.sort((a, b) => {
+		const aTime = a.lastMessageAt ?? a.createdAt;
+		return (b.lastMessageAt ?? b.createdAt).localeCompare(aTime);
+	});
+	return summaries.slice(0, limit);
+}
+//#endregion
+//#region src/host.ts
+/**
+* ClaudeCodeHost — the persistent chat bridge for a self-hosted Claude Code
+* agent.
+*
+* It holds ONE `ChatServiceClient` (reused verbatim from `@alfe.ai/chat`, with
+* NO custom reconnect — the client already backs off with jitter and guards
+* against orphan sockets), registers the inbound RPC handlers the chat service
+* calls, and drives the `SessionDriver` to run `claude -p` turns on the user's
+* subscription.
+*
+* Every wire shape here is byte-for-byte the shape the `@alfe.ai/openclaw-chat`
+* plugin emits, so the chat service / adapter / UI treat a Claude Code turn
+* identically to an OpenClaw turn. The invariant tags (B1–B4, C1–C5, E1–E3)
+* reference the Phase 2 plan and `services/chat/src/{adapter,daemon-server}.ts`.
+*
+* Method dispatch (mirrors `openclaw-chat` plugin `onRequest`):
+*   - `agent`        → per-claude-session FIFO queue → SessionDriver turn (C4)
+*   - `chat.abort`   → SIGINT the child + settle (B3)
+*   - `sessions.list`/`sessions.get` → session-store reads (unqueued)
+*   - `runtime.activity` → drain probe: `{ active: busy }` (B4)
+*   - anything else  → `sendResponse(id, false, { message })`
+*/
+/** Voice-mode speech-style guidance (origin:'voice'). Mirrors VOICE_REPLY_SYSTEM_PROMPT. */
+const VOICE_REPLY_SYSTEM_PROMPT = [
+	"This message arrived over a LIVE VOICE CALL — your reply is read aloud by text-to-speech.",
+	"Speak the way a helpful person would on a phone call:",
+	"- Keep it brief and conversational — usually 1-3 short sentences.",
+	"- Plain spoken language only: no markdown, no bullet or numbered lists, no headings, no code blocks, no URLs or link syntax.",
+	"- If the full answer is long or detailed, give the short spoken version and offer to send the details to the chat.",
+	"This is guidance on speaking STYLE only. Do NOT skip tool calls you would otherwise make, and never omit information the user actually needs."
+].join("\n");
+/** Cross-agent tool steering (every turn). Mirrors CROSS_AGENT_TOOLS_SYSTEM_PROMPT. */
+const CROSS_AGENT_TOOLS_SYSTEM_PROMPT = ["Cross-agent messaging: to contact another Alfe agent (IDs like agt_…), use list_agents to discover and message_agent to send.", "The runtime's built-in session tools do NOT know Alfe agent IDs and will fail — never use them to reach another agent."].join("\n");
+/** Persona files read from the workspace, in precedence order (first wins as lead). */
+const PERSONA_FILES = ["SOUL.md", "IDENTITY.md"];
+/**
+* One FIFO backlog PER claude-session key. Unlike openclaw-chat's single
+* per-daemon queue, the Claude Code host spawns a distinct `claude -p` per
+* conversation, so distinct sessions run CONCURRENTLY — the queue only
+* serialises turns that target the SAME session (concurrent `--resume <sameId>`
+* would corrupt the transcript). The queue is keyed on the RPC `sessionKey`
+* (which is 1:1 with a conversation and thus its claude session lineage).
+*/
+var PerSessionQueues = class {
+	backlogs = /* @__PURE__ */ new Map();
+	draining = /* @__PURE__ */ new Set();
+	enqueue(key, task, opts) {
+		return new Promise((resolve, reject) => {
+			const entry = {
+				run: task,
+				coalesceKey: opts?.coalesceKey,
+				onSuperseded: opts?.onSuperseded ?? (() => void 0),
+				resolve,
+				reject
+			};
+			const backlog = this.backlogs.get(key) ?? [];
+			if (entry.coalesceKey) {
+				const survivors = [];
+				for (const queued of backlog) if (queued.coalesceKey === entry.coalesceKey) {
+					try {
+						queued.onSuperseded();
+					} catch {}
+					queued.resolve();
+				} else survivors.push(queued);
+				backlog.length = 0;
+				backlog.push(...survivors);
+			}
+			backlog.push(entry);
+			this.backlogs.set(key, backlog);
+			this.drain(key);
+		});
+	}
+	async drain(key) {
+		if (this.draining.has(key)) return;
+		this.draining.add(key);
+		try {
+			const backlog = this.backlogs.get(key);
+			while (backlog && backlog.length > 0) {
+				const entry = backlog.shift();
+				if (!entry) break;
+				try {
+					await entry.run();
+					entry.resolve();
+				} catch (err) {
+					entry.reject(err);
+				}
+			}
+		} finally {
+			this.draining.delete(key);
+			if (this.backlogs.get(key)?.length === 0) this.backlogs.delete(key);
+		}
+	}
+	/** Test/introspection: total queued (not-yet-started) turns across all keys. */
+	backlogLength() {
+		let n = 0;
+		for (const b of this.backlogs.values()) n += b.length;
+		return n;
+	}
+};
+var ClaudeCodeHost = class {
+	chat;
+	/**
+	* Factory for a per-turn `SessionDriver`. A driver tracks a single in-flight
+	* `child`, so distinct sessions running concurrently (C4) each get their OWN
+	* driver — a shared singleton would cross-abort and mis-probe (its one `child`
+	* slot would be overwritten by whichever session spawned last).
+	*/
+	makeDriver;
+	api;
+	log;
+	cfg;
+	queues = new PerSessionQueues();
+	/** Alfe sessionId → claude session id map (mirrors ~/.alfe/claude-code/sessions.json). */
+	claudeSessionIds = /* @__PURE__ */ new Map();
+	claudeSessionsPath;
+	/** RPC sessionKey → currently RUNNING request id (for chat.abort targeting). */
+	runningTurns = /* @__PURE__ */ new Map();
+	/** idempotencyKey → settled request id, for E3 duplicate-RPC dedupe. */
+	seenIdempotencyKeys = /* @__PURE__ */ new Map();
+	/** RPC sessionKey → resolved SessionDriver so chat.abort can SIGINT the child. */
+	activeDriverBySession = /* @__PURE__ */ new Map();
+	constructor(cfg, deps) {
+		this.cfg = cfg;
+		this.log = cfg.logger ?? console;
+		this.claudeSessionsPath = cfg.claudeSessionsPath ?? join(homedir(), ".alfe", "claude-code", "sessions.json");
+		this.makeDriver = deps?.makeDriver ?? (() => new SessionDriver({
+			logger: this.log,
+			baseEnv: process.env
+		}));
+		this.api = deps?.api ?? new AgentApiClient({
+			apiKey: cfg.apiKey,
+			apiUrl: cfg.apiUrl
+		});
+		this.chat = deps?.chat ?? new ChatServiceClient({
+			wsUrl: cfg.wsUrl,
+			apiKey: cfg.apiKey,
+			logger: this.log,
+			onRequest: (req) => {
+				this.handleRequest(req);
+			},
+			onConnectionChange: (connected) => {
+				this.log.info(`[claude-host] chat ${connected ? "connected" : "disconnected"}`);
+			}
+		});
+	}
+	/** Start the chat WS. Non-blocking — the client reconnects internally. */
+	async start() {
+		await this.loadClaudeSessionIds();
+		this.chat.start();
+	}
+	/** Stop the chat WS (SIGTERM path). */
+	stop() {
+		this.chat.stop();
+	}
+	/**
+	* Inbound RPC dispatch. Invoked by the chat client's `onRequest` in
+	* production; also the test seam (drive `agent`/`chat.abort`/… directly).
+	*/
+	async handleRequest(req) {
+		try {
+			switch (req.method) {
+				case "agent":
+					await this.handleAgent(req);
+					return;
+				case "chat.abort":
+					this.handleChatAbort(req);
+					return;
+				case "sessions.list":
+					await this.handleSessionsList(req);
+					return;
+				case "sessions.get":
+					await this.handleSessionsGet(req);
+					return;
+				case "runtime.activity":
+					this.chat.sendResponse(req.id, true, { active: this.activeDriverBySession.size > 0 });
+					return;
+				default:
+					this.chat.sendResponse(req.id, false, { message: `Unknown method: ${req.method}` });
+					return;
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this.log.error(`[claude-host] handler for ${req.method} threw: ${message}`);
+			this.chat.sendResponse(req.id, false, { message });
+		}
+	}
+	async handleAgent(req) {
+		const params = req.params;
+		const sessionKey = params.sessionKey;
+		if (typeof sessionKey !== "string" || !sessionKey) {
+			this.chat.sendResponse(req.id, false, { message: "Missing sessionKey" });
+			return;
+		}
+		const idem = params.idempotencyKey;
+		if (idem && this.seenIdempotencyKeys.has(idem)) {
+			this.chat.sendResponse(req.id, true, { sessionKey });
+			return;
+		}
+		if (idem) this.pruneIdempotency();
+		const coalesceKey = params.coalesce === "replace" ? sessionKey : void 0;
+		await this.queues.enqueue(sessionKey, () => this.runAgentTurn(req, params), coalesceKey ? {
+			coalesceKey,
+			onSuperseded: () => {
+				this.chat.sendResponse(req.id, true, {
+					superseded: true,
+					sessionKey
+				});
+			}
+		} : void 0);
+	}
+	async runAgentTurn(req, params) {
+		const sessionKey = params.sessionKey;
+		const bareSessionId = params.conversationId ?? stripAgentPrefix(sessionKey);
+		const runId = params.idempotencyKey ?? req.id;
+		const isVoice = params.origin === "voice";
+		await this.ensureSession(bareSessionId, params);
+		await addMessage(bareSessionId, "user", params.message, params.identityId ?? params.userId, params.displayName);
+		let memoryContext = "";
+		try {
+			memoryContext = (await this.api.memoryLoadContext()).formatted;
+		} catch (err) {
+			this.log.warn(`[claude-host] memoryLoadContext failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+		}
+		const appendSystemPrompt = await this.buildSystemPrompt(memoryContext, isVoice);
+		const claudeSessionId = this.claudeSessionIds.get(bareSessionId) ?? null;
+		const driver = this.makeDriver();
+		this.runningTurns.set(sessionKey, req.id);
+		this.activeDriverBySession.set(sessionKey, driver);
+		let result;
+		try {
+			result = await this.runWithResumeFallback(driver, bareSessionId, sessionKey, runId, {
+				prompt: params.message,
+				claudeSessionId,
+				cwd: this.cfg.workspace,
+				...this.cfg.mcpConfigPath ? { mcpConfigPath: this.cfg.mcpConfigPath } : {},
+				...appendSystemPrompt ? { appendSystemPrompt } : {},
+				onEmission: (emission) => {
+					this.forwardEmission(runId, sessionKey, emission);
+				}
+			}, isVoice);
+		} finally {
+			this.runningTurns.delete(sessionKey);
+			this.activeDriverBySession.delete(sessionKey);
+			if (params.idempotencyKey) this.seenIdempotencyKeys.set(params.idempotencyKey, Date.now());
+		}
+		if (result.claudeSessionId && result.claudeSessionId !== claudeSessionId) {
+			this.claudeSessionIds.set(bareSessionId, result.claudeSessionId);
+			await this.saveClaudeSessionIds();
+		}
+		const activityRecords = collectTurnActivityRecords(result.emissions);
+		if (activityRecords.length) await appendActivity(bareSessionId, activityRecords);
+		if (result.aborted) return;
+		if (result.isError) {
+			this.chat.sendResponse(req.id, false, { message: result.errorMessage ?? "Claude Code turn failed" });
+			return;
+		}
+		if (result.finalText) await addMessage(bareSessionId, "assistant", result.finalText);
+		if (result.finalText) this.chat.notify("agent-message", {
+			conversationId: bareSessionId,
+			text: result.finalText,
+			sessionKey,
+			messageId: params.chatMessageId ?? req.id
+		});
+		this.chat.sendResponse(req.id, true, { sessionKey });
+		try {
+			const messages = [{
+				role: "user",
+				content: params.message,
+				index: 0
+			}, ...result.finalText ? [{
+				role: "assistant",
+				content: result.finalText,
+				index: 1
+			}] : []];
+			await this.api.memoryIngest(bareSessionId, messages, {
+				...params.identityId ?? params.userId ? { userId: params.identityId ?? params.userId } : {},
+				...params.displayName ? { userName: params.displayName } : {}
+			});
+		} catch (err) {
+			this.log.warn(`[claude-host] memoryIngest failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	/**
+	* Run a turn; on a `--resume` failure (stale/missing claude session id) start
+	* fresh and prepend the last-N stored messages so the model keeps context.
+	*/
+	async runWithResumeFallback(driver, bareSessionId, _sessionKey, _runId, baseParams, isVoice) {
+		const first = await driver.runTurn(baseParams, isVoice ? "voice" : "chat");
+		if (!(baseParams.claudeSessionId !== null && first.isError && first.claudeSessionId === null && first.emissions.length === 0)) return first;
+		this.log.warn(`[claude-host] --resume failed for ${bareSessionId}; starting a fresh claude session`);
+		this.claudeSessionIds.delete(bareSessionId);
+		const history = await this.buildHistoryPreamble(bareSessionId);
+		const freshPrompt = history ? `${history}\n\n---\n\n${baseParams.prompt}` : baseParams.prompt;
+		return driver.runTurn({
+			...baseParams,
+			claudeSessionId: null,
+			prompt: freshPrompt
+		}, isVoice ? "voice" : "chat");
+	}
+	forwardEmission(runId, sessionKey, emission) {
+		if (emission.type === "chat-delta") {
+			this.chat.sendEvent("chat", {
+				runId,
+				sessionKey,
+				seq: emission.seq,
+				state: "delta",
+				message: {
+					role: "assistant",
+					content: [{
+						type: "text",
+						text: emission.text
+					}],
+					timestamp: emission.ts
+				}
+			});
+			return;
+		}
+		if (emission.type === "chat-activity") {
+			this.chat.sendEvent("chat-activity", {
+				runId,
+				sessionKey,
+				seq: emission.seq,
+				state: "activity",
+				activity: {
+					...emission.activity,
+					ts: emission.ts,
+					seq: emission.seq
+				}
+			});
+			return;
+		}
+	}
+	handleChatAbort(req) {
+		const { sessionKey } = req.params;
+		let aborted = false;
+		const driver = sessionKey ? this.activeDriverBySession.get(sessionKey) : void 0;
+		if (sessionKey && driver) {
+			driver.abort();
+			const runningReqId = this.runningTurns.get(sessionKey);
+			if (runningReqId) this.chat.sendResponse(runningReqId, true, { sessionKey });
+			aborted = true;
+		}
+		this.chat.sendResponse(req.id, true, { aborted });
+	}
+	async handleSessionsList(req) {
+		const params = req.params;
+		const sessions = await listSessions(params);
+		this.chat.sendResponse(req.id, true, { sessions });
+	}
+	async handleSessionsGet(req) {
+		const params = req.params;
+		if (!params.sessionId) {
+			this.chat.sendResponse(req.id, false, { message: "Missing sessionId" });
+			return;
+		}
+		const session = await getSession(params.sessionId);
+		if (!session) {
+			this.chat.sendResponse(req.id, true, {
+				sessionId: params.sessionId,
+				messages: [],
+				activity: []
+			});
+			return;
+		}
+		this.chat.sendResponse(req.id, true, {
+			sessionId: session.sessionId,
+			agentId: session.agentId,
+			channel: session.channel,
+			createdAt: session.createdAt,
+			messages: session.messages.map((m) => ({
+				id: `msg-${String(m.timestamp)}`,
+				role: m.role,
+				content: m.content,
+				timestamp: m.timestamp,
+				...m.components?.length ? { components: m.components } : {},
+				...m.attachments?.length ? { attachments: m.attachments } : {}
+			})),
+			activity: session.activity ?? []
+		});
+	}
+	async buildSystemPrompt(memoryContext, isVoice) {
+		const parts = [];
+		const persona = await this.readPersona();
+		if (persona) parts.push(persona);
+		if (memoryContext) parts.push(`# Relevant memory\n\n${memoryContext}`);
+		if (isVoice) parts.push(VOICE_REPLY_SYSTEM_PROMPT);
+		parts.push(CROSS_AGENT_TOOLS_SYSTEM_PROMPT);
+		return parts.join("\n\n");
+	}
+	async readPersona() {
+		const chunks = [];
+		for (const file of PERSONA_FILES) try {
+			const text = await readFile(join(this.cfg.workspace, file), "utf-8");
+			if (text.trim()) chunks.push(text.trim());
+		} catch {}
+		return chunks.join("\n\n");
+	}
+	async buildHistoryPreamble(bareSessionId) {
+		const session = await getSession(bareSessionId);
+		if (!session || session.messages.length === 0) return "";
+		const prior = session.messages.slice(0, -1).slice(-10);
+		if (prior.length === 0) return "";
+		return `Earlier in this conversation:\n${prior.map((m) => `${m.role === "assistant" ? "Assistant" : "User"}: ${m.content}`).join("\n")}`;
+	}
+	async ensureSession(bareSessionId, params) {
+		if (await getSession(bareSessionId)) return;
+		await createSession(bareSessionId, params.agentId, params.clientType ?? "chat", params.tenantId, params.identityId ?? params.userId);
+	}
+	async loadClaudeSessionIds() {
+		try {
+			const raw = await readFile(this.claudeSessionsPath, "utf-8");
+			const parsed = JSON.parse(raw);
+			for (const [k, v] of Object.entries(parsed)) if (typeof v === "string") this.claudeSessionIds.set(k, v);
+		} catch {}
+	}
+	async saveClaudeSessionIds() {
+		const obj = {};
+		for (const [k, v] of this.claudeSessionIds) obj[k] = v;
+		try {
+			await mkdir(dirname(this.claudeSessionsPath), { recursive: true });
+			await writeFile(this.claudeSessionsPath, JSON.stringify(obj, null, 2), "utf-8");
+		} catch (err) {
+			this.log.warn(`[claude-host] failed to persist claude session ids: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	pruneIdempotency() {
+		const cutoff = Date.now() - 10 * 6e4;
+		for (const [k, ts] of this.seenIdempotencyKeys) if (ts < cutoff) this.seenIdempotencyKeys.delete(k);
+	}
+};
+/** Strip the `agent:{agentId}:` prefix from a full server session key. */
+function stripAgentPrefix(sessionKey) {
+	const parts = sessionKey.split(":");
+	if (parts.length >= 3 && parts[0] === "agent") return parts.slice(2).join(":");
+	return sessionKey;
+}
+//#endregion
+//#region src/host-config.ts
+/**
+* Resolve the host runtime config from `~/.alfe/config.toml` + token-derived
+* endpoints. Kept OUT of `cli.ts` so the importable library surface
+* (`index.ts`) can re-export it without pulling in `cli.ts`'s top-level
+* `main()` (which would start the process on import).
+*/
+/**
+* Build the host config. Throws (→ non-zero exit from the CLI) when the chat
+* URL / api key can't resolve.
+*/
+function resolveHostConfig() {
+	const resolved = resolveConfig();
+	const chat = resolveAlfeChat({ apiKey: resolved.apiKey });
+	if (!chat.apiKey || !chat.chatWsUrl) throw new Error("Unable to resolve chat service URL / API key from ~/.alfe/config.toml. Run `alfe login`.");
+	return {
+		wsUrl: chat.chatWsUrl,
+		apiKey: chat.apiKey,
+		apiUrl: resolved.apiUrl,
+		workspace: resolved.workspacePath,
+		mcpConfigPath: join(homedir(), ".claude-code", "mcp-config.json"),
+		claudeSessionsPath: join(homedir(), ".alfe", "claude-code", "sessions.json")
+	};
+}
+//#endregion
+export { mapStreamEvent as _, appendActivity as a, SCRUBBED_ANTHROPIC_ENV_VARS as b, listSessions as c, DEFAULT_PERMISSION_MODE as d, SessionDriver as f, createMapperState as g, collectTurnActivityRecords as h, addMessage as i, saveSession as l, WARM_STREAMING_SUPPORTED as m, ClaudeCodeHost as n, createSession as o, TURN_TIMEOUT_MS as p, stripAgentPrefix as r, getSession as s, resolveHostConfig as t, DEFAULT_ALLOWED_TOOLS as u, mapStreamEvents as v, buildChildEnv as x, BRIDGE_ENV_VAR as y };