@hydra-acp/cli 0.1.60 → 0.1.62

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/daemon/server.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as fsp7 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
@@ -88,6 +88,23 @@ var paths = {
   // the agent invocation (see Session.drainQueue) so a crash mid-
   // generation doesn't double-run on restart.
   queueFile: (id) => path.join(hydraHome(), "sessions", id, "queue.ndjson"),
+  // Tombstones for sessions that were deleted locally but might still
+  // be reported by an agent's session/list at the next periodic sync.
+  // One file per (agentId, upstreamSessionId); existence is the source
+  // of truth, contents are a small JSON blob for diagnostics and the
+  // "agent advanced past our snapshot → resurrect" decision. Hidden
+  // under sessions/ because SessionStore.read() filters non-conforming
+  // dir names (the leading dot fails SESSION_ID_PATTERN) so the
+  // directory cohabits safely with real session directories.
+  tombstonesDir: () => path.join(hydraHome(), "sessions", ".tombstones"),
+  tombstoneAgentDir: (agentId) => path.join(hydraHome(), "sessions", ".tombstones", encodeURIComponent(agentId)),
+  tombstoneFile: (agentId, upstreamSessionId) => path.join(
+    hydraHome(),
+    "sessions",
+    ".tombstones",
+    encodeURIComponent(agentId),
+    encodeURIComponent(upstreamSessionId)
+  ),
   extensionsDir: () => path.join(hydraHome(), "extensions"),
   extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
   extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
@@ -267,7 +284,27 @@ var DaemonConfig = z.object({
 });
 var RegistryConfig = z.object({
   url: z.string().url().default(REGISTRY_URL_DEFAULT),
-  ttlHours: z.number().positive().default(24)
+  ttlHours: z.number().positive().default(24),
+  // When true, the daemon never re-fetches the registry over the network:
+  // it serves whatever is in the on-disk cache (~/.hydra-acp/registry.json)
+  // indefinitely, ignoring ttlHours. An escape hatch for when a bad registry
+  // push breaks an agent — pin to the last-known-good cache until upstream
+  // is fixed. `hydra registry refresh` still forces a one-off fetch.
+  pinned: z.boolean().default(false)
+});
+var LocalAgentConfig = z.object({
+  name: z.string().optional(),
+  description: z.string().optional(),
+  // Optional: defaults to the agent id (the config.agents key), mirroring
+  // how extensions default their command to the extension name. Set it
+  // when the executable differs from the id, or to point at an absolute
+  // path / wrapper script.
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional()
+});
+var AgentOverrideConfig = z.object({
+  packageSpec: z.string().optional()
 });
 var TuiConfig = z.object({
   // Minimum interval (ms) between full-screen repaints driven by content
@@ -385,7 +422,18 @@ var TransformerBody = z.object({
 });
 var HydraConfig = z.object({
   daemon: DaemonConfig.default({}),
-  registry: RegistryConfig.default({ url: REGISTRY_URL_DEFAULT, ttlHours: 24 }),
+  registry: RegistryConfig.default({
+    url: REGISTRY_URL_DEFAULT,
+    ttlHours: 24,
+    pinned: false
+  }),
+  // User-defined agents that bypass the network registry. Keyed by agent
+  // id; each is spawned via its `command`/`args` directly. Shadow registry
+  // agents of the same id.
+  agents: z.record(z.string(), LocalAgentConfig).default({}),
+  // Per-agent pin overrides applied to registry agents (e.g. force a
+  // specific npm version of opencode). Keyed by agent id.
+  agentOverrides: z.record(z.string(), AgentOverrideConfig).default({}),
   defaultAgent: z.string().default("opencode"),
   // Optional per-agent default model id. When a brand-new agent process
   // is spawned (session/new path), hydra issues session/set_model with
@@ -1062,10 +1110,16 @@ var UvxDistribution = z2.object({
   args: z2.array(z2.string()).optional(),
   env: z2.record(z2.string()).optional()
 });
+var ExecDistribution = z2.object({
+  command: z2.string(),
+  args: z2.array(z2.string()).optional(),
+  env: z2.record(z2.string()).optional()
+});
 var Distribution = z2.object({
   npx: NpxDistribution.optional(),
   binary: BinaryDistribution.optional(),
-  uvx: UvxDistribution.optional()
+  uvx: UvxDistribution.optional(),
+  exec: ExecDistribution.optional()
 });
 var RegistryAgent = z2.object({
   id: z2.string(),
@@ -1093,11 +1147,11 @@ var Registry = class {
   options;
   cache;
   async load() {
-    if (this.cache && this.isFresh(this.cache.fetchedAt)) {
+    if (this.cache && (this.isPinned() || this.isFresh(this.cache.fetchedAt))) {
       return this.cache.data;
     }
     const onDisk = await this.readDiskCache();
-    if (onDisk && this.isFresh(onDisk.fetchedAt)) {
+    if (onDisk && (this.isPinned() || this.isFresh(onDisk.fetchedAt))) {
       this.cache = onDisk;
       return onDisk.data;
     }
@@ -1128,12 +1182,57 @@ var Registry = class {
     return this.cache?.fetchedAt;
   }
   async getAgent(id) {
+    const local = this.localAgents().find((a) => a.id === id);
+    if (local) {
+      return local;
+    }
     const doc = await this.load();
     const exact = doc.agents.find((a) => a.id === id);
     if (exact) {
-      return exact;
+      return this.applyOverride(exact);
     }
-    return doc.agents.find((a) => npxPackageBasename(a) === id);
+    const byBasename = doc.agents.find((a) => npxPackageBasename(a) === id);
+    return byBasename ? this.applyOverride(byBasename) : void 0;
+  }
+  // Synthesize RegistryAgent entries from config.agents. These carry an
+  // `exec` distribution and a fixed "local" version key (no install dir).
+  localAgents() {
+    return Object.entries(this.config.agents ?? {}).map(([id, def]) => ({
+      id,
+      name: def.name ?? id,
+      description: def.description,
+      version: "local",
+      distribution: {
+        exec: {
+          // Default the command to the agent id (like extensions default
+          // theirs to the extension name) — resolved off PATH at spawn.
+          command: def.command ?? id,
+          args: def.args,
+          env: def.env
+        }
+      }
+    }));
+  }
+  // Apply a config.agentOverrides[id] pin to a registry agent: swap the
+  // npx package spec and key the install dir on the pinned version so it
+  // never collides with the floating "current" install. No-op when the
+  // agent has no override or isn't npx-distributed.
+  applyOverride(agent) {
+    const override = this.config.agentOverrides?.[agent.id];
+    if (!override?.packageSpec || !agent.distribution.npx) {
+      return agent;
+    }
+    return {
+      ...agent,
+      version: versionKeyFromSpec(override.packageSpec),
+      distribution: {
+        ...agent.distribution,
+        npx: { ...agent.distribution.npx, package: override.packageSpec }
+      }
+    };
+  }
+  isPinned() {
+    return this.config.registry?.pinned === true;
   }
   isFresh(fetchedAt) {
     const ageMs = Date.now() - fetchedAt;
@@ -1175,6 +1274,12 @@ var Registry = class {
     });
   }
 };
+function versionKeyFromSpec(spec) {
+  const lastAt = spec.lastIndexOf("@");
+  const version = lastAt > 0 ? spec.slice(lastAt + 1) : "";
+  const sanitized = version.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return sanitized.length > 0 ? `pin-${sanitized}` : "pinned";
+}
 function npxPackageBasename(agent) {
   const pkg = agent.distribution.npx?.package;
   if (!pkg) {
@@ -1185,12 +1290,45 @@ function npxPackageBasename(agent) {
   const atIdx = afterSlash.lastIndexOf("@");
   return atIdx <= 0 ? afterSlash : afterSlash.slice(0, atIdx);
 }
+async function listAgents(registry) {
+  const local = typeof registry.localAgents === "function" ? registry.localAgents() : [];
+  let doc;
+  try {
+    doc = await registry.load();
+  } catch (err) {
+    if (local.length === 0) {
+      throw err;
+    }
+    doc = { version: "local-only", agents: [] };
+  }
+  const localIds = new Set(local.map((a) => a.id));
+  const merged = [...local, ...doc.agents.filter((a) => !localIds.has(a.id))];
+  const agents = await Promise.all(
+    merged.map(async (a) => ({
+      id: a.id,
+      name: a.name,
+      version: a.version,
+      description: a.description,
+      distributions: Object.keys(a.distribution),
+      installed: await agentInstallState(a),
+      source: localIds.has(a.id) ? "local" : "registry"
+    }))
+  );
+  return {
+    version: doc.version,
+    fetchedAt: registry.lastFetchedAt(),
+    agents
+  };
+}
 async function agentInstallState(agent) {
   const platformKey = currentPlatformKey();
   if (!platformKey) {
     return "no";
   }
   const version = agent.version ?? "current";
+  if (agent.distribution.exec) {
+    return "yes";
+  }
   if (agent.distribution.binary) {
     const target = pickBinaryTarget(agent.distribution.binary, platformKey);
     if (target?.cmd) {
@@ -1287,6 +1425,16 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
       version
     };
   }
+  if (agent.distribution.exec) {
+    const exec = agent.distribution.exec;
+    const tail = callerArgs.length > 0 ? callerArgs : exec.args ?? [];
+    return {
+      command: exec.command,
+      args: tail,
+      env: exec.env ?? {},
+      version
+    };
+  }
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
 }
 
@@ -1344,8 +1492,8 @@ var HistoryPolicy = z3.enum([
 ]);
 var SessionNewParams = z3.object({
   cwd: z3.string(),
-  agentId: z3.string().optional(),
-  mcpServers: z3.array(z3.unknown()).optional()
+  mcpServers: z3.array(z3.unknown()).optional(),
+  _meta: z3.record(z3.unknown()).optional()
 });
 var SessionResumeHints = z3.object({
   upstreamSessionId: z3.string(),
@@ -1373,23 +1521,10 @@ var SessionAttachParams = z3.object({
     name: z3.string(),
     version: z3.string().optional()
   }).optional(),
-  // When true, the connection observes the session but cannot mutate
-  // it: state-changing methods (session/prompt, session/cancel,
-  // session/set_model, etc.) are rejected with -32011, and attaching
-  // to a cold session does not resurrect or spawn an agent — just
-  // streams history from disk. Used by the TUI's view-only mode.
-  readonly: z3.boolean().optional(),
-  // Debug-only replay pacing. When "drip", the daemon skips chunk
-  // coalescing and re-emits each recorded session/update individually,
-  // spacing them by their original recordedAt deltas (scaled by
-  // dripSpeed, with a per-gap cap) so a session's streaming render can
-  // be reproduced at its real granularity for flicker investigation.
-  // Omitted/"instant" preserves the normal coalesced, as-fast-as-possible
-  // replay.
-  replayMode: z3.enum(["instant", "drip"]).optional(),
-  // Multiplier applied to original inter-entry gaps in drip mode. >1
-  // compresses time (faster), <1 stretches it. Defaults to 1.
-  dripSpeed: z3.number().positive().optional(),
+  // Hydra-specific attach options (readonly, replayMode, dripSpeed) are
+  // NOT top-level — they ride under `_meta["hydra-acp"]` (read via
+  // extractHydraMeta) so session/attach carries only RFD #533's own
+  // fields at the top level.
   _meta: z3.record(z3.unknown()).optional()
 });
 var HYDRA_META_KEY = "hydra-acp";
@@ -1412,8 +1547,23 @@ function extractHydraMeta(meta) {
   if (typeof obj.cwd === "string") {
     out.cwd = obj.cwd;
   }
-  if (typeof obj.name === "string") {
-    out.name = obj.name;
+  if (typeof obj.clientId === "string") {
+    out.clientId = obj.clientId;
+  }
+  if (typeof obj.readonly === "boolean") {
+    out.readonly = obj.readonly;
+  }
+  if (obj.replayMode === "instant" || obj.replayMode === "drip") {
+    out.replayMode = obj.replayMode;
+  }
+  if (typeof obj.dripSpeed === "number" && obj.dripSpeed > 0) {
+    out.dripSpeed = obj.dripSpeed;
+  }
+  if (obj.detachStatus === "detached") {
+    out.detachStatus = obj.detachStatus;
+  }
+  if (typeof obj.title === "string") {
+    out.title = obj.title;
   }
   if (Array.isArray(obj.agentArgs) && obj.agentArgs.every((a) => typeof a === "string")) {
     out.agentArgs = obj.agentArgs;
@@ -1465,14 +1615,22 @@ function extractHydraMeta(meta) {
       out.availableCommands = cmds;
     }
   }
-  if (typeof obj.promptQueueing === "boolean") {
-    out.promptQueueing = obj.promptQueueing;
+  if (obj.prompt && typeof obj.prompt === "object" && !Array.isArray(obj.prompt)) {
+    const p = obj.prompt;
+    const caps = {};
+    if (typeof p.queueing === "boolean") caps.queueing = p.queueing;
+    if (typeof p.cancelling === "boolean") caps.cancelling = p.cancelling;
+    if (typeof p.updating === "boolean") caps.updating = p.updating;
+    if (typeof p.amending === "boolean") caps.amending = p.amending;
+    if (typeof p.pipelining === "boolean") caps.pipelining = p.pipelining;
+    out.prompt = caps;
   }
-  if (typeof obj.promptCancelling === "boolean") {
-    out.promptCancelling = obj.promptCancelling;
-  }
-  if (typeof obj.promptUpdating === "boolean") {
-    out.promptUpdating = obj.promptUpdating;
+  if (obj.agents && typeof obj.agents === "object" && !Array.isArray(obj.agents)) {
+    const a = obj.agents;
+    const caps = {};
+    if (typeof a.list === "boolean") caps.list = a.list;
+    if (typeof a.installProgress === "boolean") caps.installProgress = a.installProgress;
+    out.agents = caps;
   }
   if (typeof obj.mcpStdin === "boolean") {
     out.mcpStdin = obj.mcpStdin;
@@ -1483,12 +1641,6 @@ function extractHydraMeta(meta) {
   if (typeof obj.ancillary === "boolean") {
     out.ancillary = obj.ancillary;
   }
-  if (typeof obj.promptAmending === "boolean") {
-    out.promptAmending = obj.promptAmending;
-  }
-  if (typeof obj.promptPipelining === "boolean") {
-    out.promptPipelining = obj.promptPipelining;
-  }
   if (Array.isArray(obj.queue)) {
     const entries = [];
     for (const raw of obj.queue) {
@@ -1561,6 +1713,43 @@ function extractHydraMeta(meta) {
       out.availableModels = models;
     }
   }
+  if (obj.status === "live" || obj.status === "cold") {
+    out.status = obj.status;
+  }
+  if (typeof obj.busy === "boolean") {
+    out.busy = obj.busy;
+  }
+  if (typeof obj.awaitingInput === "boolean") {
+    out.awaitingInput = obj.awaitingInput;
+  }
+  if (typeof obj.attachedClients === "number") {
+    out.attachedClients = obj.attachedClients;
+  }
+  if (typeof obj.importedFromMachine === "string") {
+    out.importedFromMachine = obj.importedFromMachine;
+  }
+  if (typeof obj.importedFromUpstreamSessionId === "string") {
+    out.importedFromUpstreamSessionId = obj.importedFromUpstreamSessionId;
+  }
+  if (typeof obj.parentSessionId === "string") {
+    out.parentSessionId = obj.parentSessionId;
+  }
+  if (typeof obj.forkedFromSessionId === "string") {
+    out.forkedFromSessionId = obj.forkedFromSessionId;
+  }
+  if (typeof obj.forkedFromMessageId === "string") {
+    out.forkedFromMessageId = obj.forkedFromMessageId;
+  }
+  if (obj.originatingClient && typeof obj.originatingClient === "object" && !Array.isArray(obj.originatingClient) && typeof obj.originatingClient.name === "string") {
+    const oc = obj.originatingClient;
+    out.originatingClient = {
+      name: oc.name,
+      ...typeof oc.version === "string" ? { version: oc.version } : {}
+    };
+  }
+  if (obj.agentCapabilities !== void 0) {
+    out.agentCapabilities = obj.agentCapabilities;
+  }
   return out;
 }
 function mergeMeta(passthrough, ours) {
@@ -1598,7 +1787,7 @@ var SessionListEntry = z3.object({
   importedFromUpstreamSessionId: z3.string().optional(),
   // Set when this session was spawned as a child by a transformer.
   parentSessionId: z3.string().optional(),
-  // Local-fork breadcrumbs set by hydra-acp/fork_session. Distinct from
+  // Local-fork breadcrumbs set by hydra-acp/session/fork. Distinct from
   // the imported* family above: a fork is a local branch off another
   // local session, an import is a cross-machine takeover.
   forkedFromSessionId: z3.string().optional(),
@@ -1636,36 +1825,89 @@ var SessionListResult = z3.object({
   sessions: z3.array(SessionListEntryWire),
   nextCursor: z3.string().optional()
 });
-function sessionListEntryToWire(entry) {
-  const hydraMeta = {
+function buildHydraSessionMeta(entry, extras) {
+  const meta = {
     attachedClients: entry.attachedClients,
     status: entry.status,
     busy: entry.busy,
     awaitingInput: entry.awaitingInput
   };
+  if (entry.cwd !== void 0) {
+    meta.cwd = entry.cwd;
+  }
+  if (entry.title !== void 0) {
+    meta.title = entry.title;
+  }
   if (entry.agentId !== void 0) {
-    hydraMeta.agentId = entry.agentId;
+    meta.agentId = entry.agentId;
   }
   if (entry.upstreamSessionId !== void 0) {
-    hydraMeta.upstreamSessionId = entry.upstreamSessionId;
+    meta.upstreamSessionId = entry.upstreamSessionId;
   }
   if (entry.currentModel !== void 0) {
-    hydraMeta.currentModel = entry.currentModel;
+    meta.currentModel = entry.currentModel;
   }
   if (entry.currentUsage !== void 0) {
-    hydraMeta.currentUsage = entry.currentUsage;
+    meta.currentUsage = entry.currentUsage;
   }
   if (entry.importedFromMachine !== void 0) {
-    hydraMeta.importedFromMachine = entry.importedFromMachine;
+    meta.importedFromMachine = entry.importedFromMachine;
   }
   if (entry.importedFromUpstreamSessionId !== void 0) {
-    hydraMeta.importedFromUpstreamSessionId = entry.importedFromUpstreamSessionId;
+    meta.importedFromUpstreamSessionId = entry.importedFromUpstreamSessionId;
+  }
+  if (entry.parentSessionId !== void 0) {
+    meta.parentSessionId = entry.parentSessionId;
+  }
+  if (entry.forkedFromSessionId !== void 0) {
+    meta.forkedFromSessionId = entry.forkedFromSessionId;
+  }
+  if (entry.forkedFromMessageId !== void 0) {
+    meta.forkedFromMessageId = entry.forkedFromMessageId;
+  }
+  if (entry.originatingClient !== void 0) {
+    meta.originatingClient = entry.originatingClient;
+  }
+  if (entry.interactive !== void 0) {
+    meta.interactive = entry.interactive;
+  }
+  if (extras) {
+    if (extras.clientId !== void 0) {
+      meta.clientId = extras.clientId;
+    }
+    if (extras.currentMode !== void 0) {
+      meta.currentMode = extras.currentMode;
+    }
+    if (extras.agentArgs !== void 0 && extras.agentArgs.length > 0) {
+      meta.agentArgs = extras.agentArgs;
+    }
+    if (extras.availableCommands !== void 0 && extras.availableCommands.length > 0) {
+      meta.availableCommands = extras.availableCommands;
+    }
+    if (extras.availableModes !== void 0 && extras.availableModes.length > 0) {
+      meta.availableModes = extras.availableModes;
+    }
+    if (extras.availableModels !== void 0 && extras.availableModels.length > 0) {
+      meta.availableModels = extras.availableModels;
+    }
+    if (extras.turnStartedAt !== void 0) {
+      meta.turnStartedAt = extras.turnStartedAt;
+    }
+    if (extras.agentCapabilities !== void 0) {
+      meta.agentCapabilities = extras.agentCapabilities;
+    }
+    if (extras.queue !== void 0 && extras.queue.length > 0) {
+      meta.queue = extras.queue;
+    }
   }
+  return meta;
+}
+function sessionListEntryToWire(entry) {
   const wire = {
     sessionId: entry.sessionId,
     cwd: entry.cwd,
     updatedAt: entry.updatedAt,
-    _meta: mergeMeta(entry._meta, hydraMeta)
+    _meta: mergeMeta(entry._meta, buildHydraSessionMeta(entry))
   };
   if (entry.title !== void 0) {
     wire.title = entry.title;
@@ -1753,65 +1995,6 @@ var PromptAmendedParams = z3.object({
   originator: PromptOriginatorSchema,
   amendedAt: z3.number()
 });
-var StreamOpenParams = z3.object({
-  sessionId: z3.string(),
-  // 'memory' keeps the ring in RAM only — needed for the eventual MCP
-  // tool surface. 'file' adds a temp file projection that the agent can
-  // consume with shell tools (tail -f / head / grep) when MCP isn't
-  // available. The temp file's path is returned in the response.
-  mode: z3.enum(["memory", "file"]).optional(),
-  // Ring capacity in bytes. Server clamps to a reasonable minimum and
-  // its configured max; omitted falls back to the daemon default.
-  capacityBytes: z3.number().int().positive().optional(),
-  // File mode only. Soft cap in bytes; after this many bytes are
-  // written to the file, further appends still land in the ring but
-  // stop being mirrored to disk. The daemon emits one stream_truncated
-  // session/update notification when the cap is first hit.
-  fileCapBytes: z3.number().int().positive().optional()
-});
-var StreamOpenResult = z3.object({
-  // Only present when mode === "file".
-  filePath: z3.string().optional(),
-  capacityBytes: z3.number().int().positive(),
-  fileCapBytes: z3.number().int().positive().optional()
-});
-var StreamWriteParams = z3.object({
-  sessionId: z3.string(),
-  // Base64-encoded bytes. UTF-8 stdin gets re-encoded on the wire; the
-  // ring is byte-exact so binary streams (audio, framed protocols) work
-  // identically.
-  chunk: z3.string(),
-  // True on the final write. Pending long-poll reads / waits return with
-  // eof:true once this is observed.
-  eof: z3.boolean().optional()
-});
-var StreamWriteResult = z3.object({
-  // Absolute writeCursor after this append landed.
-  writeCursor: z3.number().int().nonnegative()
-});
-var StreamReadParams = z3.object({
-  sessionId: z3.string(),
-  cursor: z3.number().int().nonnegative(),
-  // Cap on bytes returned. Server enforces a hard ceiling (STREAM_READ_MAX_BYTES,
-  // currently 64 KiB) even when the caller asks for more.
-  maxBytes: z3.number().int().positive().optional(),
-  // Long-poll timeout in ms. 0 / omitted returns immediately with
-  // whatever's available (possibly empty). Server cap 60s.
-  waitMs: z3.number().int().nonnegative().optional()
-});
-var StreamReadResult = z3.object({
-  // Base64-encoded bytes. Empty string when nothing new is available
-  // and either waitMs was 0 or the long-poll expired without data.
-  bytes: z3.string(),
-  nextCursor: z3.number().int().nonnegative(),
-  // Set when `cursor` pointed before the oldest still-resident byte —
-  // value is the count of bytes that were evicted between the caller's
-  // cursor and what we still have.
-  gap: z3.number().int().nonnegative().optional(),
-  // True when the producer has closed AND there are no more bytes
-  // after nextCursor.
-  eof: z3.boolean().optional()
-});
 var AgentInstallProgressParams = z3.object({
   agentId: z3.string(),
   version: z3.string(),
@@ -1828,7 +2011,7 @@ var AgentInstallProgressParams = z3.object({
   totalBytes: z3.number().optional(),
   packageSpec: z3.string().optional()
 });
-var AGENT_INSTALL_PROGRESS_METHOD = "hydra-acp/agent_install_progress";
+var AGENT_INSTALL_PROGRESS_METHOD = "hydra-acp/agents/install_progress";
 
 // src/acp/framing.ts
 function ndjsonStreamFromStdio(stdout, stdin) {
@@ -1931,6 +2114,13 @@ var JsonRpcConnection = class _JsonRpcConnection {
   pending = /* @__PURE__ */ new Map();
   closed = false;
   closeHandlers = [];
+  // Observers for error frames that arrive with no matching pending
+  // request — e.g. an agent replying with an error to a notification
+  // (which carries no id, so it can't be correlated the normal way).
+  // session/cancel is the canonical case: an agent that doesn't support
+  // it (current opencode) emits a MethodNotFound/UnsupportedOperation
+  // error frame we'd otherwise silently drop. See handleResponse.
+  orphanErrorHandlers = [];
   onRequest(method, handler) {
     this.requestHandlers.set(method, handler);
   }
@@ -1966,6 +2156,10 @@ var JsonRpcConnection = class _JsonRpcConnection {
   onClose(handler) {
     this.closeHandlers.push(handler);
   }
+  // Subscribe to error frames that can't be matched to a pending request.
+  onOrphanError(handler) {
+    this.orphanErrorHandlers.push(handler);
+  }
   async request(method, params) {
     return this.requestWithId(method, params).response;
   }
@@ -2022,6 +2216,8 @@ var JsonRpcConnection = class _JsonRpcConnection {
       }
     } else if ("id" in message) {
       this.handleResponse(message);
+    } else if ("error" in message) {
+      this.handleResponse(message);
     }
   }
   async handleRequest(req) {
@@ -2069,6 +2265,18 @@ var JsonRpcConnection = class _JsonRpcConnection {
   handleResponse(res) {
     const pending = this.pending.get(res.id);
     if (!pending) {
+      if (res.error) {
+        for (const handler of this.orphanErrorHandlers) {
+          try {
+            handler({
+              code: res.error.code,
+              message: res.error.message,
+              data: res.error.data
+            });
+          } catch {
+          }
+        }
+      }
       return;
     }
     this.pending.delete(res.id);
@@ -2254,7 +2462,7 @@ function openAgentLog(agentId) {
 }
 
 // src/core/session-manager.ts
-import * as fs13 from "fs/promises";
+import * as fs14 from "fs/promises";
 import * as os2 from "os";
 import * as path9 from "path";
 import { customAlphabet as customAlphabet3 } from "nanoid";
@@ -2298,8 +2506,8 @@ var SessionStreamBuffer = class {
   fileCapReached = false;
   onFileCapReached;
   logWriteError;
-  // Single-flight chain for file appends so concurrent stream_write
-  // calls don't interleave their writes.
+  // Single-flight chain for file appends so concurrent stdin writes
+  // don't interleave their file writes.
   fileWriteChain = Promise.resolve();
   constructor(opts = {}) {
     this.maxCapacityBytes = opts.capacityBytes ?? DEFAULT_CAPACITY_BYTES;
@@ -2920,7 +3128,7 @@ function stripHydraSessionPrefix(id) {
 var DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
 var TRANSFORMER_CLAIM_TIMEOUT_MS = 5 * 60 * 1e3;
 var RECENTLY_TERMINAL_LIMIT = 64;
-var Session = class {
+var Session = class _Session {
   sessionId;
   cwd;
   // agent / agentId / upstreamSessionId are mutable so /hydra agent can
@@ -2994,6 +3202,16 @@ var Session = class {
   // endpoint uses this to tail a live session's conversation stream
   // without participating in turns or prompts.
   broadcastHandlers = [];
+  // Epoch ms of the most recent session/cancel we sent to the agent.
+  // Used to attribute an id-less error frame from the agent to a cancel
+  // (see wireAgent's orphan-error observer). Window kept short so an
+  // unrelated later error isn't mislabeled.
+  lastCancelAt = 0;
+  static CANCEL_ERROR_WINDOW_MS = 2e3;
+  // Set by forceCancel() so the in-flight turn's agent-kill rejection is
+  // reported to the originator as a clean "cancelled" stopReason instead of
+  // a raw "connection closed" error.
+  forceCancelling = false;
   // True once we've observed our first session/prompt; gates the
   // first-prompt-seeded title so subsequent prompts don't churn it.
   // Also read by SessionManager's onClose hook to decide whether to
@@ -3069,6 +3287,7 @@ var Session = class {
   agentCommandsHandlers = [];
   agentModesHandlers = [];
   agentModelsHandlers = [];
+  availableAgentsFn;
   modelHandlers = [];
   modeHandlers = [];
   interactiveHandlers = [];
@@ -3141,6 +3360,7 @@ var Session = class {
     this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
     this.idleEventTimeoutMs = init.idleEventTimeoutMs ?? 3e4;
     this.spawnReplacementAgent = init.spawnReplacementAgent;
+    this.availableAgentsFn = init.availableAgents;
     this.listSessions = init.listSessions;
     this.logger = init.logger;
     this.transformChain = init.transformChain ?? [];
@@ -3218,6 +3438,11 @@ var Session = class {
     agent.connection.onRequest("session/request_permission", async (params) => {
       return this.handlePermissionRequest(params);
     });
+    if (typeof agent.connection.onOrphanError === "function") {
+      agent.connection.onOrphanError((error) => {
+        this.handleOrphanError(error);
+      });
+    }
     agent.onExit(() => {
       if (this.agent !== agent) {
         return;
@@ -3225,6 +3450,31 @@ var Session = class {
       this.markClosed({ deleteRecord: false });
     });
   }
+  // An error frame arrived from the agent that couldn't be matched to a
+  // pending request. The canonical case is a reply to our id-less
+  // session/cancel notification: agents that don't support cancellation
+  // (current opencode) answer with MethodNotFound (-32601) or an
+  // UnsupportedOperation error. If one lands within the cancel window,
+  // surface it to attached clients so the TUI can tell the user the
+  // cancel didn't take rather than silently dropping it.
+  handleOrphanError(error) {
+    const sinceCancel = Date.now() - this.lastCancelAt;
+    if (this.lastCancelAt === 0 || sinceCancel > _Session.CANCEL_ERROR_WINDOW_MS) {
+      this.logger?.warn(
+        `agent ${this.agentId} sent uncorrelated error frame code=${error.code} message=${error.message}`
+      );
+      return;
+    }
+    this.lastCancelAt = 0;
+    this.logger?.warn(
+      `agent ${this.agentId} rejected session/cancel code=${error.code} message=${error.message}`
+    );
+    this.broadcastQueueNotification("hydra-acp/cancel_failed", {
+      sessionId: this.sessionId,
+      code: error.code,
+      message: error.message
+    });
+  }
   // Runs the response-side transformer chain, then the snapshot interceptors,
   // then recordAndBroadcast. All state mutation happens after the chain exits.
   // See forwardRequest for originatedBy / startIdx semantics.
@@ -3242,7 +3492,7 @@ var Session = class {
       const token = `t_${generateChainToken()}`;
       let result;
       try {
-        result = await t.connection.request("transformer/message", {
+        result = await t.connection.request("hydra-acp/transformer/message", {
           token,
           phase: "response",
           method: "session/update",
@@ -3268,7 +3518,7 @@ var Session = class {
           const timer = setTimeout(() => {
             if (this.pendingClaims.delete(token)) {
               this.broadcastQueueNotification(
-                "hydra-acp/transformer_abandoned_request",
+                "hydra-acp/transformer/abandoned_request",
                 { sessionId: this.sessionId, token, transformerName: t.name }
               );
               void this.runResponseChain(
@@ -3315,7 +3565,10 @@ var Session = class {
       return;
     }
     if (this.maybeApplyAgentConfigOption(envelope)) {
-      this.recordAndBroadcast("session/update", envelope);
+      this.recordAndBroadcast(
+        "session/update",
+        this.mergeAgentOptionIntoEnvelope(envelope)
+      );
       return;
     }
     if (this.maybeApplyAgentUsage(rawParams)) {
@@ -3650,7 +3903,7 @@ var Session = class {
   // prompt_received a single, useful meaning ("the agent is now taking
   // a turn on this prompt"), which is how attached clients (notably
   // agent-shell) consume it. The accept-time signal that peers can use
-  // for queue chip rendering is hydra-acp/prompt_queue_added instead.
+  // for queue chip rendering is hydra-acp/prompt_queue/added instead.
   broadcastPromptReceived(entry) {
     const sentBy = { clientId: entry.originator.clientId };
     if (entry.originator.name) {
@@ -3741,7 +3994,7 @@ var Session = class {
       this.recentlyTerminal.delete(oldest);
     }
   }
-  // Fire hydra-acp/prompt_amended for the M1→M2 linkage. The amendment's
+  // Fire hydra-acp/prompt/amended for the M1→M2 linkage. The amendment's
   // current content is read live from the queue entry so any update_prompt
   // calls during the amend window are reflected. Best-effort: if M2 has
   // already been cancelled out of the queue by the time we get here, we
@@ -3761,7 +4014,7 @@ var Session = class {
       amendedAt: Date.now()
     };
     this.broadcastQueueNotification(
-      "hydra-acp/prompt_amended",
+      "hydra-acp/prompt/amended",
       params
     );
   }
@@ -3804,17 +4057,17 @@ var Session = class {
         "hydra-acp": { amending: options.amending }
       };
     }
-    this.broadcastQueueNotification("hydra-acp/prompt_queue_added", params);
+    this.broadcastQueueNotification("hydra-acp/prompt_queue/added", params);
   }
   broadcastQueueUpdated(messageId, prompt) {
-    this.broadcastQueueNotification("hydra-acp/prompt_queue_updated", {
+    this.broadcastQueueNotification("hydra-acp/prompt_queue/updated", {
       sessionId: this.sessionId,
       messageId,
       prompt
     });
   }
   broadcastQueueRemoved(messageId, reason) {
-    this.broadcastQueueNotification("hydra-acp/prompt_queue_removed", {
+    this.broadcastQueueNotification("hydra-acp/prompt_queue/removed", {
       sessionId: this.sessionId,
       messageId,
       reason
@@ -4095,6 +4348,7 @@ var Session = class {
         JsonRpcErrorCodes.SessionNotFound
       );
     }
+    this.lastCancelAt = Date.now();
     await this.agent.connection.notify("session/cancel", {
       sessionId: this.upstreamSessionId
     });
@@ -4110,7 +4364,7 @@ var Session = class {
       this.transformChain.push(ref);
     }
     if (ref.intercepts.has("lifecycle:session.opened")) {
-      void ref.connection.notify("transformer/session_event", {
+      void ref.connection.notify("hydra-acp/transformer/session_event", {
         event: "session.opened",
         sessionId: this.sessionId
       }).catch(() => void 0);
@@ -4134,7 +4388,7 @@ var Session = class {
       const token = `t_${generateChainToken()}`;
       let result;
       try {
-        result = await t.connection.request("transformer/message", {
+        result = await t.connection.request("hydra-acp/transformer/message", {
           token,
           phase: "request",
           method,
@@ -4160,7 +4414,7 @@ var Session = class {
           const timer = setTimeout(() => {
             if (this.pendingClaims.delete(token)) {
               this.broadcastQueueNotification(
-                "hydra-acp/transformer_abandoned_request",
+                "hydra-acp/transformer/abandoned_request",
                 { sessionId: this.sessionId, token, transformerName: t.name }
               );
               void this.forwardRequest(
@@ -4202,7 +4456,7 @@ var Session = class {
     claim.resolve(result);
     return true;
   }
-  // Called by the WS handler on hydra-acp/keep_alive.
+  // Called by the WS handler on hydra-acp/connection/keep_alive.
   // Resets the abandonment timer for an outstanding processing claim.
   keepAliveClaim(token, estimatedRemainingMs) {
     const claim = this.pendingClaims.get(token);
@@ -4214,7 +4468,7 @@ var Session = class {
     const timer = setTimeout(() => {
       if (this.pendingClaims.delete(token)) {
         this.broadcastQueueNotification(
-          "hydra-acp/transformer_abandoned_request",
+          "hydra-acp/transformer/abandoned_request",
           { sessionId: this.sessionId, token, transformerName: claim.transformerName }
         );
         if (claim.side === "response") {
@@ -4379,18 +4633,20 @@ var Session = class {
       } catch {
       }
     }
+    this.broadcastConfigOptions();
     return true;
   }
-  // Apply an opencode-style config_option_update. opencode emits this
-  // (not the spec-shaped current_model_update / available_models_update)
-  // to carry both the current model and the list of available models.
-  // The payload is `configOptions: [{ id: "model", currentValue, options:
-  // [{ value, name }] }, ...]`. We harvest only the entry whose id is
-  // "model" — other ids ("mode", "effort", etc.) are opencode-internal
-  // and not consumed by hydra. Returns true when we recognized and
-  // handled the notification so the wireAgent loop can stop trying
-  // further extractors (the broadcast still fires; clients that grok
-  // config_option_update render it directly).
+  // Apply an agent-emitted config_option_update. claude-acp and opencode
+  // emit this (not the spec-shaped current_model_update /
+  // available_modes_update) to carry the current value AND option list for
+  // model and mode. The payload is `configOptions: [{ id, currentValue,
+  // options: [{ value, name }] }, ...]`. We harvest the "model" and "mode"
+  // entries — other ids (e.g. "effort") are agent-internal and ignored.
+  // Harvesting the mode list here is what populates availableModes for
+  // agents that never send available_modes_update (so the TUI's Shift+Tab
+  // cycle has something to cycle through). Returns true when recognized so
+  // the wireAgent loop stops trying further extractors (the original frame
+  // still broadcasts; config-options-aware clients render it directly).
   maybeApplyAgentConfigOption(params) {
     const obj = params ?? {};
     const update = obj.update ?? {};
@@ -4406,24 +4662,37 @@ var Session = class {
         continue;
       }
       const opt = raw;
-      if (opt.id !== "model") {
-        continue;
-      }
-      const models = parseModelsList(opt.options);
-      if (models.length > 0) {
-        this.setAgentAdvertisedModels(models);
-      }
-      const cv = opt.currentValue;
-      if (typeof cv === "string") {
-        const trimmed = cv.trim();
-        if (trimmed && trimmed !== this.currentModel) {
-          this.logger?.info(
-            `live config_option_update(model): sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
-          );
-          this.applyModelChange(trimmed);
+      if (opt.id === "model") {
+        const models = parseModelsList(opt.options);
+        if (models.length > 0) {
+          this.setAgentAdvertisedModels(models);
+        }
+        const cv = opt.currentValue;
+        if (typeof cv === "string") {
+          const trimmed = cv.trim();
+          if (trimmed && trimmed !== this.currentModel) {
+            this.logger?.info(
+              `live config_option_update(model): sessionId=${this.sessionId} ${JSON.stringify(this.currentModel)} \u2192 ${JSON.stringify(trimmed)}`
+            );
+            this.applyModelChange(trimmed);
+          }
+        }
+      } else if (opt.id === "mode") {
+        const modes = parseModesList(opt.options);
+        if (modes.length > 0) {
+          this.setAgentAdvertisedModes(modes);
+        }
+        const cv = opt.currentValue;
+        if (typeof cv === "string") {
+          const trimmed = cv.trim();
+          if (trimmed && trimmed !== this.currentMode) {
+            this.logger?.info(
+              `live config_option_update(mode): sessionId=${this.sessionId} ${JSON.stringify(this.currentMode)} \u2192 ${JSON.stringify(trimmed)}`
+            );
+            this.applyModeChange(trimmed);
+          }
         }
       }
-      break;
     }
     return true;
   }
@@ -4451,6 +4720,7 @@ var Session = class {
       } catch {
       }
     }
+    this.broadcastConfigOptions();
     return true;
   }
   // usage_update carries any subset of {used, size, cost.amount,
@@ -4661,6 +4931,7 @@ var Session = class {
       sessionId: this.upstreamSessionId,
       update
     });
+    this.broadcastConfigOptions();
   }
   // Apply a mode change initiated by a client request (session/set_mode)
   // when the agent doesn't emit a current_mode_update notification on its
@@ -4697,6 +4968,115 @@ var Session = class {
       sessionId: this.upstreamSessionId,
       update
     });
+    this.broadcastConfigOptions();
+  }
+  // Assemble the spec-shaped configOptions snapshot for this session.
+  // Order reflects the agent's preferred prominence: model and mode (the
+  // dimensions users toggle constantly) first, then the hydra-native
+  // `agent` selector. model/mode are included only when hydra actually
+  // knows that dimension for the connected agent; `agent` is always
+  // present since hydra owns the swap concept regardless of the backend.
+  buildConfigOptions() {
+    const out = [];
+    if (this.agentAdvertisedModels.length > 0) {
+      const options = this.agentAdvertisedModels.map(
+        (m) => ({
+          value: m.modelId,
+          name: m.name ?? m.modelId,
+          ...m.description !== void 0 ? { description: m.description } : {}
+        })
+      );
+      const currentValue = this.currentModel && options.some((o) => o.value === this.currentModel) ? this.currentModel : options[0].value;
+      out.push({
+        id: "model",
+        name: "Model",
+        category: "model",
+        type: "select",
+        currentValue,
+        options
+      });
+    }
+    if (this.agentAdvertisedModes.length > 0) {
+      const options = this.agentAdvertisedModes.map(
+        (m) => ({
+          value: m.id,
+          name: m.name ?? m.id,
+          ...m.description !== void 0 ? { description: m.description } : {}
+        })
+      );
+      const currentValue = this.currentMode && options.some((o) => o.value === this.currentMode) ? this.currentMode : options[0].value;
+      out.push({
+        id: "mode",
+        name: "Session Mode",
+        category: "mode",
+        type: "select",
+        currentValue,
+        options
+      });
+    }
+    const agents = this.availableAgentsFn?.() ?? [];
+    const agentOptions = agents.map((a) => ({
+      value: a.id,
+      name: a.name ?? a.id,
+      ...a.description !== void 0 ? { description: a.description } : {}
+    }));
+    if (!agentOptions.some((o) => o.value === this.agentId)) {
+      agentOptions.unshift({ value: this.agentId, name: this.agentId });
+    }
+    out.push({
+      id: "agent",
+      name: "Agent",
+      category: "_hydra_agent",
+      type: "select",
+      currentValue: this.agentId,
+      options: agentOptions
+    });
+    return out;
+  }
+  // Broadcast a config_option_update carrying the full snapshot. Fired
+  // alongside the legacy current_mode_update / current_model_update and on
+  // agent swaps so config-options-aware clients stay in sync via the
+  // spec mechanism. config_option_update is a STATE_UPDATE_KIND, so this
+  // broadcasts live but is not recorded to history.
+  broadcastConfigOptions() {
+    this.recordAndBroadcast("session/update", {
+      sessionId: this.upstreamSessionId,
+      update: {
+        sessionUpdate: "config_option_update",
+        configOptions: this.buildConfigOptions()
+      }
+    });
+  }
+  // Return a shallow clone of an agent-emitted config_option_update
+  // envelope with the hydra-native `agent` option appended to its
+  // configOptions (unless the agent already advertised one). Preserves
+  // the agent's own options (mode/model/effort/…) and their order; the
+  // `agent` selector rides last, matching its lower prominence. The
+  // original envelope is not mutated.
+  mergeAgentOptionIntoEnvelope(envelope) {
+    if (!envelope || typeof envelope !== "object") {
+      return envelope;
+    }
+    const env = envelope;
+    if (!env.update || typeof env.update !== "object") {
+      return envelope;
+    }
+    const update = env.update;
+    const list = Array.isArray(update.configOptions) ? [...update.configOptions] : [];
+    const hasAgent = list.some(
+      (o) => o && typeof o === "object" && o.id === "agent"
+    );
+    if (hasAgent) {
+      return envelope;
+    }
+    const agentOption = this.buildConfigOptions().find((o) => o.id === "agent");
+    if (!agentOption) {
+      return envelope;
+    }
+    return {
+      ...env,
+      update: { ...update, configOptions: [...list, agentOption] }
+    };
   }
   onUsageChange(handler) {
     this.usageHandlers.push(handler);
@@ -4832,7 +5212,7 @@ var Session = class {
   // "/hydra <name> <verb> [args]" — name matches a registered extension
   // or transformer. We split the remainder into verb + args, validate the
   // verb against what the process advertised, and forward as a
-  // hydra-acp/extension_command request on the process's WS connection.
+  // hydra-acp/commands/invoke request on the process's WS connection.
   // The reply's text (if any) is broadcast as a synthetic
   // agent_message_chunk so it appears in the conversation alongside the
   // user's invocation.
@@ -4861,7 +5241,7 @@ var Session = class {
       }
       let reply;
       try {
-        reply = await entry.connection.request("hydra-acp/extension_command", {
+        reply = await entry.connection.request("hydra-acp/commands/invoke", {
           sessionId: this.sessionId,
           verb,
           args
@@ -5074,6 +5454,14 @@ ${body}
   // record. Spawns the new agent first so a failure leaves the old one
   // intact; then injects a synthesized transcript so the new agent has
   // context for the next turn.
+  // Public entry for swapping the underlying agent from a client request
+  // (session/set_config_option with configId "agent"), the protocol twin
+  // of the `/hydra agent` text command. Delegates to the same swap
+  // machinery so both paths share validation, transcript replay, and the
+  // config_option_update broadcast.
+  setAgent(newAgentId) {
+    return this.runAgentCommand(newAgentId);
+  }
   runAgentCommand(newAgentId) {
     if (!newAgentId) {
       throw withCode(
@@ -5112,12 +5500,10 @@ ${body}
       this.agentCapabilities = fresh.agentCapabilities;
       this.agentAdvertisedCommands = [];
       this.broadcastMergedCommands();
-      if (this.agentAdvertisedModels.length > 0) {
-        this.setAgentAdvertisedModels([]);
-      }
-      if (this.agentAdvertisedModes.length > 0) {
-        this.setAgentAdvertisedModes([]);
-      }
+      this.currentModel = fresh.initialModel;
+      this.currentMode = fresh.initialMode;
+      this.setAgentAdvertisedModels(fresh.initialModels ?? []);
+      this.setAgentAdvertisedModes(fresh.initialModes ?? []);
       await oldAgent.kill().catch(() => void 0);
       if (transcript) {
         await this.runInternalPrompt(transcript).catch(() => void 0);
@@ -5141,7 +5527,7 @@ ${body}
   // down any in-flight request as a side effect. The record is kept
   // (deleteRecord:false) so the session goes cold and can be resurrected.
   // Returns end_turn so the prompt() caller's response resolves normally,
-  // but every attached client has already received hydra-acp/session_closed
+  // but every attached client has already received hydra-acp/session/closed
   // by the time this returns.
   async runKillCommand() {
     await this.close({ deleteRecord: false });
@@ -5159,45 +5545,71 @@ ${body}
         JsonRpcErrorCodes.InternalError
       );
     }
-    const spawnAgent = this.spawnReplacementAgent;
-    const agentId = this.agentId;
     return this.enqueuePrompt(async () => {
-      const transcript = await this.buildSwitchTranscript(agentId);
-      const fresh = await spawnAgent({
-        agentId,
-        cwd: this.cwd,
-        agentArgs: this.agentArgs
-      });
-      this.accumulateAndResetCost();
-      this.wireAgent(fresh.agent);
-      const oldAgent = this.agent;
-      this.agent = fresh.agent;
-      this.upstreamSessionId = fresh.upstreamSessionId;
-      this.agentMeta = fresh.agentMeta;
-      this.agentCapabilities = fresh.agentCapabilities;
-      this.agentAdvertisedCommands = [];
-      this.broadcastMergedCommands();
-      if (this.agentAdvertisedModels.length > 0) {
-        this.setAgentAdvertisedModels([]);
-      }
-      if (this.agentAdvertisedModes.length > 0) {
-        this.setAgentAdvertisedModes([]);
-      }
-      await oldAgent.kill().catch(() => void 0);
-      if (transcript) {
-        await this.runInternalPrompt(transcript).catch(() => void 0);
-      }
-      this.broadcastAgentSwitch(agentId, agentId);
-      const info = { agentId, upstreamSessionId: this.upstreamSessionId };
-      for (const handler of this.agentChangeHandlers) {
-        try {
-          handler(info);
-        } catch {
-        }
-      }
+      await this.respawnAgent();
       return { stopReason: "end_turn" };
     });
   }
+  // Last-resort cancellation. When an agent ignores session/cancel (current
+  // opencode returns UnsupportedOperation and keeps generating), the only
+  // way to actually stop the turn is to tear the subprocess down. Rather
+  // than respawn + replay the transcript (slow, and renders as an agent
+  // "switch"), we close the session keeping its record: agent.kill() aborts
+  // the in-flight turn, and the next prompt auto-resurrects via session/load
+  // (cheap — the agent restores its own context). The forceCancelling flag
+  // makes runQueueEntry render the aborted turn as "cancelled" rather than a
+  // raw connection error. Runs OUTSIDE the prompt queue so a wedged turn
+  // can't block it.
+  async forceCancel() {
+    if (this.closed || this.closing) {
+      throw withCode(
+        new Error("session is closing"),
+        JsonRpcErrorCodes.SessionClosing
+      );
+    }
+    this.lastCancelAt = 0;
+    this.forceCancelling = true;
+    await this.close({ deleteRecord: false });
+    return { stopReason: "cancelled" };
+  }
+  // Shared kill-and-respawn used by /hydra restart (queued) and forceCancel
+  // (immediate). Spawns a fresh agent, swaps it in, kills the old one, and
+  // re-seeds the conversation transcript so the new process has context.
+  async respawnAgent() {
+    const spawnAgent = this.spawnReplacementAgent;
+    const agentId = this.agentId;
+    const transcript = await this.buildSwitchTranscript(agentId);
+    const fresh = await spawnAgent({
+      agentId,
+      cwd: this.cwd,
+      agentArgs: this.agentArgs
+    });
+    this.accumulateAndResetCost();
+    this.wireAgent(fresh.agent);
+    const oldAgent = this.agent;
+    this.agent = fresh.agent;
+    this.upstreamSessionId = fresh.upstreamSessionId;
+    this.agentMeta = fresh.agentMeta;
+    this.agentCapabilities = fresh.agentCapabilities;
+    this.agentAdvertisedCommands = [];
+    this.broadcastMergedCommands();
+    this.currentModel = fresh.initialModel;
+    this.currentMode = fresh.initialMode;
+    this.setAgentAdvertisedModels(fresh.initialModels ?? []);
+    this.setAgentAdvertisedModes(fresh.initialModes ?? []);
+    await oldAgent.kill().catch(() => void 0);
+    if (transcript) {
+      await this.runInternalPrompt(transcript).catch(() => void 0);
+    }
+    this.broadcastAgentSwitch(agentId, agentId);
+    const info = { agentId, upstreamSessionId: this.upstreamSessionId };
+    for (const handler of this.agentChangeHandlers) {
+      try {
+        handler(info);
+      } catch {
+      }
+    }
+  }
   // Walk the persisted history and produce a labeled transcript suitable
   // for handing to a fresh agent. Includes user prompts, agent replies,
   // and tool-call outcomes; skips hydra-synthesized markers (so multi-hop
@@ -5298,15 +5710,13 @@ ${body}
       return void 0;
     });
   }
-  // Tell every attached client (a) the agent identity has changed
-  // (session_info_update carrying agentId inside _meta["hydra-acp"] —
+  // Tell every attached client the agent identity has changed via
+  // session_info_update carrying agentId inside _meta["hydra-acp"] —
   // the ACP schema for session_info_update is just title/updatedAt/_meta,
   // so non-hydra clients harmlessly ignore the extension; hydra-aware
-  // ones read it and relabel) and (b) drop a visible banner into the
-  // transcript so users see the switch rather than just suddenly getting
-  // answers from a different agent. Both updates carry synthetic=true
-  // so a future /hydra agent's transcript builder filters them out.
-  broadcastAgentSwitch(oldAgentId, newAgentId) {
+  // ones read it and relabel. synthetic=true so a future /hydra agent's
+  // transcript builder filters it out.
+  broadcastAgentSwitch(_oldAgentId, newAgentId) {
     this.recordAndBroadcast("session/update", {
       sessionId: this.sessionId,
       update: {
@@ -5314,19 +5724,7 @@ ${body}
         _meta: { "hydra-acp": { synthetic: true, agentId: newAgentId } }
       }
     });
-    this.recordAndBroadcast("session/update", {
-      sessionId: this.sessionId,
-      update: {
-        sessionUpdate: "agent_message_chunk",
-        content: {
-          type: "text",
-          text: `
-_(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
-`
-        },
-        _meta: { "hydra-acp": { synthetic: true } }
-      }
-    });
+    this.broadcastConfigOptions();
   }
   // stdin-stream lifecycle. Cat --stream calls openStream() once after
   // session/new, then forwards stdin chunks via streamWrite(). The agent
@@ -5457,7 +5855,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
   requireStreamBuffer() {
     if (this.streamBuffer === void 0) {
       const err = new Error(
-        `session ${this.sessionId} has no stream buffer; call hydra-acp/stream_open first`
+        `session ${this.sessionId} has no stream buffer; POST /v1/sessions/:id/stdin/open first`
       );
       err.code = JsonRpcErrorCodes.StreamNotEnabled;
       throw err;
@@ -5500,7 +5898,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     const sessionId = this.sessionId;
     this.queueWriteChain = this.queueWriteChain.catch(() => void 0).then(() => deleteQueue(sessionId).catch(() => void 0));
     for (const client of this.clients.values()) {
-      void client.connection.notify("hydra-acp/session_closed", { sessionId: this.sessionId }).catch(() => void 0);
+      void client.connection.notify("hydra-acp/session/closed", { sessionId: this.sessionId }).catch(() => void 0);
     }
     this.clients.clear();
     if (this.streamBuffer !== void 0) {
@@ -5607,7 +6005,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       if (!t.intercepts.has(intercept)) {
         continue;
       }
-      void t.connection.notify("transformer/session_event", {
+      void t.connection.notify("hydra-acp/transformer/session_event", {
         event,
         sessionId: this.sessionId,
         payload
@@ -5887,6 +6285,10 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
       );
     } catch (err) {
+      if (this.forceCancelling) {
+        this.clearAmendIfMatches(entry.messageId);
+        return { stopReason: "cancelled" };
+      }
       if (!this.closed) {
         this.broadcastTurnComplete(
           entry.clientId,
@@ -6002,6 +6404,31 @@ function parseModelsList(list) {
   }
   return out;
 }
+function parseModesList(list) {
+  if (!Array.isArray(list)) {
+    return [];
+  }
+  const out = [];
+  for (const raw of list) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      continue;
+    }
+    const r = raw;
+    const id = typeof r.value === "string" && r.value.trim() || typeof r.id === "string" && r.id.trim() || void 0;
+    if (!id) {
+      continue;
+    }
+    const mode = { id };
+    if (typeof r.name === "string" && r.name.length > 0) {
+      mode.name = r.name;
+    }
+    if (typeof r.description === "string" && r.description.length > 0) {
+      mode.description = r.description;
+    }
+    out.push(mode);
+  }
+  return out;
+}
 function extractAdvertisedModes(params) {
   const obj = params ?? {};
   const update = obj.update ?? {};
@@ -6378,9 +6805,9 @@ var SessionRecord = z5.object({
   // memory. Cleared after that first resurrect completes.
   pendingHistorySync: z5.boolean().optional(),
   // Set when this session was spawned as a child by a transformer via
-  // hydra-acp/spawn_child_session. Points to the spawning session's id.
+  // hydra-acp/child_session/spawn. Points to the spawning session's id.
   parentSessionId: z5.string().optional(),
-  // Set when this session was created by hydra-acp/fork_session.
+  // Set when this session was created by hydra-acp/session/fork.
   // forkedFromSessionId points to the local source session; forkedFromMessageId
   // is the resolved forkAt — the messageId of the turn_complete the slice
   // ended at. Kept so future UI can show "branched from turn N of session X".
@@ -6521,20 +6948,167 @@ function recordFromMemorySession(args) {
   };
 }
 
+// src/core/tombstone-store.ts
+import * as fs9 from "fs/promises";
+import { z as z6 } from "zod";
+var Tombstone = z6.object({
+  version: z6.literal(1),
+  agentId: z6.string(),
+  upstreamSessionId: z6.string(),
+  deletedAt: z6.string(),
+  // Agent's last-reported updatedAt for this session at the moment we
+  // deleted, snapshotted from SessionRecord.updatedAt. Compared against
+  // the listing's updatedAt on subsequent syncs to detect that the
+  // conversation has moved on (the agent / user revived it), in which
+  // case the tombstone is dropped and the session re-imports. Absent
+  // when the deleted record never carried a meaningful updatedAt.
+  upstreamUpdatedAt: z6.string().optional(),
+  cwd: z6.string().optional(),
+  title: z6.string().optional(),
+  reason: z6.enum(["user", "expired"]).optional()
+});
+var TombstoneStore = class {
+  async add(t) {
+    const full = { version: 1, ...t };
+    await writeJsonAtomic(
+      paths.tombstoneFile(t.agentId, t.upstreamSessionId),
+      full,
+      { mode: 384 }
+    );
+  }
+  async has(agentId, upstreamSessionId) {
+    try {
+      await fs9.access(paths.tombstoneFile(agentId, upstreamSessionId));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // Returns the tombstone payload if the file exists. An unreadable or
+  // unparseable file still counts as a tombstone — we synthesize a
+  // bare record so the caller's "is this dead?" check stays correct,
+  // but with no upstreamUpdatedAt the resurrection rule treats any
+  // listed updatedAt as advancement (see SessionManager.syncFromAgent).
+  async read(agentId, upstreamSessionId) {
+    const file = paths.tombstoneFile(agentId, upstreamSessionId);
+    const parsed = await readJsonSafe(file);
+    if (parsed === void 0) {
+      if (await this.has(agentId, upstreamSessionId)) {
+        return {
+          version: 1,
+          agentId,
+          upstreamSessionId,
+          deletedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+        };
+      }
+      return void 0;
+    }
+    try {
+      return Tombstone.parse(parsed);
+    } catch {
+      return {
+        version: 1,
+        agentId,
+        upstreamSessionId,
+        deletedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+      };
+    }
+  }
+  async remove(agentId, upstreamSessionId) {
+    try {
+      await fs9.unlink(paths.tombstoneFile(agentId, upstreamSessionId));
+    } catch (err) {
+      const e = err;
+      if (e.code !== "ENOENT") {
+        throw err;
+      }
+    }
+    try {
+      await fs9.rmdir(paths.tombstoneAgentDir(agentId));
+    } catch (err) {
+      const e = err;
+      if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
+        throw err;
+      }
+    }
+  }
+  async list(agentId) {
+    if (agentId !== void 0) {
+      return this.listForAgent(agentId);
+    }
+    let agents;
+    try {
+      agents = await fs9.readdir(paths.tombstonesDir());
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const out = [];
+    for (const enc of agents) {
+      let decoded;
+      try {
+        decoded = decodeURIComponent(enc);
+      } catch {
+        continue;
+      }
+      out.push(...await this.listForAgent(decoded));
+    }
+    return out;
+  }
+  async listForAgent(agentId) {
+    let files;
+    try {
+      files = await fs9.readdir(paths.tombstoneAgentDir(agentId));
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const out = [];
+    for (const f of files) {
+      let upstreamId;
+      try {
+        upstreamId = decodeURIComponent(f);
+      } catch {
+        continue;
+      }
+      const t = await this.read(agentId, upstreamId);
+      if (t) {
+        out.push(t);
+      }
+    }
+    return out;
+  }
+};
+function shouldResurrectFromUpstream(tombstone, listingUpdatedAt) {
+  if (listingUpdatedAt === void 0) {
+    return false;
+  }
+  if (tombstone.upstreamUpdatedAt === void 0) {
+    return true;
+  }
+  return listingUpdatedAt > tombstone.upstreamUpdatedAt;
+}
+
 // src/core/synopsis-coordinator.ts
-import * as fs10 from "fs/promises";
+import * as fs11 from "fs/promises";
 
 // src/core/hydra-version.ts
 import { fileURLToPath } from "url";
 import * as path7 from "path";
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 function resolveVersion() {
   try {
     let dir = path7.dirname(fileURLToPath(import.meta.url));
     for (let i = 0; i < 8; i += 1) {
       const candidate = path7.join(dir, "package.json");
-      if (fs9.existsSync(candidate)) {
-        const pkg = JSON.parse(fs9.readFileSync(candidate, "utf8"));
+      if (fs10.existsSync(candidate)) {
+        const pkg = JSON.parse(fs10.readFileSync(candidate, "utf8"));
         if (typeof pkg.version === "string" && pkg.version.length > 0 && (typeof pkg.name !== "string" || pkg.name.includes("hydra-acp"))) {
           return pkg.version;
         }
@@ -7058,7 +7632,7 @@ var SynopsisCoordinator = class {
       });
       const modelId = this.opts.synopsisModel;
       const synopsisCwd = paths.sessionDir(sessionId);
-      await fs10.mkdir(synopsisCwd, { recursive: true }).catch(() => void 0);
+      await fs11.mkdir(synopsisCwd, { recursive: true }).catch(() => void 0);
       this.opts.logger?.info(
         `synopsis: start sessionId=${sessionId} agentId=${synopsisAgentId} historyLen=${history.length} model=${JSON.stringify(modelId ?? "(default)")} cwd=${synopsisCwd}`
       );
@@ -7161,7 +7735,7 @@ function describeFields(s) {
 }
 
 // src/core/history-store.ts
-import * as fs11 from "fs/promises";
+import * as fs12 from "fs/promises";
 var SESSION_ID_PATTERN2 = /^[A-Za-z0-9_-]+$/;
 var DEFAULT_MAX_ENTRIES = 1e3;
 var HistoryStore = class {
@@ -7178,9 +7752,9 @@ var HistoryStore = class {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs11.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      await fs12.mkdir(paths.sessionDir(sessionId), { recursive: true });
       const line = JSON.stringify(entry) + "\n";
-      await fs11.appendFile(paths.historyFile(sessionId), line, {
+      await fs12.appendFile(paths.historyFile(sessionId), line, {
         encoding: "utf8",
         mode: 384
       });
@@ -7191,9 +7765,9 @@ var HistoryStore = class {
       return;
     }
     return this.enqueue(sessionId, async () => {
-      await fs11.mkdir(paths.sessionDir(sessionId), { recursive: true });
+      await fs12.mkdir(paths.sessionDir(sessionId), { recursive: true });
       const body = entries.length === 0 ? "" : entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-      await fs11.writeFile(paths.historyFile(sessionId), body, {
+      await fs12.writeFile(paths.historyFile(sessionId), body, {
         encoding: "utf8",
         mode: 384
       });
@@ -7210,7 +7784,7 @@ var HistoryStore = class {
     return this.enqueue(sessionId, async () => {
       let raw;
       try {
-        raw = await fs11.readFile(paths.historyFile(sessionId), "utf8");
+        raw = await fs12.readFile(paths.historyFile(sessionId), "utf8");
       } catch (err) {
         const e = err;
         if (e.code === "ENOENT") {
@@ -7223,7 +7797,7 @@ var HistoryStore = class {
         return;
       }
       const trimmed = lines.slice(-maxEntries);
-      await fs11.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
+      await fs12.writeFile(paths.historyFile(sessionId), trimmed.join("\n") + "\n", {
         encoding: "utf8",
         mode: 384
       });
@@ -7239,7 +7813,7 @@ var HistoryStore = class {
     }
     let raw;
     try {
-      raw = await fs11.readFile(paths.historyFile(sessionId), "utf8");
+      raw = await fs12.readFile(paths.historyFile(sessionId), "utf8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -7298,7 +7872,7 @@ var HistoryStore = class {
     }
     return this.enqueue(sessionId, async () => {
       try {
-        await fs11.unlink(paths.historyFile(sessionId));
+        await fs12.unlink(paths.historyFile(sessionId));
       } catch (err) {
         const e = err;
         if (e.code !== "ENOENT") {
@@ -7306,7 +7880,7 @@ var HistoryStore = class {
         }
       }
       try {
-        await fs11.rmdir(paths.sessionDir(sessionId));
+        await fs12.rmdir(paths.sessionDir(sessionId));
       } catch (err) {
         const e = err;
         if (e.code !== "ENOENT" && e.code !== "ENOTEMPTY") {
@@ -7330,74 +7904,74 @@ var HistoryStore = class {
 };
 
 // src/tui/history.ts
-import { promises as fs12 } from "fs";
+import { promises as fs13 } from "fs";
 import * as path8 from "path";
 async function saveHistory(file, history) {
-  await fs12.mkdir(path8.dirname(file), { recursive: true });
+  await fs13.mkdir(path8.dirname(file), { recursive: true });
   const lines = history.map((entry) => JSON.stringify(entry));
-  await fs12.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
+  await fs13.writeFile(file, lines.length > 0 ? lines.join("\n") + "\n" : "");
 }
 
 // src/core/bundle.ts
-import { z as z6 } from "zod";
-var HistoryEntrySchema = z6.object({
-  method: z6.string(),
-  params: z6.unknown(),
-  recordedAt: z6.number()
+import { z as z7 } from "zod";
+var HistoryEntrySchema = z7.object({
+  method: z7.string(),
+  params: z7.unknown(),
+  recordedAt: z7.number()
 });
-var BundleSession = z6.object({
+var BundleSession = z7.object({
   // The exporter's local id. Regenerated fresh on import (sessionId is
   // the local namespace; lineageId is what survives across hops).
-  sessionId: z6.string(),
+  sessionId: z7.string(),
   // Required on bundles — the export path backfills if the source
   // record was written before lineageId existed.
-  lineageId: z6.string(),
+  lineageId: z7.string(),
   // The exporter's agent-side session id at export time. Carried so
   // importers can persist it as a breadcrumb (and, eventually, as the
   // handle a "connect back to origin" feature would need). Omitted on
   // bundles whose source record never bound to an agent (e.g. a
   // re-export of an imported, not-yet-attached session).
-  upstreamSessionId: z6.string().optional(),
-  agentId: z6.string(),
-  cwd: z6.string(),
-  title: z6.string().optional(),
+  upstreamSessionId: z7.string().optional(),
+  agentId: z7.string(),
+  cwd: z7.string(),
+  title: z7.string().optional(),
   // Structured snapshot. Carried across export/import so a sync'd
   // session on another machine surfaces the same synopsis in its
   // picker / list / info views without re-asking the agent.
   synopsis: SessionSynopsis.optional(),
-  summarizedThroughEntry: z6.number().int().nonnegative().optional(),
-  currentModel: z6.string().optional(),
-  currentMode: z6.string().optional(),
+  summarizedThroughEntry: z7.number().int().nonnegative().optional(),
+  currentModel: z7.string().optional(),
+  currentMode: z7.string().optional(),
   currentUsage: PersistedUsage.optional(),
-  agentCommands: z6.array(PersistedAgentCommand).optional(),
-  agentModes: z6.array(PersistedAgentMode).optional(),
+  agentCommands: z7.array(PersistedAgentCommand).optional(),
+  agentModes: z7.array(PersistedAgentMode).optional(),
   // Raw interactive tristate (NOT the resolved effectiveInteractive) so
   // the value stays promotable on the destination: a cat/empty source
   // arrives as undefined and a real turn there can still flip it to
   // true. Carried alongside originatingClient so the importer's
   // effectiveInteractive can re-apply the cat-name hint at read time
   // without freezing a sticky `false` into the record.
-  interactive: z6.boolean().optional(),
+  interactive: z7.boolean().optional(),
   originatingClient: PersistedOriginatingClient.optional(),
-  createdAt: z6.string(),
-  updatedAt: z6.string()
+  createdAt: z7.string(),
+  updatedAt: z7.string()
 });
-var Bundle = z6.object({
-  version: z6.literal(1),
-  exportedAt: z6.string(),
-  exportedFrom: z6.object({
-    hydraVersion: z6.string(),
-    machine: z6.string(),
+var Bundle = z7.object({
+  version: z7.literal(1),
+  exportedAt: z7.string(),
+  exportedFrom: z7.object({
+    hydraVersion: z7.string(),
+    machine: z7.string(),
     // Externally-reachable name (and optional ":port") for the exporting
     // daemon, sourced from config.daemon.publicHost (or daemon.host when
     // non-loopback). Carried so an importer can construct a hydra:// URL
     // that dials back to the origin — e.g. over Tailscale. Omitted when
     // the exporter has no routable address; never falls back to loopback.
-    hydraHost: z6.string().optional()
+    hydraHost: z7.string().optional()
   }),
   session: BundleSession,
-  history: z6.array(HistoryEntrySchema),
-  promptHistory: z6.array(z6.string()).optional()
+  history: z7.array(HistoryEntrySchema),
+  promptHistory: z7.array(z7.string()).optional()
 });
 function encodeBundle(params) {
   const bundle = {
@@ -7447,6 +8021,7 @@ var SessionManager = class {
     this.registry = registry;
     this.spawner = spawner ?? ((opts) => AgentInstance.spawn(opts));
     this.store = store ?? new SessionStore();
+    this.tombstones = options.tombstones ?? new TombstoneStore();
     this.sessionHistoryMaxEntries = options.sessionHistoryMaxEntries ?? 1e3;
     this.histories = new HistoryStore({ maxEntries: this.sessionHistoryMaxEntries });
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
@@ -7478,12 +8053,14 @@ var SessionManager = class {
       logger: this.logger,
       npmRegistry: this.npmRegistry
     });
+    void this.refreshAgentCatalog();
   }
   registry;
   sessions = /* @__PURE__ */ new Map();
   resurrectionInflight = /* @__PURE__ */ new Map();
   spawner;
   store;
+  tombstones;
   histories;
   idleTimeoutMs;
   defaultModels;
@@ -7505,6 +8082,25 @@ var SessionManager = class {
   // out-of-band so session close is instant; persists synopsis/title
   // via the same enqueueMetaWrite path the in-session handlers used.
   synopsisCoordinator;
+  // Cached agent catalog used to populate the `agent` config option's
+  // value list. Refreshed lazily (fire-and-forget) since the underlying
+  // registry load may hit the network; sessions read whatever snapshot is
+  // current and always inject their own live agent if it's missing.
+  agentCatalog = [];
+  // Refresh the cached agent catalog from the registry. Fire-and-forget;
+  // failures leave the prior snapshot in place. Called at construction and
+  // after each session creation so the list tracks newly-installed agents.
+  async refreshAgentCatalog() {
+    try {
+      const { agents } = await listAgents(this.registry);
+      this.agentCatalog = agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+        ...a.description !== void 0 ? { description: a.description } : {}
+      }));
+    } catch {
+    }
+  }
   async create(params) {
     const fresh = await this.bootstrapAgent({
       agentId: params.agentId,
@@ -7521,7 +8117,7 @@ var SessionManager = class {
           continue;
         }
         try {
-          const result = await t.connection.request("transformer/message", {
+          const result = await t.connection.request("hydra-acp/transformer/message", {
             token: `t_${generateRawSessionId()}`,
             phase: "response",
             method: "initialize",
@@ -7551,6 +8147,7 @@ var SessionManager = class {
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       listSessions: () => this.list(),
+      availableAgents: () => this.agentCatalog,
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: fresh.initialModel,
@@ -7718,6 +8315,7 @@ var SessionManager = class {
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       listSessions: () => this.list(),
+      availableAgents: () => this.agentCatalog,
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: effectiveModel,
@@ -7798,6 +8396,7 @@ var SessionManager = class {
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
       listSessions: () => this.list(),
+      availableAgents: () => this.agentCatalog,
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: effectiveModel,
@@ -7821,7 +8420,7 @@ var SessionManager = class {
   }
   async dirExists(cwd) {
     try {
-      return (await fs13.stat(cwd)).isDirectory();
+      return (await fs14.stat(cwd)).isDirectory();
     } catch {
       return false;
     }
@@ -7927,7 +8526,7 @@ var SessionManager = class {
     for (const rec of stored) {
       existing.add(`${rec.agentId}::${rec.upstreamSessionId}`);
     }
-    const hydraHomeDir = paths.home();
+    const synopsisSandboxDir = paths.sessionsDir();
     const synced = [];
     let skipped = 0;
     for (const entry of entries) {
@@ -7936,10 +8535,21 @@ var SessionManager = class {
         skipped += 1;
         continue;
       }
-      if (isUnderHydraHome(entry.cwd, hydraHomeDir)) {
+      if (isSynopsisSession(entry.cwd, synopsisSandboxDir)) {
         skipped += 1;
         continue;
       }
+      const tombstone = await this.tombstones.read(agentId, entry.sessionId).catch(() => void 0);
+      if (tombstone) {
+        if (!shouldResurrectFromUpstream(tombstone, entry.updatedAt)) {
+          skipped += 1;
+          continue;
+        }
+        await this.tombstones.remove(agentId, entry.sessionId).catch(() => void 0);
+        this.logger?.info(
+          `syncFromAgent: resurrecting tombstoned ${agentId}/${entry.sessionId} (upstream updatedAt advanced past ${tombstone.upstreamUpdatedAt ?? "<unset>"})`
+        );
+      }
       existing.add(dedupeKey);
       const newId = `${HYDRA_SESSION_PREFIX}${generateRawSessionId()}`;
       const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -8095,6 +8705,17 @@ var SessionManager = class {
     session.onClose(({ deleteRecord }) => {
       this.sessions.delete(session.sessionId);
       if (deleteRecord) {
+        if (session.upstreamSessionId) {
+          void this.tombstones.add({
+            agentId: session.agentId,
+            upstreamSessionId: session.upstreamSessionId,
+            deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            upstreamUpdatedAt: new Date(session.updatedAt).toISOString(),
+            cwd: session.cwd,
+            title: session.title,
+            reason: "user"
+          }).catch(() => void 0);
+        }
         void this.store.delete(session.sessionId).catch(() => void 0);
         void this.histories.delete(session.sessionId).catch(() => void 0);
         return;
@@ -8304,6 +8925,35 @@ var SessionManager = class {
     }
     return session;
   }
+  // Synchronous SessionListEntry for a resident session. Mirrors the
+  // live-session branch of list() but skips the async history probe:
+  // callers on the attach/new hot path already hold the Session and
+  // don't need the history-derived `interactive` inference (they pass
+  // through the session's own tristate) or the history mtime (the
+  // session's updatedAt is current). Used to build the reconciled
+  // session/new + session/attach response `_meta["hydra-acp"]` from the
+  // same shape session/list emits.
+  liveListEntry(session) {
+    return {
+      sessionId: session.sessionId,
+      upstreamSessionId: session.upstreamSessionId,
+      cwd: session.cwd,
+      title: session.title,
+      agentId: session.agentId,
+      currentModel: session.currentModel,
+      currentUsage: session.currentUsage,
+      parentSessionId: session.parentSessionId,
+      forkedFromSessionId: session.forkedFromSessionId,
+      forkedFromMessageId: session.forkedFromMessageId,
+      originatingClient: session.originatingClient,
+      interactive: session.interactive,
+      updatedAt: new Date(session.updatedAt).toISOString(),
+      attachedClients: session.attachedCount,
+      status: "live",
+      busy: session.turnStartedAt !== void 0,
+      awaitingInput: session.awaitingInput
+    };
+  }
   async list(filter = {}) {
     const entries = [];
     const liveIds = /* @__PURE__ */ new Set();
@@ -8582,7 +9232,7 @@ var SessionManager = class {
     );
     const sourceMtime = new Date(args.bundle.session.updatedAt);
     if (!Number.isNaN(sourceMtime.getTime())) {
-      await fs13.utimes(paths.historyFile(args.sessionId), sourceMtime, sourceMtime).catch(() => void 0);
+      await fs14.utimes(paths.historyFile(args.sessionId), sourceMtime, sourceMtime).catch(() => void 0);
     }
     if (args.bundle.promptHistory && args.bundle.promptHistory.length > 0) {
       await saveHistory(
@@ -8637,6 +9287,17 @@ var SessionManager = class {
     if (!record) {
       return false;
     }
+    if (record.upstreamSessionId) {
+      await this.tombstones.add({
+        agentId: record.agentId,
+        upstreamSessionId: record.upstreamSessionId,
+        deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        upstreamUpdatedAt: record.updatedAt,
+        cwd: record.cwd,
+        title: record.title,
+        reason: "user"
+      }).catch(() => void 0);
+    }
     await this.store.delete(sessionId).catch(() => void 0);
     return true;
   }
@@ -8846,13 +9507,13 @@ var SessionManager = class {
     }
   }
 };
-function isUnderHydraHome(cwd, hydraHomeDir) {
+function isSynopsisSession(cwd, sandboxDir) {
   if (typeof cwd !== "string" || cwd.length === 0) {
     return false;
   }
   const resolved = path9.resolve(cwd);
-  const home = path9.resolve(hydraHomeDir);
-  return resolved === home || resolved.startsWith(home + path9.sep);
+  const base = path9.resolve(sandboxDir);
+  return resolved === base || resolved.startsWith(base + path9.sep);
 }
 function mergeForPersistence(session, existing) {
   const persistedCommands = session.mergedAvailableCommands().length > 0 ? session.agentOnlyAdvertisedCommands().map((c) => {
@@ -8977,6 +9638,13 @@ function extractInitialModel(result) {
       }
     }
   }
+  const fromConfig = findConfigOptionEntry(result, "model");
+  if (fromConfig) {
+    const cv = asString(fromConfig.currentValue);
+    if (cv) {
+      return cv;
+    }
+  }
   return void 0;
 }
 function asString(value) {
@@ -8986,6 +9654,22 @@ function asString(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+function findConfigOptionEntry(result, id) {
+  const list = result.configOptions;
+  if (!Array.isArray(list)) {
+    return void 0;
+  }
+  for (const raw of list) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      continue;
+    }
+    const entry = raw;
+    if (entry.id === id) {
+      return entry;
+    }
+  }
+  return void 0;
+}
 function nonEmptyOrUndefined(arr) {
   return arr.length > 0 ? arr : void 0;
 }
@@ -9021,6 +9705,13 @@ function extractInitialModels(result) {
       }
     }
   }
+  const fromConfig = findConfigOptionEntry(result, "model");
+  if (fromConfig) {
+    const parsed = parseModelsList(fromConfig.options);
+    if (parsed.length > 0) {
+      return parsed;
+    }
+  }
   return [];
 }
 function extractInitialModes(result) {
@@ -9055,6 +9746,13 @@ function extractInitialModes(result) {
       }
     }
   }
+  const fromConfig = findConfigOptionEntry(result, "mode");
+  if (fromConfig) {
+    const parsed = parseModesList(fromConfig.options);
+    if (parsed.length > 0) {
+      return parsed;
+    }
+  }
   return [];
 }
 function extractInitialCurrentMode(result) {
@@ -9085,6 +9783,13 @@ function extractInitialCurrentMode(result) {
       }
     }
   }
+  const fromConfig = findConfigOptionEntry(result, "mode");
+  if (fromConfig) {
+    const cv = asString(fromConfig.currentValue);
+    if (cv) {
+      return cv;
+    }
+  }
   return void 0;
 }
 async function restoreCurrentMode(opts) {
@@ -9155,33 +9860,6 @@ async function restoreCurrentModel(opts) {
     return agentReportedModel;
   }
 }
-function parseModesList(list) {
-  if (!Array.isArray(list)) {
-    return [];
-  }
-  const out = [];
-  for (const raw of list) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-      continue;
-    }
-    const r = raw;
-    const id = asString(r.id) ?? asString(r.modeId);
-    if (!id) {
-      continue;
-    }
-    const mode = { id };
-    const name = asString(r.name);
-    if (name) {
-      mode.name = name;
-    }
-    const description = asString(r.description);
-    if (description) {
-      mode.description = description;
-    }
-    out.push(mode);
-  }
-  return out;
-}
 function findLastTurnComplete(history) {
   for (let i = history.length - 1; i >= 0; i--) {
     const entry = history[i];
@@ -9201,7 +9879,7 @@ function findLastTurnComplete(history) {
 }
 async function loadPromptHistorySafely(sessionId) {
   try {
-    const raw = await fs13.readFile(paths.tuiHistoryFile(sessionId), "utf8");
+    const raw = await fs14.readFile(paths.tuiHistoryFile(sessionId), "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       if (line.length === 0) {
@@ -9222,7 +9900,7 @@ async function loadPromptHistorySafely(sessionId) {
 }
 async function historyStatus(sessionId) {
   try {
-    const st = await fs13.stat(paths.historyFile(sessionId));
+    const st = await fs14.stat(paths.historyFile(sessionId));
     return {
       mtime: new Date(st.mtimeMs).toISOString(),
       hasContent: st.size > 0
@@ -9243,7 +9921,7 @@ function effectiveInteractive(record, hasContent) {
 
 // src/core/child-supervisor.ts
 import { spawn as spawn4 } from "child_process";
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as fsp5 from "fs/promises";
 import * as path10 from "path";
 
@@ -9616,7 +10294,7 @@ var ChildSupervisor = class {
     }
     const cfg = entry.config;
     const command = cfg.command.length > 0 ? cfg.command : [cfg.name];
-    const logStream = fs14.createWriteStream(
+    const logStream = fs15.createWriteStream(
       this.adapter.paths.logFile(cfg.name),
       { flags: "a" }
     );
@@ -9672,7 +10350,7 @@ var ChildSupervisor = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs14.writeFileSync(
+        fs15.writeFileSync(
           this.adapter.paths.pidFile(cfg.name),
           `${child.pid}
 `,
@@ -9698,7 +10376,7 @@ var ChildSupervisor = class {
     });
     child.on("exit", (code, signal) => {
       try {
-        fs14.unlinkSync(this.adapter.paths.pidFile(cfg.name));
+        fs15.unlinkSync(this.adapter.paths.pidFile(cfg.name));
       } catch {
       }
       logStream.write(
@@ -9808,13 +10486,13 @@ var TRANSFORMER_ADAPTER = {
   }
 };
 var TransformerManager = class extends ChildSupervisor {
-  // Transformers that have completed transformer/initialize and are ready to
+  // Transformers that have completed hydra-acp/transformer/initialize and are ready to
   // participate in chains. Keyed by transformer name.
   connected = /* @__PURE__ */ new Map();
   constructor(transformers, context, options = {}) {
     super(transformers, TRANSFORMER_ADAPTER, context, options);
   }
-  // Called by the WS handler after transformer/initialize completes. The
+  // Called by the WS handler after hydra-acp/transformer/initialize completes. The
   // transformer is now eligible to participate in session chains.
   registerConnection(name, connection, intercepts) {
     this.connected.set(name, {
@@ -10064,20 +10742,27 @@ var SessionTokenStore = class _SessionTokenStore {
   // keyed by hash
   writeTimer = null;
   writeInflight = null;
-  constructor(records) {
+  // Bound at construction so a debounced write that fires after the
+  // process's HYDRA_ACP_HOME has changed (e.g. between tests) targets the
+  // path this store was loaded from rather than re-resolving paths.home()
+  // and clobbering an unrelated home's token file.
+  filePath;
+  constructor(records, filePath) {
+    this.filePath = filePath;
     for (const r of records) {
       this.records.set(r.hash, r);
     }
   }
   static async load() {
     let records = [];
+    const filePath = tokensFilePath();
     const parsed = await readJsonSafe(
-      tokensFilePath()
+      filePath
     );
     if (parsed && Array.isArray(parsed.records)) {
       records = parsed.records.filter(isRecord);
     }
-    const store = new _SessionTokenStore(records);
+    const store = new _SessionTokenStore(records, filePath);
     const removed = store.sweepExpired(/* @__PURE__ */ new Date());
     if (removed > 0) {
       await store.flush();
@@ -10187,21 +10872,29 @@ var SessionTokenStore = class _SessionTokenStore {
       });
     }, WRITE_DEBOUNCE_MS);
   }
-  async persist() {
-    if (this.writeInflight) {
-      await this.writeInflight;
-    }
-    const records = Array.from(this.records.values());
-    this.writeInflight = writeJsonAtomic(
-      tokensFilePath(),
-      { records },
-      { mode: 384 }
+  // Serialize writes by chaining onto whatever write is in flight. Two
+  // concurrent persists (e.g. a debounced scheduleWrite timer firing while
+  // flush() awaits) would otherwise both write a temp file and race their
+  // renames onto the same path — the older snapshot could win. Chaining
+  // guarantees writes run one after another, each snapshotting records at
+  // the moment it actually runs, so the final on-disk state reflects the
+  // latest records. The returned promise resolves once THIS persist's
+  // write has completed.
+  persist() {
+    const run2 = (this.writeInflight ?? Promise.resolve()).catch(() => void 0).then(
+      () => writeJsonAtomic(
+        this.filePath,
+        { records: Array.from(this.records.values()) },
+        { mode: 384 }
+      )
     );
-    try {
-      await this.writeInflight;
-    } finally {
-      this.writeInflight = null;
-    }
+    this.writeInflight = run2;
+    run2.catch(() => void 0).finally(() => {
+      if (this.writeInflight === run2) {
+        this.writeInflight = null;
+      }
+    });
+    return run2;
   }
 };
 function isRecord(value) {
@@ -10363,6 +11056,7 @@ var AuthRateLimiter = class {
 
 // src/daemon/routes/sessions.ts
 import * as os3 from "os";
+import * as path13 from "path";
 
 // src/core/render-update.ts
 import stripAnsi from "strip-ansi";
@@ -10412,10 +11106,52 @@ function mapUpdate(update) {
       return mapAvailableModes(u);
     case "session_info_update":
       return mapSessionInfo(u);
+    case "config_option_update":
+      return mapConfigOptions(u);
     default:
       return { kind: "unknown", sessionUpdate: tag, raw: update };
   }
 }
+function mapConfigOptions(u) {
+  const list = u.configOptions;
+  if (!Array.isArray(list)) {
+    return null;
+  }
+  const options = [];
+  for (const raw of list) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const o = raw;
+    if (typeof o.id !== "string" || typeof o.currentValue !== "string" || !Array.isArray(o.options)) {
+      continue;
+    }
+    const values = [];
+    for (const v of o.options) {
+      if (!v || typeof v !== "object") {
+        continue;
+      }
+      const vv = v;
+      if (typeof vv.value !== "string") {
+        continue;
+      }
+      values.push({
+        value: vv.value,
+        name: typeof vv.name === "string" ? vv.name : vv.value,
+        ...typeof vv.description === "string" ? { description: vv.description } : {}
+      });
+    }
+    options.push({
+      id: o.id,
+      name: typeof o.name === "string" ? o.name : o.id,
+      type: "select",
+      currentValue: o.currentValue,
+      options: values,
+      ...typeof o.category === "string" ? { category: o.category } : {}
+    });
+  }
+  return { kind: "config-options", options };
+}
 function mapSessionInfo(u) {
   const rawTitle = readString(u, "title");
   const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
@@ -11518,6 +12254,53 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     reply.code(204).send();
   });
+  app.post("/v1/sessions/:id/stdin/open", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const session = manager.get(id);
+    if (!session) {
+      reply.code(404).send({ error: "session not found" });
+      return reply;
+    }
+    const body = request.body ?? {};
+    const openOpts = {};
+    if (body.mode === "memory" || body.mode === "file") {
+      openOpts.mode = body.mode;
+    }
+    if (typeof body.capacityBytes === "number") {
+      openOpts.capacityBytes = body.capacityBytes;
+    }
+    if (typeof body.fileCapBytes === "number") {
+      openOpts.fileCapBytes = body.fileCapBytes;
+    }
+    if ((openOpts.mode ?? "memory") === "file") {
+      openOpts.filePathFor = (sid) => path13.join(os3.tmpdir(), `hydra-acp-stdin-${sid}.log`);
+    }
+    try {
+      return session.openStream(openOpts);
+    } catch (err) {
+      reply.code(409).send({ error: err.message });
+      return reply;
+    }
+  });
+  app.post("/v1/sessions/:id/stdin", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const session = manager.get(id);
+    if (!session) {
+      reply.code(404).send({ error: "session not found" });
+      return reply;
+    }
+    const body = request.body ?? {};
+    const chunk = typeof body.chunk === "string" ? body.chunk : "";
+    const eof = body.eof === true;
+    try {
+      return session.streamWrite(chunk, eof);
+    } catch (err) {
+      reply.code(409).send({ error: err.message });
+      return reply;
+    }
+  });
   app.patch("/v1/sessions/:id", async (request, reply) => {
     const raw = request.params.id;
     const id = await manager.resolveCanonicalId(raw) ?? raw;
@@ -11754,22 +12537,7 @@ function registerSessionRoutes(app, manager, defaults) {
 // src/daemon/routes/agents.ts
 function registerAgentRoutes(app, registry, manager, opts = {}) {
   app.get("/v1/agents", async () => {
-    const doc = await registry.load();
-    const agents = await Promise.all(
-      doc.agents.map(async (a) => ({
-        id: a.id,
-        name: a.name,
-        version: a.version,
-        description: a.description,
-        distributions: Object.keys(a.distribution),
-        installed: await agentInstallState(a)
-      }))
-    );
-    return {
-      version: doc.version,
-      fetchedAt: registry.lastFetchedAt(),
-      agents
-    };
+    return listAgents(registry);
   });
   app.get("/v1/registry", async () => {
     return registry.load();
@@ -12078,22 +12846,22 @@ function registerConfigRoutes(app, snapshot) {
 }
 
 // src/daemon/routes/auth.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/core/password.ts
-import * as fs15 from "fs/promises";
-import * as path13 from "path";
+import * as fs16 from "fs/promises";
+import * as path14 from "path";
 import { randomBytes as randomBytes3, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { promisify } from "util";
 var scryptAsync = promisify(scrypt);
 function passwordHashPath() {
-  return path13.join(paths.home(), "password-hash");
+  return path14.join(paths.home(), "password-hash");
 }
 var DEFAULT_N = 1 << 15;
 var MAX_MEM = 128 * 1024 * 1024;
 async function hasPassword() {
   try {
-    const text = await fs15.readFile(passwordHashPath(), "utf8");
+    const text = await fs16.readFile(passwordHashPath(), "utf8");
     return text.trim().length > 0;
   } catch (err) {
     const e = err;
@@ -12109,7 +12877,7 @@ async function verifyPassword(plaintext) {
   }
   let line;
   try {
-    line = (await fs15.readFile(passwordHashPath(), "utf8")).trim();
+    line = (await fs16.readFile(passwordHashPath(), "utf8")).trim();
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -12145,13 +12913,13 @@ async function verifyPassword(plaintext) {
 }
 
 // src/daemon/routes/auth.ts
-var LoginBody = z7.object({
-  password: z7.string().min(1),
-  label: z7.string().min(1).max(256).optional(),
-  ttlSec: z7.number().int().positive().optional()
+var LoginBody = z8.object({
+  password: z8.string().min(1),
+  label: z8.string().min(1).max(256).optional(),
+  ttlSec: z8.number().int().positive().optional()
 });
-var LogoutBody = z7.object({
-  id: z7.string().optional()
+var LogoutBody = z8.object({
+  id: z8.string().optional()
 }).optional();
 function registerAuthRoutes(app, deps) {
   app.post(
@@ -12303,8 +13071,6 @@ function wsToMessageStream(ws) {
 }
 
 // src/daemon/acp-ws.ts
-import * as os4 from "os";
-import * as path14 from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, async (socket, request) => {
@@ -12361,7 +13127,7 @@ function registerAcpWsEndpoint(app, deps) {
     });
     if (processIdentity && deps.extensionCommands) {
       const registry = deps.extensionCommands;
-      connection.onRequest("hydra-acp/register_commands", async (raw) => {
+      connection.onRequest("hydra-acp/commands/register", async (raw) => {
         const params = raw ?? {};
         const commands = Array.isArray(params.commands) ? params.commands.map((c) => {
           if (!c || typeof c !== "object") {
@@ -12389,7 +13155,7 @@ function registerAcpWsEndpoint(app, deps) {
     }
     if (processIdentity && deps.extensionMcp) {
       const mcpRegistry = deps.extensionMcp;
-      connection.onRequest("hydra-acp/register_mcp_tools", async (raw) => {
+      connection.onRequest("hydra-acp/mcp_tools/register", async (raw) => {
         const params = raw ?? {};
         const instructions = typeof params.instructions === "string" ? params.instructions : void 0;
         const tools = Array.isArray(params.tools) ? params.tools.map((t) => {
@@ -12432,7 +13198,7 @@ function registerAcpWsEndpoint(app, deps) {
       });
     }
     if (processIdentity?.kind === "transformer") {
-      connection.onRequest("transformer/initialize", async (raw) => {
+      connection.onRequest("hydra-acp/transformer/initialize", async (raw) => {
         const params = raw ?? {};
         const intercepts = Array.isArray(params.intercepts) ? params.intercepts.filter(
           (v) => typeof v === "string"
@@ -12457,7 +13223,7 @@ function registerAcpWsEndpoint(app, deps) {
       connection.onClose(() => {
         deps.transformers?.deregisterConnection(processIdentity.name);
       });
-      connection.onRequest("hydra-acp/emit_message", async (raw) => {
+      connection.onRequest("hydra-acp/message/emit", async (raw) => {
         const params = raw ?? {};
         const sessionId = typeof params.sessionId === "string" ? params.sessionId : void 0;
         const method = typeof params.method === "string" ? params.method : void 0;
@@ -12485,7 +13251,7 @@ function registerAcpWsEndpoint(app, deps) {
         }
         throw Object.assign(new Error(`unsupported route: ${JSON.stringify(route)}`), { code: -32602 });
       });
-      connection.onRequest("hydra-acp/spawn_child_session", async (raw) => {
+      connection.onRequest("hydra-acp/child_session/spawn", async (raw) => {
         const params = raw ?? {};
         const agentId = typeof params.agentId === "string" ? params.agentId : deps.defaultAgent;
         const cwd = typeof params.cwd === "string" ? params.cwd : void 0;
@@ -12502,7 +13268,7 @@ function registerAcpWsEndpoint(app, deps) {
         });
         return { childSessionId: child.sessionId };
       });
-      connection.onRequest("hydra-acp/fork_session", async (raw) => {
+      connection.onRequest("hydra-acp/session/fork", async (raw) => {
         const params = raw ?? {};
         if (typeof params.sessionId !== "string") {
           throw Object.assign(
@@ -12519,7 +13285,30 @@ function registerAcpWsEndpoint(app, deps) {
           ...agentId !== void 0 ? { agentId } : {}
         });
       });
-      connection.onRequest("hydra-acp/await_child", async (raw) => {
+      connection.onRequest("hydra-acp/session/delete", async (raw) => {
+        const params = raw ?? {};
+        if (typeof params.sessionId !== "string") {
+          throw Object.assign(
+            new Error("hydra-acp/session/delete requires sessionId"),
+            { code: JsonRpcErrorCodes.InvalidParams }
+          );
+        }
+        const id = await deps.manager.resolveCanonicalId(params.sessionId) ?? params.sessionId;
+        const live = deps.manager.get(id);
+        if (live) {
+          await live.close({ deleteRecord: true });
+          return { deleted: true, sessionId: id };
+        }
+        const removed = await deps.manager.deleteRecord(id);
+        if (!removed) {
+          throw Object.assign(
+            new Error(`session ${id} not found`),
+            { code: JsonRpcErrorCodes.SessionNotFound }
+          );
+        }
+        return { deleted: true, sessionId: id };
+      });
+      connection.onRequest("hydra-acp/child_session/await", async (raw) => {
         const params = raw ?? {};
         const childSessionId = typeof params.childSessionId === "string" ? params.childSessionId : void 0;
         const until = params.until === "idle" ? "idle" : "turn_complete";
@@ -12558,7 +13347,7 @@ function registerAcpWsEndpoint(app, deps) {
           child.onClose(() => finish());
         });
       });
-      connection.onRequest("hydra-acp/close_child_session", async (raw) => {
+      connection.onRequest("hydra-acp/child_session/close", async (raw) => {
         const params = raw ?? {};
         const childSessionId = typeof params.childSessionId === "string" ? params.childSessionId : void 0;
         if (!childSessionId) {
@@ -12570,7 +13359,7 @@ function registerAcpWsEndpoint(app, deps) {
         }
         return { ok: true };
       });
-      connection.onRequest("hydra-acp/keep_alive", async (raw) => {
+      connection.onRequest("hydra-acp/connection/keep_alive", async (raw) => {
         const params = raw ?? {};
         const token2 = typeof params.token === "string" ? params.token : void 0;
         const sessionId = typeof params.sessionId === "string" ? params.sessionId : void 0;
@@ -12632,9 +13421,9 @@ function registerAcpWsEndpoint(app, deps) {
       try {
         session = await deps.manager.create({
           cwd: params.cwd,
-          agentId: params.agentId ?? deps.defaultAgent,
+          agentId: hydraMeta.agentId ?? deps.defaultAgent,
           mcpServers: augmentedMcpServers,
-          title: hydraMeta.name,
+          title: hydraMeta.title,
           agentArgs: hydraMeta.agentArgs,
           model: hydraMeta.model,
           onInstallProgress: makeInstallProgressForwarder(connection),
@@ -12685,14 +13474,16 @@ function registerAcpWsEndpoint(app, deps) {
       const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
-        // session/new is implicitly an attach; mirror session/attach's
-        // shape by including the clientId so deferred-echo clients
-        // (TUI's queue work) can recognize their own prompt_queue_added
-        // events without an extra round-trip.
-        clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
         ...modelsPayload ? { models: modelsPayload } : {},
-        _meta: buildResponseMeta(session)
+        configOptions: session.buildConfigOptions(),
+        // session/new is a core ACP spec method, so the per-attachment
+        // clientId rides under _meta["hydra-acp"] rather than top-level.
+        // Deferred-echo clients (TUI's queue work) read it from there to
+        // recognize their own prompt_queue_added events.
+        _meta: buildResponseMeta(deps.manager, session, {
+          clientId: client.clientId
+        })
       };
     });
     connection.onRequest("session/attach", async (raw) => {
@@ -12705,8 +13496,9 @@ function registerAcpWsEndpoint(app, deps) {
           deps.onTransformerVersion?.(processIdentity.name, attachVersion);
         }
       }
-      const hydraHints = extractHydraMeta(params._meta).resume;
-      const readonly = params.readonly === true;
+      const hydraAttach = extractHydraMeta(params._meta);
+      const hydraHints = hydraAttach.resume;
+      const readonly = hydraAttach.readonly === true;
       app.log.info(
         `session/attach sessionId=${params.sessionId} hasResumeHints=${!!hydraHints} readonly=${readonly}`
       );
@@ -12781,7 +13573,7 @@ function registerAcpWsEndpoint(app, deps) {
         params.clientInfo,
         params.clientId
       );
-      const drip = params.replayMode === "drip";
+      const drip = hydraAttach.replayMode === "drip";
       const { entries: replay, appliedPolicy } = await session.attach(
         client,
         params.historyPolicy,
@@ -12796,7 +13588,7 @@ function registerAcpWsEndpoint(app, deps) {
         `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}${drip ? " replayMode=drip" : ""}`
       );
       if (drip) {
-        const speed = params.dripSpeed && params.dripSpeed > 0 ? params.dripSpeed : 1;
+        const speed = hydraAttach.dripSpeed && hydraAttach.dripSpeed > 0 ? hydraAttach.dripSpeed : 1;
         const MAX_GAP_MS = 750;
         void (async () => {
           let prev = null;
@@ -12838,7 +13630,8 @@ function registerAcpWsEndpoint(app, deps) {
         replayed: replay.length,
         ...modesPayload ? { modes: modesPayload } : {},
         ...modelsPayload ? { models: modelsPayload } : {},
-        _meta: buildResponseMeta(session)
+        configOptions: session.buildConfigOptions(),
+        _meta: buildResponseMeta(deps.manager, session)
       };
     });
     connection.onRequest("session/detach", async (raw) => {
@@ -12855,7 +13648,10 @@ function registerAcpWsEndpoint(app, deps) {
       if (session) {
         void deps.manager.reapIfOrphanedNonInteractive(params.sessionId);
       }
-      return { sessionId: params.sessionId, status: "detached" };
+      return {
+        sessionId: params.sessionId,
+        _meta: { [HYDRA_META_KEY]: { detachStatus: "detached" } }
+      };
     });
     connection.onRequest("session/list", async (raw) => {
       const params = SessionListParams.parse(raw ?? {});
@@ -12868,6 +13664,14 @@ function registerAcpWsEndpoint(app, deps) {
       };
       return result;
     });
+    connection.onRequest("hydra-acp/agents/list", async () => {
+      if (!deps.registry) {
+        const err = new Error("agent registry unavailable");
+        err.code = JsonRpcErrorCodes.InternalError;
+        throw err;
+      }
+      return listAgents(deps.registry);
+    });
     connection.onRequest("session/prompt", async (raw) => {
       const params = SessionPromptParams.parse(raw);
       denyIfReadonly(params.sessionId, "session/prompt");
@@ -12943,9 +13747,9 @@ function registerAcpWsEndpoint(app, deps) {
       handleCancelParams(raw);
       return null;
     });
-    connection.onRequest("hydra-acp/cancel_prompt", async (raw) => {
+    connection.onRequest("hydra-acp/prompt/cancel", async (raw) => {
       const params = CancelPromptParams.parse(raw);
-      denyIfReadonly(params.sessionId, "hydra-acp/cancel_prompt");
+      denyIfReadonly(params.sessionId, "hydra-acp/prompt/cancel");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
@@ -12954,78 +13758,44 @@ function registerAcpWsEndpoint(app, deps) {
       }
       return session.cancelQueuedPrompt(params.messageId);
     });
-    connection.onRequest("hydra-acp/update_prompt", async (raw) => {
-      const params = UpdatePromptParams.parse(raw);
-      denyIfReadonly(params.sessionId, "hydra-acp/update_prompt");
-      const session = deps.manager.get(params.sessionId);
-      if (!session) {
-        const err = new Error(`session ${params.sessionId} not found`);
-        err.code = JsonRpcErrorCodes.SessionNotFound;
-        throw err;
-      }
-      return session.updateQueuedPrompt(params.messageId, params.prompt);
-    });
-    connection.onRequest("hydra-acp/amend_prompt", async (raw) => {
-      const params = AmendPromptParams.parse(raw);
-      denyIfReadonly(params.sessionId, "hydra-acp/amend_prompt");
-      const att = state.attached.get(params.sessionId);
-      if (!att) {
-        const err = new Error("not attached to session");
-        err.code = JsonRpcErrorCodes.SessionNotFound;
-        throw err;
-      }
+    connection.onRequest("hydra-acp/session/force_cancel", async (raw) => {
+      const params = SessionCancelParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/session/force_cancel");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
         err.code = JsonRpcErrorCodes.SessionNotFound;
         throw err;
       }
-      return session.amendPrompt(att.clientId, params);
+      return session.forceCancel();
     });
-    connection.onRequest("hydra-acp/stream_open", async (raw) => {
-      const params = StreamOpenParams.parse(raw);
-      denyIfReadonly(params.sessionId, "hydra-acp/stream_open");
+    connection.onRequest("hydra-acp/prompt/update", async (raw) => {
+      const params = UpdatePromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/prompt/update");
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
         err.code = JsonRpcErrorCodes.SessionNotFound;
         throw err;
       }
-      const openOpts = {};
-      if (params.mode !== void 0) {
-        openOpts.mode = params.mode;
-      }
-      if (params.capacityBytes !== void 0) {
-        openOpts.capacityBytes = params.capacityBytes;
-      }
-      if (params.fileCapBytes !== void 0) {
-        openOpts.fileCapBytes = params.fileCapBytes;
-      }
-      if ((params.mode ?? "memory") === "file") {
-        openOpts.filePathFor = (sid) => path14.join(os4.tmpdir(), `hydra-acp-stdin-${sid}.log`);
-      }
-      return session.openStream(openOpts);
+      return session.updateQueuedPrompt(params.messageId, params.prompt);
     });
-    connection.onRequest("hydra-acp/stream_write", async (raw) => {
-      const params = StreamWriteParams.parse(raw);
-      denyIfReadonly(params.sessionId, "hydra-acp/stream_write");
-      const session = deps.manager.get(params.sessionId);
-      if (!session) {
-        const err = new Error(`session ${params.sessionId} not found`);
+    connection.onRequest("hydra-acp/prompt/amend", async (raw) => {
+      const params = AmendPromptParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/prompt/amend");
+      const att = state.attached.get(params.sessionId);
+      if (!att) {
+        const err = new Error("not attached to session");
         err.code = JsonRpcErrorCodes.SessionNotFound;
         throw err;
       }
-      return session.streamWrite(params.chunk, params.eof);
-    });
-    connection.onRequest("hydra-acp/stream_read", async (raw) => {
-      const params = StreamReadParams.parse(raw);
       const session = deps.manager.get(params.sessionId);
       if (!session) {
         const err = new Error(`session ${params.sessionId} not found`);
         err.code = JsonRpcErrorCodes.SessionNotFound;
         throw err;
       }
-      return session.streamRead(params.cursor, params.maxBytes, params.waitMs);
+      return session.amendPrompt(att.clientId, params);
     });
     connection.onRequest("session/load", async (raw) => {
       const rawObj = raw ?? {};
@@ -13064,12 +13834,15 @@ function registerAcpWsEndpoint(app, deps) {
       const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
-        // Same as session/new: include clientId so the deferred-echo
-        // path in queue-aware clients can recognize own broadcasts.
-        clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
         ...modelsPayload ? { models: modelsPayload } : {},
-        _meta: buildResponseMeta(session)
+        configOptions: session.buildConfigOptions(),
+        // session/load is a core ACP spec method: clientId rides under
+        // _meta["hydra-acp"] (not top-level), same as session/new. Lets
+        // deferred-echo clients recognize their own broadcasts.
+        _meta: buildResponseMeta(deps.manager, session, {
+          clientId: client.clientId
+        })
       };
     });
     connection.onRequest("session/set_model", async (rawParams) => {
@@ -13127,6 +13900,79 @@ function registerAcpWsEndpoint(app, deps) {
       session.applyModeChange(params.modeId);
       return result;
     });
+    connection.onRequest("session/set_config_option", async (rawParams) => {
+      const params = rawParams;
+      const invalid = (msg) => {
+        const err = new Error(msg);
+        err.code = JsonRpcErrorCodes.InvalidParams;
+        return err;
+      };
+      const sessionIdField = params?.sessionId;
+      if (typeof sessionIdField === "string") {
+        denyIfReadonly(sessionIdField, "session/set_config_option");
+      }
+      if (!params || typeof params.sessionId !== "string") {
+        throw invalid("session/set_config_option requires string sessionId");
+      }
+      if (typeof params.configId !== "string") {
+        throw invalid("session/set_config_option requires string configId");
+      }
+      if (typeof params.value !== "string") {
+        throw invalid("session/set_config_option requires string value");
+      }
+      const session = deps.manager.get(params.sessionId);
+      if (!session) {
+        const err = new Error(
+          `session ${params.sessionId} not found`
+        );
+        err.code = JsonRpcErrorCodes.SessionNotFound;
+        throw err;
+      }
+      const option = session.buildConfigOptions().find((o) => o.id === params.configId);
+      if (!option) {
+        throw invalid(
+          `unknown configId ${JSON.stringify(params.configId)} for this session`
+        );
+      }
+      if (!option.options.some((v) => v.value === params.value)) {
+        throw invalid(
+          `value ${JSON.stringify(params.value)} is not valid for configId ${JSON.stringify(params.configId)}`
+        );
+      }
+      switch (params.configId) {
+        case "model": {
+          if (params.value !== session.currentModel) {
+            await session.forwardRequest("session/set_model", {
+              sessionId: params.sessionId,
+              modelId: params.value
+            });
+          }
+          session.applyModelChange(params.value);
+          break;
+        }
+        case "mode": {
+          if (params.value !== session.currentMode) {
+            await session.forwardRequest("session/set_mode", {
+              sessionId: params.sessionId,
+              modeId: params.value
+            });
+          }
+          session.applyModeChange(params.value);
+          break;
+        }
+        case "agent": {
+          if (params.value !== session.agentId) {
+            await session.setAgent(params.value);
+          }
+          break;
+        }
+        default:
+          throw invalid(
+            `configId ${JSON.stringify(params.configId)} is not settable`
+          );
+      }
+      return { configOptions: session.buildConfigOptions() };
+    });
     connection.setDefaultHandler(async (rawParams, method) => {
       if (!method.startsWith("session/") || rawParams === null || typeof rawParams !== "object") {
         const err = new Error(`Method not found: ${method}`);
@@ -13279,81 +14125,57 @@ function decideSetModel(rawParams, manager) {
   };
 }
 function buildViewerResponseMeta(fromDisk) {
-  const ours = {
+  const entry = {
+    sessionId: fromDisk.hydraSessionId,
     upstreamSessionId: fromDisk.upstreamSessionId,
+    cwd: fromDisk.cwd,
+    title: fromDisk.title,
     agentId: fromDisk.agentId,
-    cwd: fromDisk.cwd
+    currentModel: fromDisk.currentModel,
+    currentUsage: fromDisk.currentUsage,
+    forkedFromSessionId: fromDisk.forkedFromSessionId,
+    forkedFromMessageId: fromDisk.forkedFromMessageId,
+    originatingClient: fromDisk.originatingClient,
+    interactive: fromDisk.interactive,
+    updatedAt: fromDisk.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    attachedClients: 0,
+    status: "cold",
+    busy: false,
+    awaitingInput: false
   };
-  if (fromDisk.title !== void 0) {
-    ours.name = fromDisk.title;
-  }
-  if (fromDisk.agentArgs && fromDisk.agentArgs.length > 0) {
-    ours.agentArgs = fromDisk.agentArgs;
-  }
-  if (fromDisk.currentModel !== void 0) {
-    ours.currentModel = fromDisk.currentModel;
-  }
-  if (fromDisk.currentMode !== void 0) {
-    ours.currentMode = fromDisk.currentMode;
-  }
-  if (fromDisk.currentUsage !== void 0) {
-    ours.currentUsage = fromDisk.currentUsage;
-  }
-  if (fromDisk.agentCommands && fromDisk.agentCommands.length > 0) {
-    ours.availableCommands = fromDisk.agentCommands;
-  }
-  if (fromDisk.agentModes && fromDisk.agentModes.length > 0) {
-    ours.availableModes = fromDisk.agentModes;
-  }
-  if (fromDisk.agentModels && fromDisk.agentModels.length > 0) {
-    ours.availableModels = fromDisk.agentModels;
-  }
-  return { [HYDRA_META_KEY]: ours };
+  const extras = {
+    currentMode: fromDisk.currentMode,
+    agentArgs: fromDisk.agentArgs,
+    availableCommands: fromDisk.agentCommands,
+    availableModes: fromDisk.agentModes,
+    availableModels: fromDisk.agentModels
+  };
+  return { [HYDRA_META_KEY]: buildHydraSessionMeta(entry, extras) };
 }
-function buildResponseMeta(session) {
-  const ours = {
-    upstreamSessionId: session.upstreamSessionId,
-    agentId: session.agentId,
-    cwd: session.cwd
+function buildResponseMeta(manager, session, opts = {}) {
+  const entry = manager.liveListEntry(session);
+  const extras = {
+    clientId: opts.clientId,
+    currentMode: session.currentMode,
+    agentArgs: session.agentArgs,
+    availableCommands: session.mergedAvailableCommands(),
+    availableModes: session.availableModes(),
+    availableModels: session.availableModels(),
+    // Mid-turn at attach time: hand the client the original prompt's
+    // recordedAt so it can boot directly into "busy · Ns" instead of
+    // sitting on "ready" until the next live notification.
+    turnStartedAt: session.turnStartedAt,
+    // The underlying agent's own initialize-time capability claim, captured
+    // verbatim. Lets capability-aware clients (cat --stream) pick the right
+    // consumption surface without re-probing the agent.
+    agentCapabilities: session.agentCapabilities,
+    // Snapshot of the daemon-owned prompt queue. Lets a late attacher
+    // paint queue chips for entries that landed before it joined without
+    // waiting for new prompt_queue_added notifications. Omitted entirely
+    // when the queue is empty (the common case).
+    queue: session.queueSnapshot()
   };
-  if (session.title !== void 0) {
-    ours.name = session.title;
-  }
-  if (session.agentArgs && session.agentArgs.length > 0) {
-    ours.agentArgs = session.agentArgs;
-  }
-  if (session.currentModel !== void 0) {
-    ours.currentModel = session.currentModel;
-  }
-  if (session.currentMode !== void 0) {
-    ours.currentMode = session.currentMode;
-  }
-  if (session.currentUsage !== void 0) {
-    ours.currentUsage = session.currentUsage;
-  }
-  const commands = session.mergedAvailableCommands();
-  if (commands.length > 0) {
-    ours.availableCommands = commands;
-  }
-  const modes = session.availableModes();
-  if (modes.length > 0) {
-    ours.availableModes = modes;
-  }
-  const models = session.availableModels();
-  if (models.length > 0) {
-    ours.availableModels = models;
-  }
-  if (session.turnStartedAt !== void 0) {
-    ours.turnStartedAt = session.turnStartedAt;
-  }
-  if (session.agentCapabilities !== void 0) {
-    ours.agentCapabilities = session.agentCapabilities;
-  }
-  const queue = session.queueSnapshot();
-  if (queue.length > 0) {
-    ours.queue = queue;
-  }
-  return mergeMeta(session.agentMeta, ours);
+  return mergeMeta(session.agentMeta, buildHydraSessionMeta(entry, extras));
 }
 function buildInitializeResult() {
   return {
@@ -13384,18 +14206,26 @@ function buildInitializeResult() {
         description: "Bearer token presented at WS upgrade"
       }
     ],
-    // Advertise hydra-only capabilities via _meta["hydra-acp"]. Generic
-    // ACP clients ignore the field; capability-aware clients learn here
-    // which hydra-acp extensions the daemon supports so they can gate
-    // UI surface accordingly. promptPipelining is false until the
-    // streaming-input probe lands (Option A in the steering brief);
-    // the others are unconditional method-availability flags.
+    // Advertise hydra-only capabilities via _meta["hydra-acp"], grouped by
+    // resource to mirror the hydra-acp/<resource>/<action> method
+    // namespaces. Generic ACP clients ignore the field; capability-aware
+    // clients probe here to gate UI before calling a method. `pipelining`
+    // is false until the streaming-input probe lands; the rest are
+    // unconditional method-availability flags. (Named `prompt`/`agents`,
+    // not `promptCapabilities`/`agentCapabilities` — those are ACP spec
+    // names with different meanings.)
     _meta: mergeMeta(void 0, {
-      promptQueueing: true,
-      promptCancelling: true,
-      promptUpdating: true,
-      promptAmending: true,
-      promptPipelining: false
+      prompt: {
+        queueing: true,
+        cancelling: true,
+        updating: true,
+        amending: true,
+        pipelining: false
+      },
+      agents: {
+        list: true,
+        installProgress: true
+      }
     })
   };
 }
@@ -13493,7 +14323,7 @@ var McpTokenRegistry = class {
 import { randomUUID } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/daemon/mcp/bearer.ts
 var BEARER_PREFIX2 = "Bearer ";
@@ -13522,7 +14352,7 @@ function buildMcpServer(session) {
     {
       description: "Return the most recent `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means older bytes existed but have been evicted from the ring.",
       inputSchema: {
-        bytes: z8.number().int().min(1).describe("How many trailing bytes to return.")
+        bytes: z9.number().int().min(1).describe("How many trailing bytes to return.")
       }
     },
     async ({ bytes }) => {
@@ -13543,7 +14373,7 @@ function buildMcpServer(session) {
     {
       description: "Return the first `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means the head has already been evicted from the ring and the returned bytes start at the oldest still-resident cursor.",
       inputSchema: {
-        bytes: z8.number().int().min(1).describe("How many leading bytes to return.")
+        bytes: z9.number().int().min(1).describe("How many leading bytes to return.")
       }
     },
     async ({ bytes }) => {
@@ -13564,13 +14394,13 @@ function buildMcpServer(session) {
     {
       description: "Read up to `max_bytes` bytes starting at absolute byte `cursor`. Returns `{bytes, nextCursor, gap?, eof?}` \u2014 `gap` is the number of bytes silently skipped because the ring had evicted them; `eof:true` means the producer closed and there is nothing left to read.",
       inputSchema: {
-        cursor: z8.number().int().min(0).describe(
+        cursor: z9.number().int().min(0).describe(
           "Absolute byte offset to start reading from. Use 0 to read from the very beginning (may produce a gap if old bytes have been evicted)."
         ),
-        max_bytes: z8.number().int().min(1).optional().describe(
+        max_bytes: z9.number().int().min(1).optional().describe(
           "Optional cap on how many bytes to return. Server caps at 64 KiB regardless."
         ),
-        wait_ms: z8.number().int().min(0).optional().describe(
+        wait_ms: z9.number().int().min(0).optional().describe(
           "If no bytes are available, block up to this many ms for more (capped server-side at 60_000)."
         )
       }
@@ -13593,8 +14423,8 @@ function buildMcpServer(session) {
     {
       description: "Block until bytes are available past `cursor`, the stream closes, or `timeout_ms` elapses. Returns one of {data, eof, timeout} plus the current `writeCursor`. Use this when you've consumed everything up to a cursor and want to wait for more without busy-polling.",
       inputSchema: {
-        cursor: z8.number().int().min(0).describe("The cursor you've already consumed up to."),
-        timeout_ms: z8.number().int().min(0).describe("Maximum ms to block (server caps at 60_000).")
+        cursor: z9.number().int().min(0).describe("The cursor you've already consumed up to."),
+        timeout_ms: z9.number().int().min(0).describe("Maximum ms to block (server caps at 60_000).")
       }
     },
     async ({ cursor, timeout_ms }) => {
@@ -13617,17 +14447,17 @@ function buildMcpServer(session) {
     {
       description: "Scan piped stdin line-by-line and return lines matching `pattern`. Prefer this over `read` when the question is 'find lines that mention X' \u2014 it filters server-side so you don't pull and decode 64 KiB base64 windows. Returns `{matches: [{cursor, line, before?, after?}], truncated, nextCursor, gap?, scannedBytes, eof?}`. Lines come back as decoded UTF-8 strings (not base64). When `truncated:true`, re-call with `cursor: nextCursor` to resume.",
       inputSchema: {
-        pattern: z8.string().min(1).describe(
+        pattern: z9.string().min(1).describe(
           "Search pattern. Treated as a JavaScript regular expression by default (set `regex:false` for a literal substring match)."
         ),
-        regex: z8.boolean().optional().describe("Default true. Pass false to treat `pattern` as a literal substring."),
-        case_insensitive: z8.boolean().optional().describe("Default false. Pass true for case-insensitive matching."),
-        invert: z8.boolean().optional().describe("Default false. Pass true to return lines that do NOT match the pattern."),
-        max_matches: z8.number().int().min(1).optional().describe("Default 100. Capped server-side at 1000."),
-        max_bytes: z8.number().int().min(1).optional().describe("Default 64 KiB output. Capped server-side at 256 KiB."),
-        context_before: z8.number().int().min(0).optional().describe("Default 0. Number of lines before each match to include (capped at 20)."),
-        context_after: z8.number().int().min(0).optional().describe("Default 0. Number of lines after each match to include (capped at 20)."),
-        cursor: z8.number().int().min(0).optional().describe(
+        regex: z9.boolean().optional().describe("Default true. Pass false to treat `pattern` as a literal substring."),
+        case_insensitive: z9.boolean().optional().describe("Default false. Pass true for case-insensitive matching."),
+        invert: z9.boolean().optional().describe("Default false. Pass true to return lines that do NOT match the pattern."),
+        max_matches: z9.number().int().min(1).optional().describe("Default 100. Capped server-side at 1000."),
+        max_bytes: z9.number().int().min(1).optional().describe("Default 64 KiB output. Capped server-side at 256 KiB."),
+        context_before: z9.number().int().min(0).optional().describe("Default 0. Number of lines before each match to include (capped at 20)."),
+        context_after: z9.number().int().min(0).optional().describe("Default 0. Number of lines after each match to include (capped at 20)."),
+        cursor: z9.number().int().min(0).optional().describe(
           "Optional absolute byte offset to start scanning from. Omit to scan from the oldest still-resident byte. Pass the `nextCursor` from a previous truncated call to resume."
         )
       }
@@ -13884,7 +14714,7 @@ async function invokeWithTimeout(connection, server, tool, args, timeoutMs) {
   });
   try {
     return await Promise.race([
-      connection.request("hydra-acp/invoke_mcp_tool", {
+      connection.request("hydra-acp/mcp_tools/invoke", {
         server,
         tool,
         args
@@ -14161,7 +14991,8 @@ async function startDaemon(config, serviceToken) {
     extensionCommands,
     mcpTokenRegistry,
     extensionMcp,
-    getDaemonOrigin
+    getDaemonOrigin,
+    registry
   });
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();
@@ -14221,7 +15052,7 @@ async function startDaemon(config, serviceToken) {
     setAgentPruneLogger(null);
     await app.close();
     try {
-      fs16.unlinkSync(paths.pidFile());
+      fs17.unlinkSync(paths.pidFile());
     } catch {
     }
     try {