@agentconnect.md/daemon 1.0.0-rc.220 → 1.0.0-rc.222

package/dist/{acp-host-CeJJZbtg.js → acp-host-DE2r7uCO.js}

@@ -1,6 +1,6 @@
 import { i as __require, o as __toESM, t as __commonJSMin } from "./rolldown-runtime-CE-6LUnI.js";
 import { t as require_src$1 } from "./src-DDtlVutj.js";
-import { S as NEVER, _ as union, c as intersection, d as number, f as object, g as string, h as record, i as boolean, l as literal, o as discriminatedUnion, r as array, s as int, t as _enum, v as unknown, y as url } from "./schemas-DujcoO0q.js";
+import { T as NEVER, _ as record, a as array, b as unknown, c as discriminatedUnion, d as literal, l as int, m as object, n as _enum, o as boolean, p as number, u as intersection, v as string, x as url, y as union } from "./schemas-CQkO9hC5.js";
 import { c as registryPath, s as registryCachePath } from "./paths-DEcUO8lC.js";
 import { delimiter, dirname, join, normalize } from "node:path";
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -418,6 +418,13 @@ const AgentWorkspace = discriminatedUnion("mode", [object({ mode: literal("scrat
 	gitCredential: _enum(["github-app"]).optional()
 })]);
 /**
+* MCP-server name reserved for the daemon's own injected stdio bridge (its
+* platform tools). A config-defined or agent-enabled server under this name
+* would collide with the bridge entry at ACP `session/new`, so the daemon
+* strips it and the CP rejects it in `AgentSpec.mcpServers` at the API edge.
+*/
+const RESERVED_MCP_SERVER_NAME = "agentconnect";
+/**
 * The editable agent definition the CP owns and the daemon needs to run it:
 * prompt + runtime selection. Raft ships this in the launch config and the
 * daemon synthesizes the system prompt locally; `description` IS the prompt.
@@ -435,8 +442,10 @@ const AgentSpec = object({
 		"high"
 	]).optional(),
 	fastMode: boolean().optional(),
+	permissionMode: string().optional(),
 	workspace: AgentWorkspace.optional(),
-	env: record(string(), string()).optional()
+	env: record(string(), string()).optional(),
+	mcpServers: array(string()).default([])
 });
 const AgentLaunch = object({
 	agentId: string().uuid(),
@@ -899,6 +908,82 @@ const WorkspaceGitPullResult = object({
 	deletions: number().int().nonnegative().optional()
 });
 //#endregion
+//#region ../protocol/dist/frames/memory.js
+/**
+* Agent memory directory (C→D REQ → REP) — the console's read/write of an agent's
+* long-term memory, and the surface the daemon serves it from.
+*
+* Memory is a DIRECTORY at the agent's ROOT (`<agent-root>/memory/`), OUTSIDE the
+* workspace — so it survives a workspace reset / re-clone and is never committed
+* into a github-workspace repo. It follows the index-plus-topics shape: a lean
+* `MEMORY.md` index (injected into the prompt every session, bounded) plus any
+* number of `<topic>.md` files the agent reads on demand. The agent maintains it
+* via MCP tools; these frames are the third channel — the CP reading/writing it
+* for the console — all pointing at the same directory.
+*
+* The CP stores NO memory content — bytes are pulled live from the owning daemon
+* and proxied to the console, never persisted (body-locality). A not-yet-created
+* file/dir is DATA (`exists:false`), not an error; only an unknown agent or a
+* path-containment violation (`BAD_PAYLOAD`) or an unexpected fs failure
+* (`INTERNAL`) comes back as an `error` frame.
+*
+* - `memory/list`: the topic files in the memory dir (flat; the index + topics).
+* - `memory/read`: one byte slice of a memory file (`path` relative to the memory
+*   dir; default `MEMORY.md`). `limit` is a ceiling — the daemon returns fewer
+*   bytes to keep the JSON-escaped REP under the 256 KiB frame cap and always ends
+*   on a UTF-8 boundary. `nextOffset` is authoritative — do NOT recompute it.
+* - `memory/write`: replace the whole named memory file with `content`.
+*/
+/** The default file name of the memory index (loaded into the prompt each session). */
+const MEMORY_INDEX = "MEMORY.md";
+/** One entry in a memory-dir listing (name-only; not a path). */
+const MemoryEntry = object({
+	name: string(),
+	size: number().int().nonnegative(),
+	mtime: string()
+});
+/** C→D REQ: list the files in the agent's memory dir. */
+const MemoryListReq = object({ agentId: string().min(1) });
+/** D→C REP (corr = the req id): the memory dir's files (or `exists:false`). */
+const MemoryListPage = object({
+	agentId: string(),
+	exists: boolean(),
+	entries: array(MemoryEntry)
+});
+/** C→D REQ: read one byte slice of a memory file (path relative to the memory dir). */
+const MemoryReadReq = object({
+	agentId: string().min(1),
+	path: string().default(MEMORY_INDEX),
+	offset: number().int().nonnegative().default(0),
+	limit: number().int().positive().max(65536).default(65536)
+});
+/** D→C REP (corr = the req id): the memory file slice (or `exists:false`). Always utf8 text. */
+const MemoryReadContent = object({
+	agentId: string(),
+	path: string(),
+	exists: boolean(),
+	size: number().int().nonnegative().optional(),
+	mtime: string().optional(),
+	content: string().optional(),
+	offset: number().int().nonnegative().optional(),
+	nextOffset: number().int().nonnegative().optional(),
+	truncated: boolean().optional()
+});
+/** C→D REQ: replace the whole named memory file with `content` (console edit). */
+const MemoryWriteReq = object({
+	agentId: string().min(1),
+	path: string().default(MEMORY_INDEX),
+	content: string(),
+	ifMatchMtime: string().optional()
+});
+/** D→C REP (corr = the req id): the written state, so the console can refresh. */
+const MemoryWriteOk = object({
+	agentId: string(),
+	path: string(),
+	size: number().int().nonnegative(),
+	mtime: string()
+});
+//#endregion
 //#region ../protocol/dist/frames/telemetry.js
 /**
 * Telemetry & facts (D→C) — protocol §7.
@@ -964,6 +1049,15 @@ const UsageReport = object({
 * daemons report the full snapshot instead; the CP keeps accepting the old
 * frame from older daemons.
 */
+/**
+* MCP transports a runtime accepts on `session/new` `mcpServers` (from the ACP
+* `initialize` response's `agentCapabilities.mcpCapabilities`). Stdio is the ACP
+* baseline every agent must accept, so only the optional transports are listed.
+*/
+const McpTransportCapabilities = object({
+	http: boolean(),
+	sse: boolean()
+});
 const FactsRuntimeProfile = object({
 	runtime: string(),
 	version: string(),
@@ -975,7 +1069,27 @@ const FactsRuntimeProfile = object({
 		"none"
 	]),
 	acpProtocolVersion: number().int().optional(),
-	toolCalling: boolean()
+	toolCalling: boolean(),
+	mcpCapabilities: McpTransportCapabilities.optional()
+});
+/**
+* Probe result for one daemon-configured MCP server (daemon config `mcpServers`).
+* The daemon connects to the server (MCP initialize + `tools/list`) so the
+* console can show what each server offers before the user enables it on an
+* agent. Metadata only — definitions (commands, URLs, headers) stay daemon-local.
+*/
+const FactsMcpServer = object({
+	name: string(),
+	transport: _enum([
+		"stdio",
+		"http",
+		"sse"
+	]),
+	/** True iff the MCP handshake succeeded. */
+	ok: boolean(),
+	tools: array(string()).default([]),
+	version: string().optional(),
+	error: string().optional()
 });
 /**
 * Full snapshot of the daemon's installed runtimes — D→C EVT (protocol §7.3a),
@@ -985,7 +1099,10 @@ const FactsRuntimeProfile = object({
 * that are no longer installed. Idempotent (latest-wins). Supersedes the
 * per-runtime `facts/runtime-profile` upsert.
 */
-const DaemonRuntimes = object({ runtimes: array(FactsRuntimeProfile) });
+const DaemonRuntimes = object({
+	runtimes: array(FactsRuntimeProfile),
+	mcpServers: array(FactsMcpServer).default([])
+});
 /** Non-secret config update — C→D EVT, protocol §8.3 / frame #26. */
 const ConfigPush = object({ keys: record(string(), unknown()) });
 /** Fleet: drain+exit, supervisor restarts — C→D REQ, protocol §8.3 / frame #27. */
@@ -1026,6 +1143,7 @@ const ErrorFrame = object({
 		"LEASE_EXPIRED",
 		"LEASE_DENIED",
 		"RATE_LIMITED",
+		"CONFLICT",
 		"INTERNAL"
 	]),
 	message: string(),
@@ -1077,6 +1195,7 @@ const WebchatEvent = discriminatedUnion("kind", [
 const WebchatStatus = object({
 	model: string().optional(),
 	effort: string().optional(),
+	permissionMode: string().optional(),
 	fastMode: boolean().optional(),
 	contextUsed: number().int().optional(),
 	contextSize: number().int().optional(),
@@ -1085,6 +1204,7 @@ const WebchatStatus = object({
 	costCurrency: string().optional(),
 	models: array(string()).optional(),
 	efforts: array(string()).optional(),
+	permissionModes: array(string()).optional(),
 	fastModeAvailable: boolean().optional(),
 	sessionId: string().optional()
 });
@@ -1144,6 +1264,11 @@ const FRAME_SCHEMAS = {
 		agentId: string().uuid(),
 		effort: string()
 	}),
+	"webchat/set-permission-mode": object({
+		conversationId: string().uuid(),
+		agentId: string().uuid(),
+		permissionMode: string()
+	}),
 	"webchat/set-fast": object({
 		conversationId: string().uuid(),
 		agentId: string().uuid(),
@@ -1190,6 +1315,12 @@ const FRAME_SCHEMAS = {
 	"workspace/gitstatus/result": WorkspaceGitStatus,
 	"workspace/gitpull": WorkspaceGitPullReq,
 	"workspace/gitpull/result": WorkspaceGitPullResult,
+	"memory/list": MemoryListReq,
+	"memory/list/page": MemoryListPage,
+	"memory/read": MemoryReadReq,
+	"memory/read/content": MemoryReadContent,
+	"memory/write": MemoryWriteReq,
+	"memory/write/ok": MemoryWriteOk,
 	"config/push": ConfigPush,
 	"daemon/restart": DaemonRestart,
 	"daemon/upgrade": DaemonUpgrade,
@@ -1232,6 +1363,7 @@ discriminatedUnion("type", [
 	frame("webchat/close", FRAME_SCHEMAS["webchat/close"]),
 	frame("webchat/set-model", FRAME_SCHEMAS["webchat/set-model"]),
 	frame("webchat/set-effort", FRAME_SCHEMAS["webchat/set-effort"]),
+	frame("webchat/set-permission-mode", FRAME_SCHEMAS["webchat/set-permission-mode"]),
 	frame("webchat/set-fast", FRAME_SCHEMAS["webchat/set-fast"]),
 	frame("webchat/cancel", FRAME_SCHEMAS["webchat/cancel"]),
 	frame("route/assign", FRAME_SCHEMAS["route/assign"]),
@@ -1274,6 +1406,12 @@ discriminatedUnion("type", [
 	frame("workspace/gitstatus/result", FRAME_SCHEMAS["workspace/gitstatus/result"]),
 	frame("workspace/gitpull", FRAME_SCHEMAS["workspace/gitpull"]),
 	frame("workspace/gitpull/result", FRAME_SCHEMAS["workspace/gitpull/result"]),
+	frame("memory/list", FRAME_SCHEMAS["memory/list"]),
+	frame("memory/list/page", FRAME_SCHEMAS["memory/list/page"]),
+	frame("memory/read", FRAME_SCHEMAS["memory/read"]),
+	frame("memory/read/content", FRAME_SCHEMAS["memory/read/content"]),
+	frame("memory/write", FRAME_SCHEMAS["memory/write"]),
+	frame("memory/write/ok", FRAME_SCHEMAS["memory/write/ok"]),
 	frame("config/push", FRAME_SCHEMAS["config/push"]),
 	frame("daemon/restart", FRAME_SCHEMAS["daemon/restart"]),
 	frame("daemon/upgrade", FRAME_SCHEMAS["daemon/upgrade"]),
@@ -5773,11 +5911,7 @@ function usesGithubApp(agent) {
 async function prepareWorkspace(agent) {
 	const cwd = agent.workspace.path;
 	mkdirSync(cwd, { recursive: true });
-	if (agent.workspace.mode === "from-scratch") {
-		const mem = join(cwd, "memory.md");
-		if (!existsSync(mem)) writeFileSync(mem, `# ${agent.name} memory\n`);
-		return cwd;
-	}
+	if (agent.workspace.mode === "from-scratch") return cwd;
 	if (!existsSync(join(cwd, ".git"))) {
 		await cloneRepo(agent);
 		return cwd;
@@ -10149,6 +10283,20 @@ function effortOptionsFrom(configOptions, isClaudeRuntime) {
 	};
 }
 /**
+* Extract the permission/approval mode selector from a session's `configOptions` (ACP
+* `category: "mode"`, `type: "select"`). Returns null when the runtime exposes no mode
+* selector.
+*/
+function permissionModeOptionsFrom(configOptions) {
+	const opt = configOptions?.find((o) => o.category === "mode" && o.type === "select");
+	if (!opt || opt.type !== "select") return null;
+	const modes = opt.options.flatMap((o) => "group" in o ? o.options : [o]).map((o) => o.value);
+	return {
+		current: opt.currentValue,
+		modes
+	};
+}
+/**
 * Extract the fast-mode toggle from a session's `configOptions` (ACP `category:
 * "model_config"`, `type: "select"` with on/off values). Returns null when the current
 * model advertises no fast toggle.
@@ -10169,9 +10317,11 @@ var AcpHost = class {
 	promptCaps = {};
 	lastModelOptions = null;
 	lastEffortOptions = null;
+	lastPermissionModeOptions = null;
 	lastFastOption = null;
 	sessionConfigs = /* @__PURE__ */ new Map();
 	negotiatedProtocolVersion;
+	mcpCaps = null;
 	constructor(runtime, opts) {
 		this.runtime = runtime;
 		this.opts = opts;
@@ -10195,6 +10345,7 @@ var AcpHost = class {
 				this.opts.log?.info(`acp: CLAUDE_CODE_EXECUTABLE not set — using claude on PATH (${claude})`);
 			}
 		}
+		if (this.isClaudeRuntime() && env.CLAUDE_CODE_DISABLE_AUTO_MEMORY === void 0) env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
 		const child = spawn$1(resolveCommandPath(this.runtime.command, env) ?? this.runtime.command, this.runtime.args, {
 			stdio: [
 				"pipe",
@@ -10227,7 +10378,12 @@ var AcpHost = class {
 		this.negotiatedProtocolVersion = init.protocolVersion;
 		this.canLoad = init.agentCapabilities?.loadSession ?? false;
 		this.promptCaps = init.agentCapabilities?.promptCapabilities ?? {};
-		this.opts.log?.debug(`acp: agent initialized (loadSession=${this.canLoad}, prompt caps: image=${!!this.promptCaps.image} audio=${!!this.promptCaps.audio} embeddedContext=${!!this.promptCaps.embeddedContext})`);
+		const mcp = init.agentCapabilities?.mcpCapabilities;
+		this.mcpCaps = {
+			http: mcp?.http ?? false,
+			sse: mcp?.sse ?? false
+		};
+		this.opts.log?.debug(`acp: agent initialized (loadSession=${this.canLoad}, prompt caps: image=${!!this.promptCaps.image} audio=${!!this.promptCaps.audio} embeddedContext=${!!this.promptCaps.embeddedContext}, mcp: http=${this.mcpCaps.http} sse=${this.mcpCaps.sse})`);
 	}
 	/** Whether the agent advertised support for a gated prompt content-block kind.
 	*  `text` and `resource_link` are baseline and always return true. */
@@ -10277,6 +10433,7 @@ var AcpHost = class {
 		const fastMode = this.opts.configPrefs?.fastMode;
 		const prefs = [
 			["model", this.opts.configPrefs?.model],
+			["mode", this.opts.configPrefs?.permissionMode],
 			["thought_level", ultracode ? void 0 : this.opts.configPrefs?.reasoningEffort],
 			["model_config", fastMode === void 0 ? void 0 : fastMode ? "on" : "off"]
 		];
@@ -10304,6 +10461,7 @@ var AcpHost = class {
 	refreshOptionCaches(configOptions) {
 		this.lastModelOptions = modelOptionsFrom(configOptions);
 		this.lastEffortOptions = effortOptionsFrom(configOptions, this.isClaudeRuntime());
+		this.lastPermissionModeOptions = permissionModeOptionsFrom(configOptions);
 		this.lastFastOption = fastOptionFrom(configOptions);
 	}
 	/** The model selector advertised by the most recent session/new|load, or null if the
@@ -10316,6 +10474,11 @@ var AcpHost = class {
 	effortOptions() {
 		return this.lastEffortOptions;
 	}
+	/** The permission/approval mode selector from the most recent session/new|load, or
+	*  null if none is offered. */
+	permissionModeOptions() {
+		return this.lastPermissionModeOptions;
+	}
 	/** The fast-mode toggle from the most recent session/new|load, or null if the current
 	*  model offers no fast mode. */
 	fastModeOption() {
@@ -10357,6 +10520,11 @@ var AcpHost = class {
 		if (effort === "ultracode") return false;
 		return this.setSessionConfig(sessionId, "thought_level", effort);
 	}
+	/** Switch the permission/approval mode of an already-running session (ACP `mode`
+	*  select). Values are runtime-owned and validated against the advertised options. */
+	async setSessionPermissionMode(sessionId, mode) {
+		return this.setSessionConfig(sessionId, "mode", mode);
+	}
 	/** Toggle fast mode on an already-running session (ACP `model_config` on/off select).
 	*  False when the current model offers no fast toggle. */
 	async setSessionFastMode(sessionId, on) {
@@ -10367,6 +10535,12 @@ var AcpHost = class {
 	acpProtocolVersion() {
 		return this.negotiatedProtocolVersion;
 	}
+	/** The optional MCP transports the agent advertised at initialize (stdio is
+	*  baseline and always accepted; the unstable `acp` flag is ignored). null
+	*  before the handshake completed. Feeds the runtime probe's transport gating. */
+	mcpCapabilities() {
+		return this.mcpCaps;
+	}
 	/** True iff THIS agent process created or loaded `sessionId` in its current lifetime. */
 	hasSession(sessionId) {
 		return this.live.has(sessionId);
@@ -10377,16 +10551,17 @@ var AcpHost = class {
 	}
 	/** Resume a previously-created session by id (ACP `session/load`). The agent
 	*  restores its own history server-side; its replayed session/update stream is
-	*  suppressed so it isn't re-posted. Throws if the agent can't load the id
-	*  (caller falls back to newSession). */
-	async loadSession(sessionId, cwd, effortOverride) {
+	*  suppressed so it isn't re-posted. `mcpServers` must be re-attached here — the
+	*  agent doesn't persist them across processes. Throws if the agent can't load
+	*  the id (caller falls back to newSession). */
+	async loadSession(sessionId, cwd, mcpServers = [], effortOverride) {
 		this.loadingSessions.add(sessionId);
 		try {
 			const _meta = claudeSessionMeta(effortOverride ?? this.opts.configPrefs?.reasoningEffort, this.isClaudeRuntime(), this.opts.configPrefs?.systemPrompt);
 			const res = await this.conn.agent.request(methods.agent.session.load, {
 				sessionId,
 				cwd,
-				mcpServers: [],
+				mcpServers,
 				..._meta ? { _meta } : {}
 			});
 			this.live.add(sessionId);
@@ -10443,6 +10618,6 @@ var AcpHost = class {
 	}
 };
 //#endregion
-export { resolveRuntimes as _, initGitInjection as a, simpleGit as c, MAX_FRAME_BYTES as d, buildEnvelope as f, cachedRuntimeVersions as g, cachedRuntimeNames as h, prepareWorkspace as i, isFrame as l, encode as m, installedRuntimes as n, probeGitVersion as o, decodeEnvelope as p, prefetchWorkspace as r, sessionGitEnv as s, AcpHost as t, normalizeGitUrl as u };
+export { cachedRuntimeNames as _, initGitInjection as a, simpleGit as c, MAX_FRAME_BYTES as d, buildEnvelope as f, RESERVED_MCP_SERVER_NAME as g, MEMORY_INDEX as h, prepareWorkspace as i, isFrame as l, encode as m, installedRuntimes as n, probeGitVersion as o, decodeEnvelope as p, prefetchWorkspace as r, sessionGitEnv as s, AcpHost as t, normalizeGitUrl as u, cachedRuntimeVersions as v, resolveRuntimes as y };
 
-//# sourceMappingURL=acp-host-CeJJZbtg.js.map
+//# sourceMappingURL=acp-host-DE2r7uCO.js.map