@agentproto/adapter-mastra-agent 0.4.2 → 0.5.0

package/dist/chunk-5C2H4JSD.mjs

@@ -0,0 +1,2094 @@
+import { promises, mkdirSync } from 'fs';
+import { homedir, tmpdir } from 'os';
+import { resolve, join, isAbsolute, relative, sep, dirname, basename } from 'path';
+import { exec, execFile } from 'child_process';
+import { randomUUID } from 'crypto';
+import { promisify } from 'util';
+import { createTool } from '@mastra/core/tools';
+import { loadAllowlistEntries, isCommandAllowed, isInterpreterBasename, interpreterExecWarning } from '@agentproto/runtime/command-allowlist';
+import { z } from 'zod';
+import { LibSQLStore } from '@mastra/libsql';
+import { Memory } from '@mastra/memory';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { readFile } from 'fs/promises';
+import { parseAgentManifest, agentFromManifest } from '@agentproto/agent';
+import { buildMastraAgent } from '@agentproto/mastra';
+import { ProviderHistoryCompat } from '@mastra/core/processors';
+import { AgentController } from '@mastra/core/agent-controller';
+import { Workspace } from '@mastra/core/workspace';
+import { createNotificationInboxTool } from '@mastra/core/notifications';
+import { SignalProvider } from '@mastra/core/signals';
+import { PROTOCOL_VERSION, ndJsonStream, AgentSideConnection } from '@agentclientprotocol/sdk';
+import { Writable, Readable } from 'stream';
+
+/**
+ * @agentproto/adapter-mastra-agent v0.1.0-alpha
+ * First-party agentproto agent: AGENT.md -> Mastra agent -> ACP server.
+ */
+
+var DaemonNotFoundError = class extends Error {
+  constructor(message = "no agentproto daemon found \u2014 set AGENTPROTO_DAEMON_URL or run inside a daemon-spawned session") {
+    super(message);
+    this.name = "DaemonNotFoundError";
+  }
+};
+var DaemonHttpError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "DaemonHttpError";
+  }
+  status;
+  body;
+};
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    return code === "EPERM";
+  }
+}
+async function readJsonFile(path) {
+  try {
+    const raw = await promises.readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function endpointFromRuntimeJson(path, isPidAlive) {
+  const parsed = await readJsonFile(path);
+  if (!parsed || typeof parsed.port !== "number") return void 0;
+  if (typeof parsed.pid === "number" && !isPidAlive(parsed.pid)) return void 0;
+  return {
+    url: `http://${typeof parsed.bind === "string" ? parsed.bind : "127.0.0.1"}:${parsed.port}`,
+    sourcePath: path,
+    ...typeof parsed.token === "string" ? { token: parsed.token } : {}
+  };
+}
+async function discoverDaemonEndpoint(opts = {}) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  const homeDir = opts.homeDir ?? homedir();
+  const isPidAlive = opts.isPidAlive ?? defaultIsPidAlive;
+  if (env.AGENTPROTO_DAEMON_URL) {
+    const url = env.AGENTPROTO_DAEMON_URL.replace(/\/+$/, "");
+    return { url, ...env.AGENTPROTO_DAEMON_TOKEN ? { token: env.AGENTPROTO_DAEMON_TOKEN } : {} };
+  }
+  const cwdRuntime = await endpointFromRuntimeJson(resolve(cwd, ".agentproto", "runtime.json"), isPidAlive);
+  if (cwdRuntime) return cwdRuntime;
+  const homeRuntime = await endpointFromRuntimeJson(resolve(homeDir, ".agentproto", "runtime.json"), isPidAlive);
+  if (homeRuntime) return homeRuntime;
+  const registryDir = opts.registryDir ?? resolve(homeDir, ".agentproto", "daemons");
+  let names;
+  try {
+    names = await promises.readdir(registryDir);
+  } catch {
+    return void 0;
+  }
+  const entries = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const path = join(registryDir, name);
+    try {
+      const st = await promises.stat(path);
+      entries.push({ path, mtimeMs: st.mtimeMs });
+    } catch {
+    }
+  }
+  entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const entry of entries) {
+    const ep = await endpointFromRuntimeJson(entry.path, isPidAlive);
+    if (ep) return ep;
+  }
+  return void 0;
+}
+var DaemonClient = class {
+  cwd;
+  env;
+  fetchImpl;
+  homeDir;
+  registryDir;
+  isPidAlive;
+  cachedEndpoint;
+  constructor(opts = {}) {
+    this.cwd = opts.cwd ?? process.cwd();
+    this.env = opts.env ?? process.env;
+    if (!opts.fetchImpl && typeof fetch !== "function") {
+      throw new Error("DaemonClient requires a global `fetch` (Node >=18) or an injected `fetchImpl`.");
+    }
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.homeDir = opts.homeDir;
+    this.registryDir = opts.registryDir;
+    this.isPidAlive = opts.isPidAlive;
+    this.cachedEndpoint = opts.endpoint;
+  }
+  async resolveEndpoint(forceRediscover = false) {
+    if (this.cachedEndpoint && !forceRediscover) return this.cachedEndpoint;
+    const found = await discoverDaemonEndpoint({
+      cwd: this.cwd,
+      env: this.env,
+      ...this.homeDir ? { homeDir: this.homeDir } : {},
+      ...this.registryDir ? { registryDir: this.registryDir } : {},
+      ...this.isPidAlive ? { isPidAlive: this.isPidAlive } : {}
+    });
+    if (!found) throw new DaemonNotFoundError();
+    this.cachedEndpoint = found;
+    return found;
+  }
+  async request(method, path, opts = {}) {
+    const endpoint = await this.resolveEndpoint();
+    const doFetch = async (ep) => {
+      const url = new URL(path, ep.url);
+      for (const [k, v] of Object.entries(opts.query ?? {})) {
+        if (v !== void 0) url.searchParams.set(k, v);
+      }
+      const headers = {};
+      if (ep.token) headers.authorization = `Bearer ${ep.token}`;
+      if (opts.body !== void 0) headers["content-type"] = "application/json";
+      return this.fetchImpl(url.toString(), {
+        method,
+        headers,
+        ...opts.body !== void 0 ? { body: JSON.stringify(opts.body) } : {}
+      });
+    };
+    let res;
+    try {
+      res = await doFetch(endpoint);
+    } catch (err) {
+      const rediscovered = await this.resolveEndpoint(true);
+      try {
+        res = await doFetch(rediscovered);
+      } catch (retryErr) {
+        throw retryErr instanceof Error ? retryErr : new Error(String(retryErr));
+      }
+    }
+    const text = await res.text();
+    if (!res.ok) {
+      throw new DaemonHttpError(
+        `daemon HTTP ${res.status} ${method} ${path}: ${text.slice(0, 200)}`,
+        res.status,
+        text
+      );
+    }
+    return text.length > 0 ? JSON.parse(text) : void 0;
+  }
+  /**
+   * Spawn a child session — `POST /sessions/agent`. `parentSessionId` is
+   * derived from `AGENTPROTO_SESSION_ID` (set by the daemon on every
+   * ACP-spawned adapter) when present, so session lineage is recorded
+   * without the caller having to thread it through.
+   */
+  async startAgent(input) {
+    const parentSessionId = this.env.AGENTPROTO_SESSION_ID;
+    return this.request("POST", "/sessions/agent", {
+      body: {
+        ...input,
+        ...parentSessionId ? { parentSessionId } : {}
+      }
+    });
+  }
+  /** Send a follow-up turn to a live session — `POST /sessions/:id/prompt`. */
+  async promptAgent(sessionId, text, opts = {}) {
+    return this.request("POST", `/sessions/${encodeURIComponent(sessionId)}/prompt`, {
+      body: { prompt: text, ...opts.interrupt ? { interrupt: true } : {} },
+      query: opts.wait === false ? { wait: "false" } : {}
+    });
+  }
+  /** List sessions — `GET /sessions`. */
+  async listSessions(opts = {}) {
+    return this.request("GET", "/sessions", {
+      query: {
+        includeArchived: opts.includeArchived ? "true" : void 0,
+        kind: opts.kind
+      }
+    });
+  }
+  /**
+   * Read a session's transcript — `GET /sessions/:id/export`. Chosen over
+   * `/sessions/:id/conversation` (needs a provider-native store registered
+   * for the adapter; not every adapter has one) and `/sessions/:id/preview`
+   * (a raw ring-buffer snapshot, not a rendered transcript): `/export`
+   * works for ANY agent-cli session, falling back to the daemon's own
+   * `events.jsonl` capture when no provider-native reader is registered
+   * (`source: "auto"`, see `transcript-export.ts`) — the one built for
+   * programmatic reads of "what did this session say".
+   */
+  async readOutput(sessionId, opts = {}) {
+    return this.request("GET", `/sessions/${encodeURIComponent(sessionId)}/export`, {
+      query: { format: opts.format ?? "json" }
+    });
+  }
+  /**
+   * Cursor-based poll of a session's structured event log —
+   * `GET /sessions/:id/events`. NOT the same event source as the MCP
+   * `session_events_poll` tool: that tool reads the daemon's in-memory,
+   * cross-session `EventRing` (turn-end/awaiting-input/exited/... lifecycle
+   * events, `packages/runtime/src/orchestration-tools.ts:528`), which has no
+   * plain-HTTP equivalent — it's only reachable over the MCP JSON-RPC
+   * transport, which this zero-dependency client doesn't speak. This route
+   * is the per-SESSION structured `events.jsonl` transcript instead
+   * (`packages/runtime/src/transcript-writer.ts`): cursor-based via
+   * `since`/`nextSeq` same as the MCP tool, and its records DO carry many of
+   * the same `kind`s (`turn-end`, `error`, `permission-resolved`, ...) — but
+   * it has no `exited` / `session:spawned` records (those are registry
+   * state changes, not transcript writes) and no cross-session fan-in
+   * (`sessionIds` filter). `types` is therefore filtered client-side here
+   * against each record's `kind`, not sent as a query param.
+   *
+   * WP-6 (`AgentprotoSignalProvider`, polling every 5s): this is a
+   * non-blocking snapshot read, so it's a direct fit for a poll loop. If
+   * WP-6 needs the actual cross-session lifecycle events (`exited`,
+   * `session:spawned`, multi-session fan-in), it either needs its own
+   * light MCP JSON-RPC client to call `session_events_poll` directly, or
+   * per-session `GET /sessions/:id/wait?since=&event=` (a blocking
+   * long-poll over the SAME EventRing `session_events_poll` reads, but
+   * scoped to one session and one event name at a time — no `types` array).
+   */
+  async pollEvents(sessionId, opts = {}) {
+    const result = await this.request(
+      "GET",
+      `/sessions/${encodeURIComponent(sessionId)}/events`,
+      {
+        query: {
+          since: opts.since !== void 0 ? String(opts.since) : void 0,
+          limit: opts.limit !== void 0 ? String(opts.limit) : void 0
+        }
+      }
+    );
+    if (!opts.types || opts.types.length === 0) return result;
+    const wanted = new Set(opts.types);
+    return {
+      ...result,
+      events: result.events.filter((e) => typeof e.kind === "string" && wanted.has(e.kind))
+    };
+  }
+};
+var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
+var ALLOWED_TEST_ARGV0 = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "node", "npx"]);
+function tail(s, maxChars = 4e3) {
+  return s.length > maxChars ? s.slice(-maxChars) : s;
+}
+function extractPatchPaths(patch) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of patch.split("\n")) {
+    const m = /^(?:\+\+\+|---) (?:a\/|b\/)?(.+?)(?:\t.*)?$/.exec(line);
+    if (!m) continue;
+    const p = m[1].trim();
+    if (p === "/dev/null") continue;
+    paths.add(p);
+  }
+  return [...paths];
+}
+function withTimeoutGuard(id, timeoutMs, execute) {
+  return async (input) => {
+    let timer;
+    try {
+      return await Promise.race([
+        execute(input),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            reject(
+              new Error(
+                `tool '${id}' timed out after ${timeoutMs}ms (adapter execution guard) \u2014 aborted so the turn can't hang indefinitely.`
+              )
+            );
+          }, timeoutMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+function resolveInCwd(cwd, p) {
+  const base = resolve(cwd);
+  const target = isAbsolute(p) ? resolve(p) : resolve(base, p);
+  const rel = relative(base, target);
+  if (rel === "") return target;
+  if (rel.startsWith("..") || isAbsolute(rel) && !target.startsWith(base + sep)) {
+    throw new Error(
+      `path '${p}' escapes the workspace (resolved to '${target}', outside '${base}').`
+    );
+  }
+  return target;
+}
+function makeUnwiredToolStub(id) {
+  return createTool({
+    id,
+    description: `NOT WIRED: '${id}' is declared in this agent's AGENT.md but this adapter has no executor for it. Calling it always fails immediately with an error \u2014 do not retry it.`,
+    inputSchema: z.record(z.string(), z.unknown()),
+    outputSchema: z.object({ error: z.string() }),
+    execute: async () => {
+      throw new Error(
+        `tool '${id}' is declared in AGENT.md but not wired to any executor in this adapter (adapters/mastra-agent/src/workspace-tools.ts). This call cannot succeed \u2014 stop retrying it.`
+      );
+    }
+  });
+}
+function makeWorkspaceTools(opts) {
+  const cwd = resolve(opts.cwd);
+  const allowExec = opts.allowExec ?? true;
+  const execTimeoutMs = opts.execTimeoutMs ?? 12e4;
+  const execEnv = { ...process.env, GIT_CEILING_DIRECTORIES: resolve(cwd, "..") };
+  const guard = (id, execute) => withTimeoutGuard(id, execTimeoutMs, execute);
+  const doListDir = async (input) => {
+    const dir = resolveInCwd(cwd, input.path ?? ".");
+    const dirents = await promises.readdir(dir, { withFileTypes: true });
+    return {
+      entries: dirents.map((d) => d.isDirectory() ? `${d.name}/` : d.name).sort()
+    };
+  };
+  const doReadFile = async (input) => {
+    const file = resolveInCwd(cwd, input.path);
+    return { content: await promises.readFile(file, "utf8") };
+  };
+  const doWriteFile = async (input) => {
+    const file = resolveInCwd(cwd, input.path);
+    await promises.mkdir(resolve(file, ".."), { recursive: true });
+    await promises.writeFile(file, input.content, "utf8");
+    return { path: input.path, bytes: Buffer.byteLength(input.content, "utf8") };
+  };
+  const list_dir = createTool({
+    id: "list_dir",
+    description: "List the entries of a directory in the workspace. Returns names with a trailing '/' for directories. Path is relative to the workspace root (default '.').",
+    inputSchema: z.object({
+      path: z.string().default(".").describe("Directory path, relative to the workspace root.")
+    }),
+    outputSchema: z.object({ entries: z.array(z.string()) }),
+    execute: guard("list_dir", doListDir)
+  });
+  const directory_list = createTool({
+    id: "directory_list",
+    description: "Alias of `list_dir` (daemon-vocabulary id) \u2014 list a workspace directory's entries.",
+    inputSchema: z.object({
+      path: z.string().default(".").describe("Directory path, relative to the workspace root.")
+    }),
+    outputSchema: z.object({ entries: z.array(z.string()) }),
+    execute: guard("directory_list", doListDir)
+  });
+  const read_file = createTool({
+    id: "read_file",
+    description: "Read a UTF-8 text file from the workspace. Path is relative to the workspace root.",
+    inputSchema: z.object({
+      path: z.string().describe("File path, relative to the workspace root.")
+    }),
+    outputSchema: z.object({ content: z.string() }),
+    execute: guard("read_file", doReadFile)
+  });
+  const file_read = createTool({
+    id: "file_read",
+    description: "Alias of `read_file` (daemon-vocabulary id) \u2014 read a UTF-8 text file from the workspace.",
+    inputSchema: z.object({
+      path: z.string().describe("File path, relative to the workspace root.")
+    }),
+    outputSchema: z.object({ content: z.string() }),
+    execute: guard("file_read", doReadFile)
+  });
+  const write_file = createTool({
+    id: "write_file",
+    description: "Write (creating or overwriting) a UTF-8 text file in the workspace. Creates parent directories as needed. Path is relative to the workspace root.",
+    inputSchema: z.object({
+      path: z.string().describe("File path, relative to the workspace root."),
+      content: z.string().describe("Full file contents to write.")
+    }),
+    outputSchema: z.object({ path: z.string(), bytes: z.number() }),
+    execute: guard("write_file", doWriteFile)
+  });
+  const file_write = createTool({
+    id: "file_write",
+    description: "Alias of `write_file` (daemon-vocabulary id) \u2014 write a UTF-8 text file to the workspace.",
+    inputSchema: z.object({
+      path: z.string().describe("File path, relative to the workspace root."),
+      content: z.string().describe("Full file contents to write.")
+    }),
+    outputSchema: z.object({ path: z.string(), bytes: z.number() }),
+    execute: guard("file_write", doWriteFile)
+  });
+  const edit_file = createTool({
+    id: "edit_file",
+    description: "Replace an exact substring in a workspace file. `old_string` must occur exactly once. Use for targeted edits instead of rewriting the whole file.",
+    inputSchema: z.object({
+      path: z.string().describe("File path, relative to the workspace root."),
+      old_string: z.string().describe("Exact text to replace (must be unique in the file)."),
+      new_string: z.string().describe("Replacement text.")
+    }),
+    outputSchema: z.object({ path: z.string(), replaced: z.boolean() }),
+    execute: guard("edit_file", async (input) => {
+      const file = resolveInCwd(cwd, input.path);
+      const current = await promises.readFile(file, "utf8");
+      const count = current.split(input.old_string).length - 1;
+      if (count === 0) throw new Error(`old_string not found in '${input.path}'.`);
+      if (count > 1) {
+        throw new Error(`old_string occurs ${count}\xD7 in '${input.path}' \u2014 make it unique.`);
+      }
+      await promises.writeFile(file, current.replace(input.old_string, input.new_string), "utf8");
+      return { path: input.path, replaced: true };
+    })
+  });
+  const file_info = createTool({
+    id: "file_info",
+    description: "Stat a file or directory in the workspace \u2014 returns name, type, size (bytes), and modified/created timestamps.",
+    inputSchema: z.object({
+      path: z.string().describe("File or directory path, relative to the workspace root.")
+    }),
+    outputSchema: z.object({
+      name: z.string(),
+      path: z.string(),
+      type: z.enum(["file", "directory"]),
+      size: z.number(),
+      modified: z.string(),
+      created: z.string()
+    }),
+    execute: guard("file_info", async (input) => {
+      const abs = resolveInCwd(cwd, input.path);
+      const info = await promises.stat(abs);
+      return {
+        name: abs.split(sep).pop() ?? input.path,
+        path: input.path,
+        type: info.isDirectory() ? "directory" : "file",
+        size: info.size,
+        modified: info.mtime.toISOString(),
+        created: info.birthtime.toISOString()
+      };
+    })
+  });
+  const tools = {
+    list_dir,
+    directory_list,
+    read_file,
+    file_read,
+    write_file,
+    file_write,
+    edit_file,
+    file_info
+  };
+  if (allowExec) {
+    tools.run_command = createTool({
+      id: "run_command",
+      description: "Run a shell command in the workspace directory and return its stdout/stderr/exit code. Runs with a timeout; use for builds, tests, git, etc.",
+      inputSchema: z.object({
+        command: z.string().describe("The shell command to run (executed in the workspace root).")
+      }),
+      outputSchema: z.object({
+        stdout: z.string(),
+        stderr: z.string(),
+        exitCode: z.number()
+      }),
+      execute: guard("run_command", async (input) => {
+        try {
+          const { stdout, stderr } = await execAsync(input.command, {
+            cwd,
+            timeout: execTimeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+            env: execEnv
+          });
+          return { stdout, stderr, exitCode: 0 };
+        } catch (err) {
+          const e = err;
+          return {
+            stdout: e.stdout ?? "",
+            stderr: e.stderr ?? e.message ?? String(err),
+            exitCode: typeof e.code === "number" ? e.code : 1
+          };
+        }
+      })
+    });
+    tools.command_execute = createTool({
+      id: "command_execute",
+      description: "Run an allowlisted command in the workspace directory. The command's basename must appear in <workspace>/.agentproto/allowed-commands.json (default-deny \u2014 a missing or empty file means nothing runs). Unlike `run_command`, args are passed as an argv array with no shell interpolation (spawned with shell:false). Returns stdout/stderr/exitCode.",
+      inputSchema: z.object({
+        command: z.string().min(1).describe("Executable name or path \u2014 checked against the allowlist by basename."),
+        args: z.array(z.string()).optional().describe("Argv array, passed verbatim (no shell expansion).")
+      }),
+      outputSchema: z.object({
+        stdout: z.string(),
+        stderr: z.string(),
+        exitCode: z.number(),
+        warning: z.string().optional()
+      }),
+      execute: guard("command_execute", async (input) => {
+        const allowlistEntries = await loadAllowlistEntries(cwd);
+        const baseName = basename(input.command);
+        if (!isCommandAllowed(allowlistEntries, baseName, input.args ?? [])) {
+          const allowedBasenames = [...new Set(allowlistEntries.map((e) => e.command))].sort().join(", ") || "(empty)";
+          const basenameKnown = allowlistEntries.some((e) => e.command === baseName);
+          throw new Error(
+            basenameKnown ? `command_execute: '${baseName}' is allowlisted but its argv doesn't match any allowed pattern for it. Check the "args" constraints in .agentproto/allowed-commands.json.` : `command_execute: '${baseName}' is not in the workspace allowlist. Add it to .agentproto/allowed-commands.json under "commands": [...]. Currently allowed: ${allowedBasenames}.`
+          );
+        }
+        const warning = isInterpreterBasename(baseName) ? interpreterExecWarning(baseName) : void 0;
+        if (warning) console.error(`[command_execute] \u26A0 ${warning}`);
+        try {
+          const { stdout, stderr } = await execFileAsync(input.command, input.args ?? [], {
+            cwd,
+            timeout: execTimeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+            env: execEnv
+          });
+          return { stdout, stderr, exitCode: 0, ...warning ? { warning } : {} };
+        } catch (err) {
+          const e = err;
+          return {
+            stdout: e.stdout ?? "",
+            stderr: e.stderr ?? e.message ?? String(err),
+            exitCode: typeof e.code === "number" ? e.code : 1,
+            ...warning ? { warning } : {}
+          };
+        }
+      })
+    });
+    tools.read_diff = createTool({
+      id: "read_diff",
+      description: "Show `git diff` for the workspace \u2014 staged and unstaged changes against HEAD (or against `base` if given), as unified diff text. Optionally scoped to `paths`.",
+      inputSchema: z.object({
+        paths: z.array(z.string()).optional().describe("Restrict the diff to these paths, relative to the workspace root."),
+        base: z.string().optional().describe("Git ref to diff against. Defaults to HEAD.")
+      }),
+      outputSchema: z.object({ diff: z.string() }),
+      execute: guard("read_diff", async (input) => {
+        const relPaths = (input.paths ?? []).map((p) => {
+          const abs = resolveInCwd(cwd, p);
+          return relative(cwd, abs) || ".";
+        });
+        const args = [
+          "diff",
+          input.base ?? "HEAD",
+          ...relPaths.length ? ["--", ...relPaths] : []
+        ];
+        try {
+          const { stdout } = await execFileAsync("git", args, {
+            cwd,
+            timeout: execTimeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+            env: execEnv
+          });
+          return { diff: stdout };
+        } catch (err) {
+          const e = err;
+          throw new Error(`git diff failed: ${e.stderr ?? e.message ?? String(err)}`);
+        }
+      })
+    });
+    tools.apply_patch = createTool({
+      id: "apply_patch",
+      description: "Apply a unified diff to files in the workspace (`git apply --whitespace=nowarn`). Paths in the patch that escape the workspace are rejected.",
+      inputSchema: z.object({
+        patch: z.string().describe("Unified diff text to apply.")
+      }),
+      outputSchema: z.object({ applied: z.boolean(), output: z.string() }),
+      execute: guard("apply_patch", async (input) => {
+        for (const p of extractPatchPaths(input.patch)) {
+          resolveInCwd(cwd, p);
+        }
+        const patchFile = join(tmpdir(), `mastra-agent-patch-${randomUUID()}.diff`);
+        await promises.writeFile(patchFile, input.patch, "utf8");
+        try {
+          const { stdout, stderr } = await execFileAsync(
+            "git",
+            ["apply", "--whitespace=nowarn", patchFile],
+            { cwd, timeout: execTimeoutMs, maxBuffer: 10 * 1024 * 1024, env: execEnv }
+          );
+          return { applied: true, output: stdout || stderr || "" };
+        } catch (err) {
+          const e = err;
+          throw new Error(`git apply failed: ${e.stderr ?? e.stdout ?? e.message ?? String(err)}`);
+        } finally {
+          await promises.unlink(patchFile).catch(() => {
+          });
+        }
+      })
+    });
+    tools.run_tests = createTool({
+      id: "run_tests",
+      description: "Run the workspace's test command (default `npm test`, overridable via `command` or the MASTRA_AGENT_TEST_CMD env) and return its exit code + output tail.",
+      inputSchema: z.object({
+        command: z.string().optional().describe("Override the test command. Its argv0 must be one of npm, pnpm, yarn, node, npx.")
+      }),
+      outputSchema: z.object({ exitCode: z.number(), output: z.string() }),
+      execute: guard("run_tests", async (input) => {
+        const commandStr = input.command ?? process.env.MASTRA_AGENT_TEST_CMD ?? "npm test";
+        const argv0 = commandStr.trim().split(/\s+/)[0];
+        if (!argv0 || !ALLOWED_TEST_ARGV0.has(argv0)) {
+          throw new Error(
+            `run_tests: command '${commandStr}' is not allowed \u2014 argv0 must be one of ${[...ALLOWED_TEST_ARGV0].join(", ")}.`
+          );
+        }
+        try {
+          const { stdout, stderr } = await execAsync(commandStr, {
+            cwd,
+            timeout: execTimeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+            env: execEnv
+          });
+          return { exitCode: 0, output: tail(stdout + stderr) };
+        } catch (err) {
+          const e = err;
+          return {
+            exitCode: typeof e.code === "number" ? e.code : 1,
+            output: tail((e.stdout ?? "") + (e.stderr ?? e.message ?? String(err)))
+          };
+        }
+      })
+    });
+  }
+  return {
+    ...tools,
+    ...opts.extraTools
+  };
+}
+function tail2(s, maxChars = 4e3) {
+  return s.length > maxChars ? s.slice(-maxChars) : s;
+}
+function makeDaemonTools(opts = {}) {
+  const client = opts.client ?? new DaemonClient(opts.clientOptions);
+  const execTimeoutMs = opts.execTimeoutMs ?? 3e4;
+  const guard = (id, execute) => withTimeoutGuard(id, execTimeoutMs, execute);
+  const agent_start = createTool({
+    id: "agent_start",
+    description: "Spawn a new agent session via the agentproto daemon (any adapter: claude-code, hermes, mastra-agent, ...). The spawned session's lineage is recorded as a child of this session when running under a daemon-spawned session. Returns the daemon's session descriptor (includes the new session's id \u2014 pass it to `agent_prompt` / `agent_output`).",
+    inputSchema: z.object({
+      adapter: z.string().describe("Adapter id to spawn, e.g. 'claude-code', 'hermes', 'mastra-agent'."),
+      cwd: z.string().optional().describe("Working directory for the spawned session. Defaults to the daemon's workspace resolution."),
+      model: z.string().optional().describe("Model id to spawn the session with, if the adapter supports selecting one."),
+      prompt: z.string().optional().describe("Initial prompt to send once the session is up."),
+      label: z.string().optional().describe("Human-readable label for the spawned session.")
+    }),
+    outputSchema: z.record(z.string(), z.unknown()),
+    execute: guard(
+      "agent_start",
+      async (input) => client.startAgent(input)
+    )
+  });
+  const agent_prompt = createTool({
+    id: "agent_prompt",
+    description: "Send a follow-up message to a live session spawned via `agent_start` (or any other daemon session id). Blocks until the turn drains by default; set `wait: false` to return as soon as the prompt is queued.",
+    inputSchema: z.object({
+      sessionId: z.string().describe("Target session id (from `agent_start`'s result or `session_list`)."),
+      text: z.string().describe("The message to send."),
+      interrupt: z.boolean().optional().describe("Cancel the target session's in-flight turn and deliver this prompt instead. Default false."),
+      wait: z.boolean().optional().describe("Wait for the turn to drain before returning. Default true.")
+    }),
+    outputSchema: z.record(z.string(), z.unknown()),
+    execute: guard(
+      "agent_prompt",
+      async (input) => client.promptAgent(input.sessionId, input.text, {
+        ...input.interrupt !== void 0 ? { interrupt: input.interrupt } : {},
+        ...input.wait !== void 0 ? { wait: input.wait } : {}
+      })
+    )
+  });
+  const agent_output = createTool({
+    id: "agent_output",
+    description: "Read a session's transcript (works for any agent-cli session, not just ones this agent spawned). Output is tailed to the most recent text when it's large.",
+    inputSchema: z.object({
+      sessionId: z.string().describe("Session id to read."),
+      format: z.enum(["markdown", "json"]).optional().describe("Transcript rendering. Default 'json'.")
+    }),
+    outputSchema: z.object({
+      adapter: z.string().optional(),
+      content: z.string().optional()
+    }).catchall(z.unknown()),
+    execute: guard("agent_output", async (input) => {
+      const result = await client.readOutput(input.sessionId, {
+        ...input.format ? { format: input.format } : {}
+      });
+      return typeof result.content === "string" ? { ...result, content: tail2(result.content) } : result;
+    })
+  });
+  const session_list = createTool({
+    id: "session_list",
+    description: "List sessions known to the daemon \u2014 spawned by this agent or any other client.",
+    inputSchema: z.object({
+      includeArchived: z.boolean().optional().describe("Include archived sessions. Default false."),
+      kind: z.string().optional().describe("Filter by session kind (e.g. 'agent-cli', 'command', 'all').")
+    }),
+    outputSchema: z.object({ sessions: z.array(z.record(z.string(), z.unknown())) }),
+    execute: guard(
+      "session_list",
+      async (input) => client.listSessions(input)
+    )
+  });
+  return { agent_start, agent_prompt, agent_output, session_list };
+}
+function resolveMemoryDbPath(env = process.env) {
+  const override = env.AGENTPROTO_MASTRA_MEMORY_DB;
+  if (override) return override;
+  const dir = join(homedir(), ".agentproto", "mastra-agent");
+  mkdirSync(dir, { recursive: true });
+  return join(dir, "memory.db");
+}
+function buildSqliteStore(env = process.env) {
+  const dbPath = resolveMemoryDbPath(env);
+  return new LibSQLStore({ id: "mastra-agent-memory", url: `file:${dbPath}` });
+}
+function buildSqliteMemory(config, env = process.env, store) {
+  if (config?.scope === "none") return void 0;
+  const lastMessages = typeof config?.retention_turns === "number" && config.retention_turns > 0 ? config.retention_turns : 20;
+  return new Memory({
+    storage: store ?? buildSqliteStore(env),
+    options: {
+      lastMessages,
+      semanticRecall: false,
+      workingMemory: { enabled: false }
+    }
+  });
+}
+var PROVIDER_ENV = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY",
+  groq: "GROQ_API_KEY",
+  xai: "XAI_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY"
+};
+function modelRefToString(ref) {
+  if (typeof ref === "string") return ref.trim();
+  if (ref && typeof ref === "object" && typeof ref.ref === "string") {
+    return ref.ref.trim();
+  }
+  throw new Error(
+    "mastra-agent: AGENT.md `model` must be a `provider/model` string (or { ref }); inline model objects are not supported by this adapter."
+  );
+}
+function providerOf(modelId) {
+  const slash = modelId.indexOf("/");
+  return slash > 0 ? modelId.slice(0, slash) : modelId;
+}
+function normalizeModelId(modelId) {
+  if (modelId.includes("/")) return modelId;
+  if (/^claude[-.]/i.test(modelId)) return `anthropic/${modelId}`;
+  return modelId;
+}
+function resolveMastraModel(ref, env = process.env) {
+  const modelId = normalizeModelId(modelRefToString(ref));
+  if (!modelId) {
+    throw new Error("mastra-agent: empty `model` ref.");
+  }
+  const provider = providerOf(modelId);
+  const envKey = PROVIDER_ENV[provider];
+  if (envKey && !env[envKey]) {
+    throw new Error(
+      `mastra-agent: model '${modelId}' needs ${envKey} in the environment (provider '${provider}'). Set it on the spawn env or export it.`
+    );
+  }
+  if (provider === "anthropic") {
+    const key = env["ANTHROPIC_API_KEY"];
+    if (key?.startsWith("sk-ant-oat")) {
+      const bareId = modelId.slice(modelId.indexOf("/") + 1);
+      return createAnthropic({ authToken: key })(bareId);
+    }
+  }
+  return modelId;
+}
+var WATCHED_EVENT_KINDS = [
+  "turn-end",
+  "error",
+  "agent-prompt",
+  "permission-resolved"
+];
+var EXIT_STATUSES = /* @__PURE__ */ new Set(["exited", "killed", "error"]);
+var MAX_WARNED_MESSAGES = 200;
+var AgentprotoSignalProvider = class extends SignalProvider {
+  id = "agentproto-daemon";
+  pollInterval;
+  #client;
+  #stateEmitter;
+  #warned = /* @__PURE__ */ new Set();
+  constructor(opts = {}) {
+    super();
+    this.#client = opts.client ?? new DaemonClient(opts.clientOptions);
+    this.#stateEmitter = opts.stateEmitter;
+    this.pollInterval = opts.pollInterval ?? 5e3;
+  }
+  /**
+   * Subscribe a thread to a daemon session's lifecycle. The public wrapper
+   * around the base class's protected `subscribe` — `sessionId` is the daemon
+   * session id (subscription `externalResourceId`). Optional `metadata.label`
+   * feeds the notification summary.
+   */
+  watch(target, sessionId, metadata) {
+    return this.subscribe(target, sessionId, metadata);
+  }
+  /** Undo a {@link watch}. Returns false when no such subscription existed. */
+  unwatch(target, sessionId) {
+    return this.unsubscribe(target, sessionId);
+  }
+  /**
+   * One poll cycle over all subscriptions. The base class only calls this
+   * when at least one subscription exists, so an idle provider (nothing
+   * watched) never touches the daemon — that's the "dormant when no daemon
+   * is discoverable" behavior: discovery isn't even attempted until a watch
+   * exists, and a failing first poll warns once instead of throwing.
+   */
+  async poll(subscriptions) {
+    if (subscriptions.length === 0) return;
+    let sessionsById;
+    try {
+      const { sessions } = await this.#client.listSessions({ includeArchived: true });
+      sessionsById = new Map(
+        sessions.filter((s) => typeof s.id === "string").map((s) => [s.id, s])
+      );
+    } catch (err) {
+      this.#warnOnce(`listSessions failed (exit detection skipped): ${errorMessage(err)}`);
+    }
+    for (const sub of subscriptions) {
+      try {
+        await this.#pollSubscription(sub, sessionsById);
+      } catch (err) {
+        this.#warnOnce(`session ${sub.externalResourceId}: ${errorMessage(err)}`);
+      }
+    }
+    await this.#emitStateSignals(subscriptions);
+  }
+  /** WP-7: one daemon-state signal per watching thread per cycle (see
+   *  {@link AgentprotoSignalProviderOptions.stateEmitter}). Never throws. */
+  async #emitStateSignals(subscriptions) {
+    const emitter = this.#stateEmitter;
+    const agent = this.agent;
+    if (!emitter || !agent) return;
+    const byTarget = /* @__PURE__ */ new Map();
+    for (const sub of subscriptions) {
+      const key = `${sub.resourceId}:${sub.threadId}`;
+      const entry = byTarget.get(key) ?? {
+        threadId: sub.threadId,
+        resourceId: sub.resourceId,
+        watched: []
+      };
+      entry.watched.push(sub.externalResourceId);
+      byTarget.set(key, entry);
+    }
+    for (const { threadId, resourceId, watched } of byTarget.values()) {
+      try {
+        await emitter.emit(agent, { threadId, resourceId }, watched);
+      } catch (err) {
+        this.#warnOnce(`state signal for thread ${threadId}: ${errorMessage(err)}`);
+      }
+    }
+  }
+  async #pollSubscription(sub, sessionsById) {
+    const sessionId = sub.externalResourceId;
+    const target = {
+      threadId: sub.threadId,
+      resourceId: sub.resourceId,
+      ...sub.metadata.ifIdle ? { ifIdle: sub.metadata.ifIdle } : {}
+    };
+    const cursor = typeof sub.metadata.cursor === "number" ? sub.metadata.cursor : void 0;
+    const result = await this.#client.pollEvents(sessionId, {
+      ...cursor !== void 0 ? { since: cursor } : {},
+      types: [...WATCHED_EVENT_KINDS]
+    });
+    for (const [i, event] of result.events.entries()) {
+      const kind = typeof event.kind === "string" ? event.kind : "unknown";
+      const seq = typeof event.seq === "number" ? String(event.seq) : `i${i}`;
+      await this.notify(
+        {
+          source: this.id,
+          kind,
+          priority: kind === "error" ? "high" : "medium",
+          summary: this.#summary(sessionId, sub, sessionsById, kind),
+          payload: event,
+          dedupeKey: `${this.id}:${sessionId}:${seq}`
+        },
+        target
+      );
+    }
+    sub.metadata.cursor = result.nextSeq;
+    const record = sessionsById?.get(sessionId);
+    if (!record) return;
+    const status = typeof record.status === "string" ? record.status : void 0;
+    if (!status) return;
+    const lastStatus = typeof sub.metadata.lastStatus === "string" ? sub.metadata.lastStatus : void 0;
+    sub.metadata.lastStatus = status;
+    const alreadyNotified = lastStatus !== void 0 && EXIT_STATUSES.has(lastStatus);
+    if (!EXIT_STATUSES.has(status) || alreadyNotified) return;
+    const exitedWithError = status === "error" || typeof record.exitCode === "number" && record.exitCode !== 0;
+    await this.notify(
+      {
+        source: this.id,
+        kind: "exited",
+        priority: exitedWithError ? "high" : "medium",
+        summary: `${this.#summary(sessionId, sub, sessionsById, "exited")} (status ${status})`,
+        payload: record,
+        dedupeKey: `${this.id}:${sessionId}:exited`
+      },
+      target
+    );
+  }
+  /** `Session <id> (<label>): <kind>` — label from watch metadata, falling
+   *  back to the daemon's session record. */
+  #summary(sessionId, sub, sessionsById, kind) {
+    const recordLabel = sessionsById?.get(sessionId)?.label;
+    const label = typeof sub.metadata.label === "string" ? sub.metadata.label : typeof recordLabel === "string" ? recordLabel : void 0;
+    return `Session ${sessionId}${label ? ` (${label})` : ""}: ${kind}`;
+  }
+  #warnOnce(message) {
+    if (this.#warned.has(message)) return;
+    if (this.#warned.size >= MAX_WARNED_MESSAGES) this.#warned.clear();
+    this.#warned.add(message);
+    console.warn(`[@agentproto/adapter-mastra-agent] ${this.id}: ${message}`);
+  }
+  /**
+   * Agent-callable subscription management. The target thread resolves from
+   * the tool's own execution context (`context.agent.threadId`/`resourceId`,
+   * populated by the agent tool-call step) — explicit `threadId`/`resourceId`
+   * inputs override it for the rare host driving these outside a run.
+   *
+   * Subscriptions made here set `ifIdle: { behavior: "persist" }`: this
+   * adapter fronts an ACP client that only streams during a prompt turn, so
+   * WAKING an idle thread would run a hidden background turn nobody sees.
+   * Persisting instead lands the notification in the thread history + inbox,
+   * where the next real turn picks it up.
+   */
+  getTools() {
+    const watch_session = createTool({
+      id: "watch_session",
+      description: "Watch a daemon session: subscribe this conversation to its lifecycle (turn ends, errors, permission asks, exit). Events arrive as notifications \u2014 check the notification inbox or the conversation for them. Use session ids from `agent_start` / `session_list`.",
+      inputSchema: z.object({
+        sessionId: z.string().describe("Daemon session id to watch."),
+        label: z.string().optional().describe("Human-readable label used in notification summaries."),
+        threadId: z.string().optional().describe("Explicit target thread id. Defaults to the current thread."),
+        resourceId: z.string().optional().describe("Explicit target resource id. Defaults to the current resource.")
+      }),
+      outputSchema: z.object({ subscribed: z.boolean(), sessionId: z.string(), threadId: z.string() }),
+      execute: async (input, context) => {
+        const threadId = input.threadId ?? context.agent?.threadId;
+        const resourceId = input.resourceId ?? context.agent?.resourceId;
+        if (!threadId || !resourceId) {
+          throw new Error(
+            "watch_session: no target thread \u2014 this call ran outside an agent thread, so pass threadId and resourceId explicitly."
+          );
+        }
+        this.watch({ threadId, resourceId, ifIdle: { behavior: "persist" } }, input.sessionId, {
+          ...input.label ? { label: input.label } : {},
+          ifIdle: { behavior: "persist" }
+        });
+        return { subscribed: true, sessionId: input.sessionId, threadId };
+      }
+    });
+    const unwatch_session = createTool({
+      id: "unwatch_session",
+      description: "Stop watching a daemon session previously subscribed with `watch_session`.",
+      inputSchema: z.object({
+        sessionId: z.string().describe("Daemon session id to stop watching."),
+        threadId: z.string().optional().describe("Explicit target thread id. Defaults to the current thread."),
+        resourceId: z.string().optional().describe("Explicit target resource id. Defaults to the current resource.")
+      }),
+      outputSchema: z.object({ unsubscribed: z.boolean(), sessionId: z.string() }),
+      execute: async (input, context) => {
+        const threadId = input.threadId ?? context.agent?.threadId;
+        const resourceId = input.resourceId ?? context.agent?.resourceId;
+        if (!threadId || !resourceId) {
+          throw new Error(
+            "unwatch_session: no target thread \u2014 this call ran outside an agent thread, so pass threadId and resourceId explicitly."
+          );
+        }
+        const unsubscribed = this.unwatch({ threadId, resourceId }, input.sessionId);
+        return { unsubscribed, sessionId: input.sessionId };
+      }
+    });
+    return { watch_session, unwatch_session };
+  }
+};
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var execFileAsync2 = promisify(execFile);
+var DAEMON_STATE_SIGNAL_ID = "agentproto-daemon-state";
+var DaemonStateEmitter = class {
+  #client;
+  #cwd;
+  #env;
+  #runGit;
+  #lastByTarget = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.#client = opts.client;
+    this.#cwd = opts.cwd ?? process.cwd();
+    this.#env = opts.env ?? process.env;
+    this.#runGit = opts.runGit ?? defaultRunGit;
+  }
+  /**
+   * Compute the current daemon-state snapshot: sessions that are either this
+   * adapter's own daemon children or in `watchedSessionIds`, plus git status.
+   * Either half failing degrades (empty sessions / no git) rather than throws
+   * only for git; a daemon listSessions failure DOES throw — the caller (the
+   * signal provider's poll loop) already isolates and warn-onces it.
+   */
+  async computeSnapshot(watchedSessionIds) {
+    const ownSessionId = this.#env.AGENTPROTO_SESSION_ID;
+    const watched = new Set(watchedSessionIds);
+    const { sessions: rows } = await this.#client.listSessions({ includeArchived: true });
+    const sessions = rows.filter((row) => typeof row.id === "string").filter(
+      (row) => watched.has(row.id) || ownSessionId !== void 0 && row.parentSessionId === ownSessionId
+    ).map(
+      (row) => ({
+        id: row.id,
+        ...typeof row.label === "string" ? { label: row.label } : {},
+        ...typeof row.adapter === "string" ? { adapter: row.adapter } : {},
+        ...typeof row.status === "string" ? { status: row.status } : {},
+        ...typeof row.parentSessionId === "string" ? { parentSessionId: row.parentSessionId } : {}
+      })
+    ).sort((a, b) => a.id.localeCompare(b.id));
+    const git = await this.#gitState();
+    return { sessions, ...git ? { git } : {} };
+  }
+  /**
+   * Compute + send the state signal to one target thread. Returns what was
+   * sent: a full `snapshot` (first emission for this target), a `delta`
+   * (changed since last), or `unchanged` (nothing sent).
+   */
+  async emit(agent, target, watchedSessionIds) {
+    const snapshot = await this.computeSnapshot(watchedSessionIds);
+    const cacheKey = snapshotCacheKey(snapshot);
+    const targetKey = `${target.resourceId}:${target.threadId}`;
+    const prev = this.#lastByTarget.get(targetKey);
+    if (prev?.cacheKey === cacheKey) return "unchanged";
+    const mode = prev ? "delta" : "snapshot";
+    const contents = mode === "snapshot" ? renderSnapshot(snapshot) : renderDelta(prev.snapshot, snapshot);
+    await agent.sendStateSignal(
+      {
+        id: DAEMON_STATE_SIGNAL_ID,
+        cacheKey,
+        mode,
+        contents,
+        value: snapshot,
+        ...mode === "delta" ? { delta: diffSnapshots(prev.snapshot, snapshot) } : {}
+      },
+      { ...target, ifIdle: { behavior: "persist" } }
+    );
+    this.#lastByTarget.set(targetKey, { cacheKey, snapshot });
+    return mode;
+  }
+  async #gitState() {
+    try {
+      const out = await this.#runGit(["status", "--porcelain=v1", "--branch"], this.#cwd);
+      const lines = out.split("\n").filter((line) => line.length > 0);
+      const header = lines[0]?.startsWith("## ") ? lines[0].slice(3) : void 0;
+      const branch = header?.split("...")[0];
+      const dirtyFiles = lines.filter((line) => !line.startsWith("## ")).length;
+      return { ...branch ? { branch } : {}, dirtyFiles };
+    } catch {
+      return void 0;
+    }
+  }
+};
+async function defaultRunGit(args, cwd) {
+  const { stdout } = await execFileAsync2("git", args, {
+    cwd,
+    env: {
+      ...process.env,
+      // Stop repo discovery from walking above the workspace (see module doc).
+      GIT_CEILING_DIRECTORIES: dirname(resolve(cwd))
+    },
+    timeout: 1e4
+  });
+  return stdout;
+}
+function snapshotCacheKey(snapshot) {
+  return JSON.stringify(snapshot);
+}
+function describeSession(s) {
+  const label = s.label ? ` (${s.label})` : "";
+  const adapter = s.adapter ? ` [${s.adapter}]` : "";
+  return `${s.id}${label}${adapter}: ${s.status ?? "unknown"}`;
+}
+function renderSnapshot(snapshot) {
+  const lines = ["Daemon state snapshot:"];
+  if (snapshot.sessions.length === 0) {
+    lines.push("- sessions: none (no children or watched sessions)");
+  } else {
+    lines.push("- sessions:");
+    for (const s of snapshot.sessions) lines.push(`  - ${describeSession(s)}`);
+  }
+  if (snapshot.git) {
+    lines.push(
+      `- workspace git: ${snapshot.git.branch ?? "?"}, ${snapshot.git.dirtyFiles} dirty file(s)`
+    );
+  }
+  return lines.join("\n");
+}
+function diffSnapshots(prev, next) {
+  const prevById = new Map(prev.sessions.map((s) => [s.id, s]));
+  const nextById = new Map(next.sessions.map((s) => [s.id, s]));
+  const addedSessions = next.sessions.filter((s) => !prevById.has(s.id));
+  const removedSessions = prev.sessions.filter((s) => !nextById.has(s.id));
+  const statusChanges = next.sessions.filter((s) => prevById.has(s.id) && prevById.get(s.id).status !== s.status).map((s) => {
+    const from = prevById.get(s.id).status;
+    return { id: s.id, ...from !== void 0 ? { from } : {}, ...s.status !== void 0 ? { to: s.status } : {} };
+  });
+  const gitChanged = JSON.stringify(prev.git) !== JSON.stringify(next.git);
+  return {
+    addedSessions,
+    removedSessions,
+    statusChanges,
+    ...gitChanged ? {
+      git: {
+        ...prev.git ? { from: prev.git } : {},
+        ...next.git ? { to: next.git } : {}
+      }
+    } : {}
+  };
+}
+function renderDelta(prev, next) {
+  const delta = diffSnapshots(prev, next);
+  const lines = ["Daemon state changed:"];
+  for (const s of delta.addedSessions) lines.push(`- new session ${describeSession(s)}`);
+  for (const s of delta.removedSessions) lines.push(`- session ${s.id} no longer listed`);
+  for (const c of delta.statusChanges) {
+    lines.push(`- session ${c.id}: ${c.from ?? "unknown"} \u2192 ${c.to ?? "unknown"}`);
+  }
+  if (delta.git) {
+    const to = delta.git.to;
+    lines.push(
+      to ? `- workspace git: ${to.branch ?? "?"}, ${to.dirtyFiles} dirty file(s)` : "- workspace git state no longer readable"
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/tool-categories.ts
+var CATEGORY_BY_TOOL = {
+  list_dir: "read",
+  read_file: "read",
+  read_diff: "read",
+  write_file: "edit",
+  edit_file: "edit",
+  apply_patch: "edit",
+  run_command: "execute",
+  run_tests: "execute",
+  // Daemon verbs (WP-5) — spawning/prompting/reading a sibling session is the
+  // same "reach outside this run" shape as an MCP tool call, so it gets
+  // Mastra's `mcp` category (default policy `ask`, see below).
+  agent_start: "mcp",
+  agent_prompt: "mcp",
+  agent_output: "mcp",
+  session_list: "mcp",
+  // AgentController's built-in `subagent` spawner (WP-5) — spawning an
+  // in-process reviewer is the same "reach outside this run" shape as the
+  // daemon spawn verbs above, so it shares their `mcp` category and default
+  // `ask` policy rather than `other`'s (also `ask` today, but a distinct
+  // category keeps the two spawn surfaces — daemon vs. in-process — tunable
+  // independently later without a behavior change now).
+  subagent: "mcp",
+  // Signal-provider subscription tools (WP-6) — deliberately NOT `mcp` like
+  // the daemon verbs above: watching a session only registers an in-process
+  // subscription whose polling reads session metadata and transcript events,
+  // the same risk class as reading files. It can't spawn, prompt, or mutate
+  // anything outside this process, so it auto-allows as `read` instead of
+  // prompting on every watch.
+  watch_session: "read",
+  unwatch_session: "read",
+  // Notification inbox (WP-7, Mastra's `createNotificationInboxTool`) —
+  // `read`: its mutating actions (markSeen/dismiss/archive) only flip inbox
+  // bookkeeping on the agent's OWN notifications, never workspace or daemon
+  // state. Prompting for approval on every inbox check would defeat the
+  // inbox (the agent is supposed to consult it freely each turn).
+  "notification-inbox": "read",
+  // `submit_plan` (WP-3) gates itself: calling it always suspends the run
+  // for the user's approve/reject decision (see modes.ts's plan mode). It
+  // has no "other"-category behavior worth asking about a second time before
+  // that suspend even runs — see the per-tool "allow" override below.
+  submit_plan: "other"
+};
+function toolCategoryResolver(toolName) {
+  return CATEGORY_BY_TOOL[toolName] ?? null;
+}
+var DEFAULT_PERMISSION_RULES = {
+  categories: {
+    read: "allow",
+    edit: "ask",
+    execute: "ask",
+    mcp: "ask",
+    other: "ask"
+  },
+  tools: {
+    submit_plan: "allow"
+  }
+};
+
+// src/modes.ts
+var PLAN_MODE = {
+  id: "plan",
+  name: "Plan",
+  description: "Investigate the task and get a plan approved before touching code.",
+  instructions: "Investigate the task: read the relevant code and history, run read-only commands to understand current behavior. Do not write or edit files in this mode. Once you have a plan, call `submit_plan` with the path to the plan you've written for the user to review \u2014 do not paste the plan into chat. Wait for approval before implementing.",
+  availableTools: ["read_file", "list_dir", "read_diff", "run_command", "submit_plan"],
+  transitionsTo: "build",
+  metadata: { default: true }
+};
+var BUILD_MODE = {
+  id: "build",
+  name: "Build",
+  description: "Implement the approved plan.",
+  instructions: "Implement the approved plan. Write and edit files and run commands as needed, keeping changes scoped to what the plan described. When the implementation is done, move on to review.",
+  transitionsTo: "review"
+};
+var REVIEW_MODE = {
+  id: "review",
+  name: "Review",
+  description: "Review the changes, run checks, and report.",
+  instructions: "Review the changes made in build mode: read the diff, run type-checks and tests, and report the result. If something is broken, describe what's wrong so planning can resume.",
+  availableTools: ["read_file", "read_diff", "run_command", "run_tests", "list_dir"],
+  transitionsTo: "plan"
+};
+var DEFAULT_MODES = [PLAN_MODE, BUILD_MODE, REVIEW_MODE];
+var DEFAULT_MODE_ID = "plan";
+var MODES_HEADING_RE = /^##\s+Modes\s*$/i;
+var TOP_HEADING_RE = /^##\s+/;
+var MODE_SUBHEADING_RE = /^###\s+(.*)$/;
+function titleCase(id) {
+  return id.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function parseModesFromAgentMd(body) {
+  const lines = body.split(/\r?\n/);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (MODES_HEADING_RE.test(lines[i])) {
+      start = i + 1;
+      break;
+    }
+  }
+  if (start === -1) return void 0;
+  let end = lines.length;
+  for (let i = start; i < lines.length; i++) {
+    if (TOP_HEADING_RE.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  const sectionLines = lines.slice(start, end);
+  const subsections = [];
+  let current;
+  for (const line of sectionLines) {
+    const heading = MODE_SUBHEADING_RE.exec(line);
+    if (heading) {
+      const id = heading[1].trim();
+      if (!id) {
+        throw new Error("AGENT.md '## Modes': a '### ' subsection has no mode id.");
+      }
+      current = { id, lines: [] };
+      subsections.push(current);
+    } else if (current) {
+      current.lines.push(line);
+    }
+  }
+  if (subsections.length === 0) {
+    throw new Error(
+      "AGENT.md declares a '## Modes' section but no '### <mode-id>' subsections were found \u2014 each mode needs its own '### <id>' heading."
+    );
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const modes = [];
+  let explicitDefaultId;
+  for (const { id, lines: bodyLines } of subsections) {
+    if (seenIds.has(id)) {
+      throw new Error(`AGENT.md '## Modes': duplicate mode id '${id}'.`);
+    }
+    seenIds.add(id);
+    let tools;
+    let transitionsTo;
+    let isDefault = false;
+    let bodyStart = 0;
+    for (; bodyStart < bodyLines.length; bodyStart++) {
+      const line = bodyLines[bodyStart].trim();
+      if (line === "") continue;
+      const toolsMatch = /^tools:\s*(.*)$/i.exec(line);
+      const transitionsMatch = /^transitions_to:\s*(.*)$/i.exec(line);
+      const defaultMatch = /^default:\s*(true|false)\s*$/i.exec(line);
+      if (toolsMatch) {
+        tools = toolsMatch[1].split(",").map((t) => t.trim()).filter(Boolean);
+      } else if (transitionsMatch) {
+        transitionsTo = transitionsMatch[1].trim() || void 0;
+      } else if (defaultMatch) {
+        isDefault = defaultMatch[1].toLowerCase() === "true";
+      } else {
+        break;
+      }
+    }
+    const instructions = bodyLines.slice(bodyStart).join("\n").trim();
+    if (isDefault) {
+      if (explicitDefaultId) {
+        throw new Error(
+          `AGENT.md '## Modes': more than one mode flagged 'default: true' ('${explicitDefaultId}', '${id}').`
+        );
+      }
+      explicitDefaultId = id;
+    }
+    modes.push({
+      id,
+      name: titleCase(id),
+      ...instructions ? { instructions } : {},
+      ...tools ? { availableTools: tools } : {},
+      ...transitionsTo ? { transitionsTo } : {}
+    });
+  }
+  const defaultModeId = explicitDefaultId ?? modes[0].id;
+  const defaultMode = modes.find((m) => m.id === defaultModeId);
+  defaultMode.metadata = { ...defaultMode.metadata, default: true };
+  return { modes, defaultModeId };
+}
+function resolveModes(body) {
+  return parseModesFromAgentMd(body) ?? {
+    modes: [...DEFAULT_MODES],
+    defaultModeId: DEFAULT_MODE_ID
+  };
+}
+
+// src/default-agent.ts
+var DEFAULT_MODEL = "openrouter/z-ai/glm-5.2";
+var DEFAULT_TOOL_IDS = [
+  "list_dir",
+  "read_file",
+  "write_file",
+  "edit_file",
+  "run_command"
+];
+function envFlag(value) {
+  return Boolean(value);
+}
+function defaultAgentManifest(model) {
+  return [
+    "---",
+    "schema: agent/v1",
+    "id: mastra-agent",
+    "description: A first-party agentproto agent powered by Mastra.",
+    `model: ${model}`,
+    "version: 0.1.0",
+    "tools:",
+    ...DEFAULT_TOOL_IDS.map((id) => `  - ${id}`),
+    "memory:",
+    "  scope: per-conversation",
+    "  retention_turns: 20",
+    "---",
+    "",
+    "You are a capable, concise coding agent operating inside a workspace ",
+    "directory. You can list, read, write, and edit files and run shell ",
+    "commands there using your tools. Do exactly what the user asks \u2014 when ",
+    "asked to reply with an exact string, reply with only that string.",
+    ""
+  ].join("\n");
+}
+function toolRefId(ref) {
+  if (typeof ref === "string") return ref;
+  if (ref && typeof ref === "object" && typeof ref.ref === "string") {
+    return ref.ref;
+  }
+  return void 0;
+}
+async function resolveAgentSource(opts = {}) {
+  if (opts.agentFile) return readFile(opts.agentFile, "utf8");
+  return defaultAgentManifest(opts.model ?? DEFAULT_MODEL);
+}
+var DISABLED_BUILTIN_TOOL_IDS = [
+  "ask_user",
+  "submit_plan",
+  "task_write",
+  "task_update",
+  "task_complete",
+  "task_check",
+  "subagent"
+];
+var REENABLED_BUILTIN_TOOL_IDS = ["submit_plan", "subagent"];
+var REVIEWER_ALLOWED_TOOL_IDS = ["read_file", "read_diff", "run_tests", "list_dir"];
+var REVIEWER_SUBAGENT = {
+  id: "reviewer",
+  name: "Code reviewer",
+  description: "Reviews changes for correctness and reports findings.",
+  instructions: "You are reviewing a change for correctness. Read the diff (`read_diff`) and the files it touches, run the test suite (`run_tests`) if one exists, and report concrete findings: bugs, missed edge cases, and test gaps. You cannot edit files \u2014 report findings back to the caller instead of trying to fix them yourself.",
+  allowedControllerTools: [...REVIEWER_ALLOWED_TOOL_IDS],
+  forked: true
+};
+function makeAgentFactory(opts = {}) {
+  return async () => {
+    const source = await resolveAgentSource(opts);
+    const { frontmatter, body } = parseAgentManifest(source);
+    const handle = agentFromManifest({ frontmatter, body });
+    const cwd = opts.cwd ?? process.cwd();
+    const workspaceTools = makeWorkspaceTools({
+      cwd,
+      allowExec: opts.allowExec,
+      extraTools: opts.extraTools
+    });
+    const store = buildSqliteStore();
+    let memory;
+    const historyCompat = new ProviderHistoryCompat({
+      additionalRules: [{
+        name: "strip-trailing-reasoning-from-assistant",
+        applyToPrompt({ prompt }) {
+          let mutated = false;
+          const next = prompt.map((message) => {
+            if (message.role !== "assistant" || !Array.isArray(message.content)) return message;
+            const content = message.content;
+            const last = content[content.length - 1];
+            if (!last || last.type !== "reasoning") return message;
+            const filtered = content.filter((p) => p.type !== "reasoning");
+            mutated = true;
+            return { ...message, content: filtered.length > 0 ? filtered : [{ type: "text", text: "" }] };
+          });
+          return mutated ? next : void 0;
+        }
+      }]
+    });
+    const { agent } = await buildMastraAgent(handle, {
+      inputProcessors: [historyCompat],
+      resolveModel: (ref) => resolveMastraModel(ref),
+      // Match each declared tool ref against the workspace toolset by id. A
+      // ref with no matching executor still resolves — to a stub that fails
+      // fast and clearly on call — rather than being dropped: a dropped ref
+      // leaves the model unable to see it at all, and (if the model still
+      // tries the name from AGENT.md prose) surfaces as an opaque provider
+      // NoSuchToolError this adapter's ACP layer silently swallows (see
+      // tool-call-map.ts), which is how a declared-but-unwired tool used to
+      // hang a turn with zero recorded tool calls instead of failing fast.
+      resolveTool: (ref) => {
+        const id = toolRefId(ref);
+        if (!id) return void 0;
+        const tool = workspaceTools[id];
+        if (tool) return { name: id, tool };
+        console.warn(
+          `[@agentproto/adapter-mastra-agent] agent '${handle.id}' declares tool '${id}' but no executor is wired for it in this adapter's workspace toolset \u2014 calls to it will fail immediately instead of hanging. Wire it in workspace-tools.ts or pass it via extraTools.`
+        );
+        return { name: id, tool: makeUnwiredToolStub(id) };
+      },
+      buildMemory: (config2) => memory = buildSqliteMemory(config2, process.env, store),
+      // The markdown body is the agent's primary system prompt (AIP-42).
+      body
+    });
+    const modesEnabled = opts.modes !== false && !envFlag(process.env.AGENTPROTO_MASTRA_NO_MODES);
+    const { modes, defaultModeId } = modesEnabled ? resolveModes(body) : { modes: [{ id: "main", metadata: { default: true } }], defaultModeId: "main" };
+    let tools = workspaceTools;
+    if (modesEnabled) {
+      const daemonClient = new DaemonClient({ cwd });
+      tools = { ...workspaceTools, ...makeDaemonTools({ client: daemonClient }) };
+      const signalProvider = new AgentprotoSignalProvider({
+        client: daemonClient,
+        stateEmitter: new DaemonStateEmitter({ client: daemonClient, cwd })
+      });
+      signalProvider.connect(agent);
+      signalProvider.startPolling();
+      tools = { ...tools, ...signalProvider.getTools() };
+      const notificationsStorage = await store.getStore("notifications");
+      if (notificationsStorage) {
+        tools = {
+          ...tools,
+          "notification-inbox": createNotificationInboxTool({ storage: notificationsStorage })
+        };
+      }
+    }
+    const config = {
+      id: "agentproto-native",
+      // The AGENT.md-built agent backs every mode; parity mode has exactly
+      // one mode and layers no mode instructions, so runs behave as the raw
+      // agent did.
+      agent,
+      modes,
+      defaultModeId,
+      // Thread rows + per-thread settings persist to the same SQLite file the
+      // agent's Memory writes messages to.
+      storage: store,
+      // Our hardened workspace toolset (+ daemon tools, modes-on) stays the
+      // tool surface. The backing agent already carries the AGENT.md-declared
+      // subset; controller-level tools are an additive toolset, so ids
+      // overlap onto the same executors.
+      tools,
+      // Parity mode disables every built-in controller tool and skips tool
+      // approvals entirely (`yolo: true` keeps `requireToolApproval` off so
+      // tools execute pass-through exactly as the raw stream did). Modes-on
+      // re-enables `submit_plan` (the plan mode's approval gate) and
+      // `subagent` (WP-5's in-process reviewer, see `REVIEWER_SUBAGENT`), and
+      // seeds real per-category tool-approval policy instead.
+      disableBuiltinTools: modesEnabled ? DISABLED_BUILTIN_TOOL_IDS.filter((id) => !REENABLED_BUILTIN_TOOL_IDS.includes(id)) : [...DISABLED_BUILTIN_TOOL_IDS],
+      toolCategoryResolver,
+      initialState: modesEnabled ? { permissionRules: DEFAULT_PERMISSION_RULES } : { yolo: true },
+      // `Session` construction hard-requires a `Workspace` instance
+      // (`createSession` throws "A session requires a valid workspace
+      // instance" without one) — but a *filesystem/sandbox*-backed Workspace
+      // makes Mastra auto-inject its own `mastra_workspace_*` file/exec tools
+      // into every run, duplicating our own hardened workspace toolset. A
+      // skills-only Workspace (no filesystem, no sandbox) satisfies the
+      // former without triggering the latter: `createWorkspaceTools` only
+      // adds filesystem/sandbox tools, so this config contributes none.
+      workspace: new Workspace({ skills: () => [] })
+    };
+    if (memory) config.memory = memory;
+    if (modesEnabled) config.subagents = [REVIEWER_SUBAGENT];
+    return { controller: new AgentController(config) };
+  };
+}
+
+// src/tool-call-map.ts
+function toolKindFor(toolName) {
+  switch (toolName) {
+    case "read_file":
+    case "list_dir":
+      return "read";
+    case "write_file":
+    case "edit_file":
+      return "edit";
+    case "run_command":
+      return "execute";
+    default:
+      return "other";
+  }
+}
+function toolCallTitle(toolName, args) {
+  if (args && typeof args === "object") {
+    const { command, path, file } = args;
+    const hint = typeof command === "string" && command || typeof path === "string" && path || typeof file === "string" && file || "";
+    if (hint) return `${toolName}: ${hint}`;
+  }
+  return toolName;
+}
+function errorMessage2(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function messageText(message) {
+  const parts = message.content?.parts;
+  if (!Array.isArray(parts)) return "";
+  let text = "";
+  for (const part of parts) {
+    if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+      text += part.text;
+    }
+  }
+  return text;
+}
+function createEventMapper() {
+  const relayed = /* @__PURE__ */ new Map();
+  return (event) => {
+    switch (event.type) {
+      case "message_update": {
+        if (event.message.role !== "assistant") return null;
+        const text = messageText(event.message);
+        const seen = relayed.get(event.message.id) ?? 0;
+        if (text.length <= seen) return null;
+        relayed.set(event.message.id, text.length);
+        return {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: text.slice(seen) }
+        };
+      }
+      case "tool_start": {
+        if (!event.toolCallId) return null;
+        const toolName = event.toolName || "tool";
+        return {
+          sessionUpdate: "tool_call",
+          toolCallId: event.toolCallId,
+          title: toolCallTitle(toolName, event.args),
+          kind: toolKindFor(toolName),
+          status: "in_progress",
+          rawInput: event.args
+        };
+      }
+      case "tool_end": {
+        if (!event.toolCallId) return null;
+        return {
+          sessionUpdate: "tool_call_update",
+          toolCallId: event.toolCallId,
+          status: event.isError ? "failed" : "completed",
+          rawOutput: event.isError ? { error: errorMessage2(event.result) } : event.result
+        };
+      }
+      default:
+        return null;
+    }
+  };
+}
+var DEFAULT_MODEL_CATALOG = [
+  { id: "openrouter/z-ai/glm-5.2" },
+  { id: "openrouter/deepseek/deepseek-v4-pro" },
+  { id: "openai/gpt-5" }
+];
+var APPROVAL_OPTIONS = [
+  { optionId: "approve", name: "Approve", kind: "allow_once" },
+  {
+    optionId: "always_allow_category",
+    name: "Always allow this category",
+    kind: "allow_always"
+  },
+  { optionId: "decline", name: "Decline", kind: "reject_once" }
+];
+var SUSPENSION_OPTIONS = [
+  { optionId: "approve", name: "Continue", kind: "allow_once" },
+  { optionId: "decline", name: "Cancel", kind: "reject_once" }
+];
+var META_SUSPEND_PAYLOAD = "mastra-agent/suspendPayload";
+var META_RESUME_SCHEMA = "mastra-agent/resumeSchema";
+var META_RESUME_DATA = "mastra-agent/resumeData";
+function emptySessionState() {
+  return {
+    session: null,
+    turn: null,
+    pendingModelId: null,
+    pendingModeId: null,
+    suspensions: /* @__PURE__ */ new Map()
+  };
+}
+function promptText(params) {
+  return promptContent(params).text;
+}
+function filenameOf(uri) {
+  if (typeof uri !== "string" || !uri) return void 0;
+  return uri.split("/").pop() || void 0;
+}
+function textMediaType(mimeType) {
+  if (mimeType && (mimeType.startsWith("text/") || mimeType === "application/json")) {
+    return mimeType;
+  }
+  return "text/plain";
+}
+function promptContent(params) {
+  const blocks = Array.isArray(params.prompt) ? params.prompt : [];
+  let text = "";
+  const files = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    switch (block.type) {
+      case "text":
+        if (typeof block.text === "string") text += block.text;
+        break;
+      case "image": {
+        const filename = filenameOf(block.uri);
+        files.push({
+          data: block.data,
+          mediaType: block.mimeType,
+          ...filename ? { filename } : {}
+        });
+        break;
+      }
+      case "audio":
+        files.push({ data: block.data, mediaType: block.mimeType });
+        break;
+      case "resource": {
+        const resource = block.resource;
+        if (!resource || typeof resource !== "object") break;
+        const filename = filenameOf(resource.uri);
+        if ("text" in resource && typeof resource.text === "string") {
+          files.push({
+            data: resource.text,
+            mediaType: textMediaType(resource.mimeType),
+            ...filename ? { filename } : {}
+          });
+        } else if ("blob" in resource && typeof resource.blob === "string") {
+          files.push({
+            data: resource.blob,
+            mediaType: resource.mimeType || "application/octet-stream",
+            ...filename ? { filename } : {}
+          });
+        }
+        break;
+      }
+    }
+  }
+  return { text: text.trim(), files };
+}
+function describeError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const msg = err.message || void 0;
+  const causeMsg = err.cause instanceof Error ? err.cause.message : void 0;
+  const detail = msg && msg !== "Error" ? msg : causeMsg || msg || "unknown error";
+  const frames = err.stack?.split("\n").slice(1, 3).map((l) => l.trim()).filter(Boolean);
+  return frames?.length ? `${detail} [${frames.join(" \u2190 ")}]` : detail;
+}
+var MastraAcpAgent = class {
+  #conn;
+  #buildController;
+  #resource;
+  #models;
+  #sessions = /* @__PURE__ */ new Map();
+  #controller = null;
+  constructor(conn, buildController, resource = "mastra-agent", models = DEFAULT_MODEL_CATALOG) {
+    this.#conn = conn;
+    this.#buildController = buildController;
+    this.#resource = resource;
+    this.#models = models;
+  }
+  async initialize(_params) {
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      agentCapabilities: {
+        // session/load reconnects the Mastra thread and replays its history.
+        loadSession: true,
+        promptCapabilities: {
+          image: true,
+          audio: true,
+          embeddedContext: true
+        }
+      }
+    };
+  }
+  async authenticate(_params) {
+    return {};
+  }
+  async newSession(_params) {
+    const sessionId = randomId();
+    this.#sessions.set(sessionId, emptySessionState());
+    return { sessionId };
+  }
+  /**
+   * Resume an existing session: reconnect the controller session (scope +
+   * thread keyed by the ACP session id — `createSession` resumes an existing
+   * Mastra thread with full history) and replay the conversation to the
+   * client, as the `session/load` contract requires, via `user_message_chunk`
+   * / `agent_message_chunk` updates.
+   *
+   * Unlike `prompt`, this NEEDS the controller now (replay reads the thread),
+   * so build errors surface as this request's JSON-RPC error rather than a
+   * first-prompt error chunk.
+   */
+  async loadSession(params) {
+    const sessionId = params.sessionId;
+    let state = this.#sessions.get(sessionId);
+    if (!state) {
+      state = emptySessionState();
+      this.#sessions.set(sessionId, state);
+    }
+    const session = await this.#ensureSession(sessionId, state);
+    const messages = await session.thread.listMessages({ threadId: sessionId });
+    for (const message of messages) {
+      if (message.role !== "user" && message.role !== "assistant") continue;
+      const text = messageText(message);
+      if (!text) continue;
+      await this.#conn.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: message.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+          content: { type: "text", text }
+        }
+      });
+    }
+    return { configOptions: this.#modelConfigOptions(this.#currentModelId(state)) };
+  }
+  async prompt(params) {
+    const state = this.#sessions.get(params.sessionId);
+    if (!state) throw new Error(`unknown session ${params.sessionId}`);
+    const interrupted = state.turn;
+    if (interrupted) interrupted.cancelled = true;
+    const turn = { cancelled: false };
+    state.turn = turn;
+    const { text, files } = promptContent(params);
+    try {
+      const session = await this.#ensureSession(params.sessionId, state);
+      const map = createEventMapper();
+      let endReason;
+      let lastError = null;
+      let relay = Promise.resolve();
+      let resolveAgentEnd;
+      const agentEndPromise = new Promise((r) => {
+        resolveAgentEnd = r;
+      });
+      const unsubscribe = session.subscribe((event) => {
+        if (event.type === "error") {
+          lastError = event.error;
+          return;
+        }
+        if (event.type === "agent_end") {
+          endReason = event.reason ?? "complete";
+          resolveAgentEnd?.();
+          return;
+        }
+        if (event.type === "tool_approval_required") {
+          const tail3 = relay;
+          void tail3.catch(() => {
+          }).then(() => this.#bridgeApproval(params.sessionId, session, event)).catch(() => {
+          });
+          return;
+        }
+        if (event.type === "tool_suspended") {
+          const pending = { cancelled: false };
+          state.suspensions.set(event.toolCallId, pending);
+          const tail3 = relay;
+          void tail3.catch(() => {
+          }).then(
+            () => this.#bridgeSuspension(params.sessionId, session, state, event, pending)
+          ).catch(() => {
+          });
+          return;
+        }
+        if (event.type === "tool_suspension_cancelled") {
+          const pending = state.suspensions.get(event.toolCallId);
+          if (pending) pending.cancelled = true;
+          state.suspensions.delete(event.toolCallId);
+          return;
+        }
+        const update = map(event);
+        if (!update) return;
+        relay = relay.then(
+          () => this.#conn.sessionUpdate({ sessionId: params.sessionId, update })
+        );
+      });
+      try {
+        if (interrupted) {
+          if (files.length) {
+            session.abort();
+            await session.sendMessage({ content: text, files });
+          } else {
+            await session.steer({ content: text });
+          }
+        } else if (files.length) {
+          await session.sendMessage({ content: text, files });
+        } else {
+          await session.sendMessage({ content: text });
+        }
+        if (!endReason && !lastError && !turn.cancelled) {
+          await agentEndPromise;
+        }
+      } finally {
+        unsubscribe();
+        await relay.catch(() => {
+        });
+      }
+      if (turn.cancelled || endReason === "aborted") {
+        return { stopReason: "cancelled" };
+      }
+      if (endReason === "error") {
+        throw lastError ?? new Error("the agent run ended with an error");
+      }
+      return { stopReason: "end_turn" };
+    } catch (err) {
+      if (turn.cancelled) return { stopReason: "cancelled" };
+      await this.#conn.sessionUpdate({
+        sessionId: params.sessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: {
+            type: "text",
+            text: `
+[mastra-agent error] ${describeError(err)}
+`
+          }
+        }
+      });
+      return { stopReason: "refusal" };
+    } finally {
+      if (state.turn === turn) state.turn = null;
+    }
+  }
+  async cancel(params) {
+    const state = this.#sessions.get(params.sessionId);
+    if (!state) return;
+    if (state.turn) state.turn.cancelled = true;
+    state.session?.abort();
+  }
+  /**
+   * The host applies the operator's `model` as a `--model` spawn arg via the
+   * manifest `bin_args_template`, then ALSO calls this ACP config hook (the
+   * daemon's default "config" apply path). Runtime switches go through
+   * `session.model.switch`; a choice made before the controller session
+   * exists is remembered and applied on creation, preserving the invariant
+   * that controller build errors surface on the first prompt.
+   */
+  async setSessionConfigOption(params) {
+    const state = this.#sessions.get(params.sessionId);
+    if (!state) throw new Error(`unknown session ${params.sessionId}`);
+    if (params.configId === "model") {
+      const modelId = String(params.value ?? "");
+      if (modelId) {
+        if (state.session) await state.session.model.switch({ modelId });
+        else state.pendingModelId = modelId;
+      }
+    }
+    return {
+      configOptions: this.#modelConfigOptions(this.#currentModelId(state))
+    };
+  }
+  /** Switch the controller session's mode (the catalog itself is controller
+   *  config — WP-3). Mode-change confirmations reach the client via the
+   *  session-lifetime `mode_changed` → `current_mode_update` relay. */
+  async setSessionMode(params) {
+    const state = this.#sessions.get(params.sessionId);
+    if (!state) throw new Error(`unknown session ${params.sessionId}`);
+    if (state.session) await state.session.mode.switch({ modeId: params.modeId });
+    else state.pendingModeId = params.modeId;
+    return {};
+  }
+  /** The ACP `model` config option (a select), reflecting `currentValue`.
+   *  A free-form current id not in the catalog is appended so the reported
+   *  state stays coherent. */
+  #modelConfigOptions(currentValue) {
+    const options = this.#models.map((m) => ({ value: m.id, name: m.name ?? m.id }));
+    if (currentValue && !options.some((o) => o.value === currentValue)) {
+      options.push({ value: currentValue, name: currentValue });
+    }
+    return [
+      {
+        type: "select",
+        id: "model",
+        name: "Model",
+        category: "model",
+        description: "Model id routed via Mastra's model gateway",
+        currentValue,
+        options
+      }
+    ];
+  }
+  #currentModelId(state) {
+    const selected = state.session?.model.get() ?? "";
+    return selected || state.pendingModelId || this.#models[0]?.id || "";
+  }
+  /** Relay a parked `tool_approval_required` gate as an ACP permission
+   *  request and feed the user's decision back to the controller session. */
+  async #bridgeApproval(sessionId, session, event) {
+    const toolName = event.toolName || "tool";
+    let decision = "decline";
+    try {
+      const { outcome } = await this.#conn.requestPermission({
+        sessionId,
+        toolCall: {
+          toolCallId: event.toolCallId,
+          title: toolCallTitle(toolName, event.args),
+          kind: toolKindFor(toolName),
+          status: "pending",
+          rawInput: event.args
+        },
+        options: APPROVAL_OPTIONS
+      });
+      if (outcome.outcome === "selected") {
+        if (outcome.optionId === "approve" || outcome.optionId === "always_allow_category") {
+          decision = outcome.optionId;
+        }
+      }
+    } catch {
+    }
+    session.respondToToolApproval({ decision, toolCallId: event.toolCallId });
+  }
+  /**
+   * Relay a `tool_suspended` run as an ACP permission request. ACP's answer is
+   * an option pick, not free-form data, so the suspend payload and resume
+   * schema ride out on the request's `_meta` and the resume data rides back on
+   * the outcome's `_meta` (`mastra-agent/resumeData`) when the client supplies
+   * it — else Continue/Cancel resume with `{ approved: true | false }` (the
+   * shape the built-in `submit_plan` approval path consumes).
+   */
+  async #bridgeSuspension(sessionId, session, state, event, pending) {
+    const toolName = event.toolName || "tool";
+    try {
+      const { outcome } = await this.#conn.requestPermission({
+        sessionId,
+        toolCall: {
+          toolCallId: event.toolCallId,
+          title: toolCallTitle(toolName, event.args),
+          kind: toolKindFor(toolName),
+          status: "in_progress",
+          rawInput: event.args,
+          _meta: {
+            [META_SUSPEND_PAYLOAD]: event.suspendPayload,
+            ...event.resumeSchema !== void 0 ? { [META_RESUME_SCHEMA]: event.resumeSchema } : {}
+          }
+        },
+        options: SUSPENSION_OPTIONS
+      });
+      if (pending.cancelled) return;
+      if (outcome.outcome !== "selected") return;
+      const meta = outcome._meta;
+      const resumeData = meta && META_RESUME_DATA in meta ? meta[META_RESUME_DATA] : { approved: outcome.optionId === "approve" };
+      await session.respondToToolSuspension({
+        resumeData,
+        toolCallId: event.toolCallId
+      });
+    } catch {
+      if (!pending.cancelled) {
+        await session.respondToToolSuspension({
+          resumeData: { approved: false },
+          toolCallId: event.toolCallId
+        }).catch(() => {
+        });
+      }
+    } finally {
+      if (state.suspensions.get(event.toolCallId) === pending) {
+        state.suspensions.delete(event.toolCallId);
+      }
+    }
+  }
+  /** Resolve this ACP session's controller session, creating it on first use.
+   *  Deferred to the first prompt (not session/new) on purpose: controller
+   *  construction parses the AGENT.md and resolves the model, and those
+   *  errors must keep surfacing as a first-prompt error chunk + "refusal",
+   *  never as a session/new JSON-RPC failure. (`session/load` opts into the
+   *  eager path — replay can't happen without the controller.) */
+  async #ensureSession(acpSessionId, state) {
+    if (state.session) return state.session;
+    const controller = await this.#ensureController();
+    const session = await controller.createSession({
+      resourceId: this.#resource,
+      scope: acpSessionId,
+      threadId: acpSessionId
+    });
+    session.subscribe((event) => {
+      if (event.type === "mode_changed") {
+        void this.#conn.sessionUpdate({
+          sessionId: acpSessionId,
+          update: {
+            sessionUpdate: "current_mode_update",
+            currentModeId: event.modeId
+          }
+        }).catch(() => {
+        });
+      } else if (event.type === "model_changed") {
+        void this.#conn.sessionUpdate({
+          sessionId: acpSessionId,
+          update: {
+            sessionUpdate: "config_option_update",
+            // Read the session's own selection: a `model_changed` scoped to
+            // a non-active mode doesn't move the effective model.
+            configOptions: this.#modelConfigOptions(
+              session.model.get() || event.modelId
+            )
+          }
+        }).catch(() => {
+        });
+      }
+    });
+    state.session = session;
+    if (state.pendingModeId) {
+      const modeId = state.pendingModeId;
+      state.pendingModeId = null;
+      await session.mode.switch({ modeId });
+    }
+    if (state.pendingModelId) {
+      const modelId = state.pendingModelId;
+      state.pendingModelId = null;
+      await session.model.switch({ modelId });
+    }
+    return session;
+  }
+  async #ensureController() {
+    if (this.#controller) return this.#controller;
+    const { controller } = await this.#buildController();
+    await controller.init();
+    this.#controller = controller;
+    return controller;
+  }
+};
+function randomId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function runAcpOverStdio(buildController) {
+  const toClient = Writable.toWeb(process.stdout);
+  const fromClient = Readable.toWeb(
+    process.stdin
+  );
+  const stream = ndJsonStream(toClient, fromClient);
+  return new AgentSideConnection(
+    (conn) => new MastraAcpAgent(conn, buildController),
+    stream
+  );
+}
+
+export { DEFAULT_MODEL, DEFAULT_MODEL_CATALOG, DEFAULT_TOOL_IDS, DISABLED_BUILTIN_TOOL_IDS, DaemonClient, DaemonHttpError, DaemonNotFoundError, MastraAcpAgent, buildSqliteMemory, buildSqliteStore, createEventMapper, defaultAgentManifest, discoverDaemonEndpoint, makeAgentFactory, makeDaemonTools, makeWorkspaceTools, messageText, modelRefToString, promptContent, promptText, providerOf, resolveInCwd, resolveMastraModel, resolveMemoryDbPath, runAcpOverStdio, toolCallTitle, toolKindFor };
+//# sourceMappingURL=chunk-5C2H4JSD.mjs.map
+//# sourceMappingURL=chunk-5C2H4JSD.mjs.map