@hydra-acp/cli 0.1.44 → 0.1.46

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/daemon/server.ts
-import * as fs14 from "fs";
-import * as fsp5 from "fs/promises";
+import * as fs15 from "fs";
+import * as fsp8 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
 
@@ -86,6 +86,13 @@ var paths = {
   extensionsDir: () => path.join(hydraHome(), "extensions"),
   extensionLogFile: (name) => path.join(hydraHome(), "extensions", `${name}.log`),
   extensionPidFile: (name) => path.join(hydraHome(), "extensions", `${name}.pid`),
+  transformersDir: () => path.join(hydraHome(), "transformers"),
+  transformerLogFile: (name) => path.join(hydraHome(), "transformers", `${name}.log`),
+  transformerPidFile: (name) => path.join(hydraHome(), "transformers", `${name}.pid`),
+  // Per-session scratch directory for transformer state. Each transformer
+  // gets an isolated directory keyed by session + transformer name so
+  // multiple transformers on the same session don't collide.
+  transformerState: (sessionId, transformerName) => path.join(hydraHome(), "sessions", sessionId, "transformer-state", transformerName),
   tuiHistoryFile: (id) => path.join(hydraHome(), "sessions", id, "prompt-history"),
   // Cross-session prompt history. Up-arrow / ^R fall through to this
   // after the per-session list is exhausted. JSONL, one entry per
@@ -166,7 +173,7 @@ var DaemonConfig = z.object({
   // Compaction trims to this many on a periodic basis; reads also slice
   // to the tail at this length as a defensive measure against older
   // daemons that may have written unbounded files.
-  sessionHistoryMaxEntries: z.number().int().positive().default(1e3),
+  sessionHistoryMaxEntries: z.number().int().positive().default(1e4),
   // Bytes of trailing agent stderr buffered per AgentInstance so the
   // daemon can include it in the diagnostic message when a spawn fails.
   // Bump if your agents emit large tracebacks you want surfaced.
@@ -226,7 +233,13 @@ var TuiConfig = z.object({
   // streaming lines beneath the live thinking block. Set false to
   // suppress them — the TUI hotkey ^T toggles this at runtime without
   // persisting back to config.
-  showThoughts: z.boolean().default(true)
+  showThoughts: z.boolean().default(true),
+  // Cap on entries kept in the cross-session global prompt-history file
+  // (~/.hydra-acp/prompt-history). This is the ^P / ^R recall list
+  // shared across all sessions; it's append-only on disk, so long-lived
+  // installs can grow past this — it's enforced at load time and per
+  // append in memory.
+  promptHistoryMaxEntries: z.number().int().positive().default(2e3)
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -238,6 +251,12 @@ var ExtensionBody = z.object({
   env: z.record(z.string()).default({}),
   enabled: z.boolean().default(true)
 });
+var TransformerBody = z.object({
+  command: z.array(z.string()).default([]),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string()).default({}),
+  enabled: z.boolean().default(true)
+});
 var HydraConfig = z.object({
   daemon: DaemonConfig.default({}),
   registry: RegistryConfig.default({ url: REGISTRY_URL_DEFAULT, ttlHours: 24 }),
@@ -259,6 +278,8 @@ var HydraConfig = z.object({
   // recency and truncated to this count. `--all` overrides in the CLI.
   sessionListColdLimit: z.number().int().nonnegative().default(20),
   extensions: z.record(ExtensionName, ExtensionBody).default({}),
+  transformers: z.record(ExtensionName, TransformerBody).default({}),
+  defaultTransformers: z.array(z.string()).default([]),
   // npm registry URL used when installing npm-distributed agents into
   // ~/.hydra-acp/agents. Overrides the global ~/.npmrc registry so a
   // corporate .npmrc pointing at an internal registry doesn't break
@@ -272,7 +293,8 @@ var HydraConfig = z.object({
     cwdColumnMaxWidth: 24,
     progressIndicator: true,
     defaultEnterAction: "amend",
-    showThoughts: true
+    showThoughts: true,
+    promptHistoryMaxEntries: 2e3
   })
 });
 function extensionList(config) {
@@ -281,6 +303,12 @@ function extensionList(config) {
     ...body
   }));
 }
+function transformerList(config) {
+  return Object.entries(config.transformers).map(([name, body]) => ({
+    name,
+    ...body
+  }));
+}
 async function readConfigFile() {
   let raw;
   try {
@@ -1138,7 +1166,8 @@ var JsonRpcErrorCodes = {
   // can't collide with future spec assignments.
   BundleAlreadyImported: -32010,
   PermissionDenied: -32011,
-  AlreadyAttached: -32012
+  AlreadyAttached: -32012,
+  StreamNotEnabled: -32013
 };
 var InitializeParams = z3.object({
   protocolVersion: z3.number().optional(),
@@ -1219,6 +1248,9 @@ function extractHydraMeta(meta) {
   if (Array.isArray(obj.agentArgs) && obj.agentArgs.every((a) => typeof a === "string")) {
     out.agentArgs = obj.agentArgs;
   }
+  if (Array.isArray(obj.transformers) && obj.transformers.every((t) => typeof t === "string")) {
+    out.transformers = obj.transformers;
+  }
   if (obj.resume) {
     const parsed = SessionResumeHints.safeParse(obj.resume);
     if (parsed.success) {
@@ -1385,6 +1417,8 @@ var SessionListEntry = z3.object({
   // future "connect back to origin" callers would dial both.
   importedFromMachine: z3.string().optional(),
   importedFromUpstreamSessionId: z3.string().optional(),
+  // Set when this session was spawned as a child by a transformer.
+  parentSessionId: z3.string().optional(),
   updatedAt: z3.string(),
   attachedClients: z3.number().int().nonnegative(),
   status: z3.enum(["live", "cold"]).default("live"),
@@ -1518,6 +1552,65 @@ 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(),
@@ -1923,6 +2016,264 @@ import { customAlphabet as customAlphabet3 } from "nanoid";
 // src/core/session.ts
 import { customAlphabet } from "nanoid";
 
+// src/core/stream-buffer.ts
+import * as fsp3 from "fs/promises";
+var DEFAULT_CAPACITY_BYTES = 16 * 1024 * 1024;
+var STREAM_READ_MAX_BYTES = 64 * 1024;
+var STREAM_WAIT_MAX_MS = 6e4;
+var SessionStreamBuffer = class {
+  storage;
+  capacityBytes;
+  // Absolute monotonic byte offset of the next byte to be written. Also
+  // the count of bytes ever appended. `writeCursor - capacityBytes`
+  // (clamped at 0) is the oldest still-resident byte's cursor.
+  writeCursor = 0;
+  closed = false;
+  waiters = [];
+  filePath;
+  fileCapBytes;
+  fileBytesWritten = 0;
+  fileCapReached = false;
+  onFileCapReached;
+  logWriteError;
+  // Single-flight chain for file appends so concurrent stream_write
+  // calls don't interleave their writes.
+  fileWriteChain = Promise.resolve();
+  constructor(opts = {}) {
+    this.capacityBytes = opts.capacityBytes ?? DEFAULT_CAPACITY_BYTES;
+    if (this.capacityBytes <= 0) {
+      throw new Error("capacityBytes must be > 0");
+    }
+    this.storage = Buffer.alloc(this.capacityBytes);
+    this.filePath = opts.filePath;
+    this.fileCapBytes = opts.fileCapBytes ?? Number.POSITIVE_INFINITY;
+    this.onFileCapReached = opts.onFileCapReached;
+    this.logWriteError = opts.logWriteError;
+  }
+  get capacity() {
+    return this.capacityBytes;
+  }
+  get writeCursorPos() {
+    return this.writeCursor;
+  }
+  get oldestAvailable() {
+    return Math.max(0, this.writeCursor - this.capacityBytes);
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  // Append-or-noop. Calls after close() are silently dropped (the
+  // producer ought not to keep writing, but it's not worth throwing if
+  // a chunk arrives late).
+  append(chunk) {
+    if (this.closed || chunk.length === 0) {
+      return;
+    }
+    this.writeRing(chunk);
+    this.writeCursor += chunk.length;
+    if (this.filePath !== void 0) {
+      this.scheduleFileWrite(chunk);
+    }
+    this.wakeWaiters("data");
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.wakeWaiters("eof");
+  }
+  // Read up to `maxBytes` bytes starting at `cursor`. If `cursor` is
+  // behind the oldest still-resident byte, gap-skip to the oldest and
+  // report how many bytes were dropped. If `cursor` is at writeCursor
+  // and the buffer is closed, return eof:true.
+  read(cursor, maxBytes) {
+    const cap = Math.max(0, Math.min(maxBytes, STREAM_READ_MAX_BYTES));
+    if (cap === 0) {
+      const tail = {
+        bytes: Buffer.alloc(0),
+        nextCursor: cursor
+      };
+      if (this.closed && cursor >= this.writeCursor) {
+        tail.eof = true;
+      }
+      return tail;
+    }
+    let from = cursor;
+    let gap = 0;
+    const oldest = this.oldestAvailable;
+    if (from < oldest) {
+      gap = oldest - from;
+      from = oldest;
+    }
+    const available = this.writeCursor - from;
+    if (available <= 0) {
+      const result2 = {
+        bytes: Buffer.alloc(0),
+        nextCursor: from
+      };
+      if (gap > 0) {
+        result2.gap = gap;
+      }
+      if (this.closed) {
+        result2.eof = true;
+      }
+      return result2;
+    }
+    const take = Math.min(available, cap);
+    const bytes = this.sliceFromRing(from, take);
+    const result = {
+      bytes,
+      nextCursor: from + take
+    };
+    if (gap > 0) {
+      result.gap = gap;
+    }
+    if (this.closed && from + take >= this.writeCursor) {
+      result.eof = true;
+    }
+    return result;
+  }
+  // Latest N bytes from the tail, capped at capacity / STREAM_READ_MAX_BYTES.
+  // truncated:true when the requested span extends past the oldest
+  // still-resident byte (i.e. there was more upstream that we don't have
+  // anymore).
+  tail(bytes) {
+    const want = Math.max(0, Math.min(bytes, STREAM_READ_MAX_BYTES));
+    const oldest = this.oldestAvailable;
+    const startWant = this.writeCursor - want;
+    const start = Math.max(oldest, startWant);
+    const truncated = startWant < oldest;
+    const slice = this.sliceFromRing(start, this.writeCursor - start);
+    return {
+      bytes: slice,
+      startCursor: start,
+      endCursor: this.writeCursor,
+      truncated
+    };
+  }
+  // First N bytes since the stream began. Returns truncated:true when
+  // the head has already been evicted (cursor 0 is no longer resident).
+  head(bytes) {
+    const want = Math.max(0, Math.min(bytes, STREAM_READ_MAX_BYTES));
+    const oldest = this.oldestAvailable;
+    const truncated = oldest > 0;
+    const start = oldest;
+    const end = Math.min(this.writeCursor, start + want);
+    const slice = this.sliceFromRing(start, end - start);
+    return {
+      bytes: slice,
+      startCursor: start,
+      endCursor: end,
+      truncated
+    };
+  }
+  // Long-poll until new bytes arrive past `cursor`, the buffer closes, or
+  // the timeout expires. Resolves with "data" / "eof" / "timeout".
+  waitForData(cursor, timeoutMs) {
+    if (cursor < this.writeCursor) {
+      return Promise.resolve("data");
+    }
+    if (this.closed) {
+      return Promise.resolve("eof");
+    }
+    const cap = Math.max(0, Math.min(timeoutMs, STREAM_WAIT_MAX_MS));
+    if (cap === 0) {
+      return Promise.resolve("timeout");
+    }
+    return new Promise((resolve3) => {
+      const waiter = {
+        resolve: (outcome) => {
+          if (waiter.timer !== void 0) {
+            clearTimeout(waiter.timer);
+            waiter.timer = void 0;
+          }
+          resolve3(outcome);
+        },
+        timer: setTimeout(() => {
+          const idx = this.waiters.indexOf(waiter);
+          if (idx >= 0) {
+            this.waiters.splice(idx, 1);
+          }
+          waiter.timer = void 0;
+          resolve3("timeout");
+        }, cap)
+      };
+      this.waiters.push(waiter);
+    });
+  }
+  wakeWaiters(outcome) {
+    if (this.waiters.length === 0) {
+      return;
+    }
+    const wake = this.waiters;
+    this.waiters = [];
+    for (const w of wake) {
+      w.resolve(outcome);
+    }
+  }
+  writeRing(chunk) {
+    const len = chunk.length;
+    if (len >= this.capacityBytes) {
+      const tailStart = len - this.capacityBytes;
+      chunk.copy(this.storage, 0, tailStart, len);
+      return;
+    }
+    const offset = this.writeCursor % this.capacityBytes;
+    const tailRoom = this.capacityBytes - offset;
+    if (len <= tailRoom) {
+      chunk.copy(this.storage, offset, 0, len);
+    } else {
+      chunk.copy(this.storage, offset, 0, tailRoom);
+      chunk.copy(this.storage, 0, tailRoom, len);
+    }
+  }
+  sliceFromRing(fromCursor, length) {
+    if (length <= 0) {
+      return Buffer.alloc(0);
+    }
+    const out = Buffer.alloc(length);
+    const offset = fromCursor % this.capacityBytes;
+    const tailLen = Math.min(length, this.capacityBytes - offset);
+    this.storage.copy(out, 0, offset, offset + tailLen);
+    if (tailLen < length) {
+      this.storage.copy(out, tailLen, 0, length - tailLen);
+    }
+    return out;
+  }
+  scheduleFileWrite(chunk) {
+    const path13 = this.filePath;
+    if (path13 === void 0) {
+      return;
+    }
+    if (this.fileCapReached) {
+      return;
+    }
+    const remaining = this.fileCapBytes - this.fileBytesWritten;
+    if (remaining <= 0) {
+      this.fileCapReached = true;
+      this.onFileCapReached?.();
+      return;
+    }
+    const slice = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
+    this.fileBytesWritten += slice.length;
+    const willHitCap = this.fileBytesWritten >= this.fileCapBytes;
+    this.fileWriteChain = this.fileWriteChain.then(() => fsp3.appendFile(path13, slice)).catch((err) => {
+      this.logWriteError?.(err);
+    });
+    if (willHitCap && !this.fileCapReached) {
+      this.fileCapReached = true;
+      this.onFileCapReached?.();
+    }
+  }
+  // Wait for any pending file appends to flush. Used by tests and by
+  // session close handlers that want to ensure the file is durable
+  // before unlinking.
+  async drainFileWrites() {
+    await this.fileWriteChain.catch(() => void 0);
+  }
+};
+
 // src/core/hydra-commands.ts
 var HYDRA_COMMANDS = [
   {
@@ -1940,6 +2291,11 @@ var HYDRA_COMMANDS = [
     verb: "kill",
     name: "hydra kill",
     description: "Close this session (kills the agent; record is kept so it can be resumed later)"
+  },
+  {
+    verb: "restart",
+    name: "hydra restart",
+    description: "Restart the agent with a fresh session/new while preserving conversation history (useful when the proxy has changed available models)"
   }
 ];
 var VERB_INDEX = new Map(HYDRA_COMMANDS.map((c) => [c.verb, c]));
@@ -1992,8 +2348,10 @@ async function deleteQueue(sessionId) {
 }
 
 // src/core/session.ts
+import * as fsp4 from "fs/promises";
 var HYDRA_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var generateHydraId = customAlphabet(HYDRA_ID_ALPHABET, 16);
+var generateChainToken = customAlphabet(HYDRA_ID_ALPHABET, 16);
 var HYDRA_SESSION_PREFIX = "hydra_session_";
 function generateMessageId() {
   return `m_${generateHydraId()}`;
@@ -2002,6 +2360,7 @@ function stripHydraSessionPrefix(id) {
   return id.startsWith(HYDRA_SESSION_PREFIX) ? id.slice(HYDRA_SESSION_PREFIX.length) : id;
 }
 var DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
+var TRANSFORMER_CLAIM_TIMEOUT_MS = 5 * 60 * 1e3;
 var RECENTLY_TERMINAL_LIMIT = 64;
 var Session = class {
   sessionId;
@@ -2014,14 +2373,18 @@ var Session = class {
   agent;
   upstreamSessionId;
   agentMeta;
+  agentCapabilities;
   agentArgs;
+  parentSessionId;
   title;
   // Snapshot state delivered to attaching clients via the attach
   // response _meta rather than via history replay (which would be
   // stale-prone for snapshot-shaped events).
   currentModel;
   currentMode;
-  currentUsage;
+  // Raw per-agent-life usage. Never read directly outside this class —
+  // always access via the currentUsage getter which adds cumulativeCost.
+  _currentUsage;
   updatedAt;
   createdAt;
   clients = /* @__PURE__ */ new Map();
@@ -2076,6 +2439,10 @@ var Session = class {
   internalPromptCapture;
   idleTimeoutMs;
   idleTimer;
+  // Separate timer that fires session.idle to the transformer chain after
+  // a quiet period. Distinct from idleTimer, which drives session close.
+  idleEventTimer;
+  idleEventTimeoutMs;
   // Time of the last recordable broadcast (or session creation, if
   // none yet). Drives the inactivity-based idle close; deliberately
   // does NOT include snapshot state pings (model/mode/title/commands)
@@ -2083,7 +2450,11 @@ var Session = class {
   // and noisy state churn keep a quiet session alive forever.
   lastRecordedAt;
   spawnReplacementAgent;
+  listSessions;
   logger;
+  transformChain;
+  // Outstanding "processing" claims: token → claim waiting for respondsTo discharge.
+  pendingClaims = /* @__PURE__ */ new Map();
   agentChangeHandlers = [];
   // Last available_commands_update we observed from the agent. Stored
   // so we can re-broadcast a merged (hydra ∪ agent) list whenever
@@ -2110,6 +2481,24 @@ var Session = class {
   modelHandlers = [];
   modeHandlers = [];
   usageHandlers = [];
+  cumulativeCost = 0;
+  // Total cost across all agent lives. costAmount in the returned snapshot
+  // is cumulativeCost + the current agent's raw amount so every consumer
+  // gets the right figure without knowing about the internal split.
+  // cumulativeCost is stripped from the return value so it never leaks
+  // into persistence paths via session.currentUsage.
+  get currentUsage() {
+    if (!this._currentUsage && !this.cumulativeCost) {
+      return void 0;
+    }
+    const base = this._currentUsage ?? {};
+    const total = this.cumulativeCost + (base.costAmount ?? 0);
+    return {
+      ...base,
+      costAmount: total || void 0,
+      cumulativeCost: void 0
+    };
+  }
   // Set by amendPrompt at the start of a cancel-and-resubmit dance.
   // broadcastTurnComplete reads it to attach the _meta.amended marker
   // to the cancelled turn's turn_complete notification, and to fire the
@@ -2124,6 +2513,11 @@ var Session = class {
   // older entries fall out and resolve to target_not_found, which is
   // the correct behavior.
   recentlyTerminal = /* @__PURE__ */ new Map();
+  // Optional ring buffer for piped stdin, populated by openStream() when
+  // a cat --stream session attaches. Lifecycle follows the session — the
+  // markClosed path closes the buffer and unlinks any file projection.
+  streamBuffer;
+  streamFilePath;
   constructor(init) {
     this.sessionId = init.sessionId ?? `${HYDRA_SESSION_PREFIX}${generateHydraId()}`;
     this.cwd = init.cwd;
@@ -2131,11 +2525,14 @@ var Session = class {
     this.agent = init.agent;
     this.upstreamSessionId = init.upstreamSessionId;
     this.agentMeta = init.agentMeta;
+    this.agentCapabilities = init.agentCapabilities;
     this.agentArgs = init.agentArgs;
+    this.parentSessionId = init.parentSessionId;
     this.title = init.title;
     this.currentModel = init.currentModel;
     this.currentMode = init.currentMode;
-    this.currentUsage = init.currentUsage;
+    this._currentUsage = init.currentUsage;
+    this.cumulativeCost = init.currentUsage?.cumulativeCost ?? 0;
     if (init.agentCommands && init.agentCommands.length > 0) {
       this.agentAdvertisedCommands = [...init.agentCommands];
     }
@@ -2146,8 +2543,11 @@ var Session = class {
       this.agentAdvertisedModels = [...init.agentModels];
     }
     this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
+    this.idleEventTimeoutMs = init.idleEventTimeoutMs ?? 3e4;
     this.spawnReplacementAgent = init.spawnReplacementAgent;
+    this.listSessions = init.listSessions;
     this.logger = init.logger;
+    this.transformChain = init.transformChain ?? [];
     if (init.firstPromptSeeded) {
       this.firstPromptSeeded = true;
     }
@@ -2159,10 +2559,14 @@ var Session = class {
     this.lastRecordedAt = this.updatedAt;
     this.wireAgent(this.agent);
     this.scheduleIdleCheck();
+    this.notifyChain("session.opened", {});
   }
   broadcastMergedCommands() {
     const merged = [
       ...hydraCommandsAsAdvertised(),
+      { name: "model <model-id>", description: "Switch model; omit arg to list available models" },
+      { name: "sessions", description: "List all sessions" },
+      { name: "help", description: "Show available commands" },
       ...this.agentAdvertisedCommands
     ];
     this.recordAndBroadcast("session/update", {
@@ -2211,34 +2615,7 @@ var Session = class {
         captureInternalChunk(this.internalPromptCapture, params);
         return;
       }
-      const agentCmds = extractAdvertisedCommands(params);
-      if (agentCmds !== null) {
-        this.setAgentAdvertisedCommands(agentCmds);
-        return;
-      }
-      const agentModes = extractAdvertisedModes(params);
-      if (agentModes !== null) {
-        this.setAgentAdvertisedModes(agentModes);
-        return;
-      }
-      if (this.maybeApplyAgentModel(params)) {
-        this.recordAndBroadcast("session/update", params);
-        return;
-      }
-      if (this.maybeApplyAgentMode(params)) {
-        this.recordAndBroadcast("session/update", params);
-        return;
-      }
-      if (this.maybeApplyAgentConfigOption(params)) {
-        this.recordAndBroadcast("session/update", params);
-        return;
-      }
-      if (this.maybeApplyAgentUsage(params)) {
-        this.recordAndBroadcast("session/update", params);
-        return;
-      }
-      this.maybeApplyAgentSessionInfo(params);
-      this.recordAndBroadcast("session/update", params);
+      void this.runResponseChain(params);
     });
     agent.connection.onRequest("session/request_permission", async (params) => {
       return this.handlePermissionRequest(params);
@@ -2250,6 +2627,106 @@ var Session = class {
       this.markClosed({ deleteRecord: false });
     });
   }
+  // 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.
+  async runResponseChain(params, originatedBy = /* @__PURE__ */ new Set(), startIdx = 0) {
+    const rawParams = params;
+    let envelope = this.injectCumulativeCost(params);
+    for (let i = startIdx; i < this.transformChain.length; i++) {
+      const t = this.transformChain[i];
+      if (originatedBy.has(t.name)) {
+        continue;
+      }
+      if (!t.intercepts.has("response:session/update")) {
+        continue;
+      }
+      const token = `t_${generateChainToken()}`;
+      let result;
+      try {
+        result = await t.connection.request("transformer/message", {
+          token,
+          phase: "response",
+          method: "session/update",
+          direction: "agent\u2192client",
+          sessionId: this.sessionId,
+          envelope
+        });
+      } catch (err) {
+        this.logger?.warn(
+          `transformer ${t.name} error on response:session/update: ${err.message}`
+        );
+        continue;
+      }
+      const action = result?.action ?? "continue";
+      if (action === "stop") {
+        return;
+      }
+      if (action === "processing") {
+        const claimIdx = i;
+        const claimEnvelope = envelope;
+        const claimOriginatedBy = new Set(originatedBy);
+        await new Promise((resolve3) => {
+          const timer = setTimeout(() => {
+            if (this.pendingClaims.delete(token)) {
+              this.broadcastQueueNotification(
+                "hydra-acp/transformer_abandoned_request",
+                { sessionId: this.sessionId, token, transformerName: t.name }
+              );
+              void this.runResponseChain(
+                claimEnvelope,
+                /* @__PURE__ */ new Set([...claimOriginatedBy, t.name]),
+                claimIdx + 1
+              ).then(resolve3);
+            }
+          }, TRANSFORMER_CLAIM_TIMEOUT_MS);
+          if (typeof timer.unref === "function") {
+            timer.unref();
+          }
+          this.pendingClaims.set(token, {
+            resolve: () => resolve3(),
+            timer,
+            transformerName: t.name,
+            method: "session/update",
+            envelope: claimEnvelope,
+            chainIdx: claimIdx,
+            originatedBy: claimOriginatedBy,
+            side: "response"
+          });
+        });
+        return;
+      }
+      originatedBy.add(t.name);
+    }
+    const agentCmds = extractAdvertisedCommands(envelope);
+    if (agentCmds !== null) {
+      this.setAgentAdvertisedCommands(agentCmds);
+      return;
+    }
+    const agentModes = extractAdvertisedModes(envelope);
+    if (agentModes !== null) {
+      this.setAgentAdvertisedModes(agentModes);
+      return;
+    }
+    if (this.maybeApplyAgentModel(envelope)) {
+      this.recordAndBroadcast("session/update", envelope);
+      return;
+    }
+    if (this.maybeApplyAgentMode(envelope)) {
+      this.recordAndBroadcast("session/update", envelope);
+      return;
+    }
+    if (this.maybeApplyAgentConfigOption(envelope)) {
+      this.recordAndBroadcast("session/update", envelope);
+      return;
+    }
+    if (this.maybeApplyAgentUsage(rawParams)) {
+      this.recordAndBroadcast("session/update", envelope);
+      return;
+    }
+    this.maybeApplyAgentSessionInfo(envelope);
+    this.recordAndBroadcast("session/update", envelope);
+  }
   onAgentChange(handler) {
     this.agentChangeHandlers.push(handler);
   }
@@ -2990,8 +3467,159 @@ var Session = class {
       sessionId: this.upstreamSessionId
     });
   }
-  async forwardRequest(method, params) {
-    return this.agent.connection.request(method, this.rewriteForAgent(params));
+  // Add a transformer to this session's chain retroactively. No-ops if it's
+  // already present. Fires session.opened on the new transformer so it gets
+  // the same lifecycle signal it would have received at session creation.
+  addTransformer(ref) {
+    const existing = this.transformChain.findIndex((t) => t.name === ref.name);
+    if (existing >= 0) {
+      this.transformChain[existing] = ref;
+    } else {
+      this.transformChain.push(ref);
+    }
+    if (ref.intercepts.has("lifecycle:session.opened")) {
+      void ref.connection.notify("transformer/session_event", {
+        event: "session.opened",
+        sessionId: this.sessionId
+      }).catch(() => void 0);
+    }
+  }
+  // Walk the request-side chain then forward to the agent.
+  // originatedBy: transformer names already in the lineage — skipped for loop
+  //   prevention and to implement resume-routing on re-entry from emit_message.
+  // startIdx: chain position to start from (0 for normal, emitterIdx+1 for re-entry).
+  async forwardRequest(method, params, originatedBy = /* @__PURE__ */ new Set(), startIdx = 0) {
+    let envelope = this.rewriteForAgent(params);
+    for (let i = startIdx; i < this.transformChain.length; i++) {
+      const t = this.transformChain[i];
+      if (originatedBy.has(t.name)) {
+        continue;
+      }
+      const intercept = `request:${method}`;
+      if (!t.intercepts.has(intercept)) {
+        continue;
+      }
+      const token = `t_${generateChainToken()}`;
+      let result;
+      try {
+        result = await t.connection.request("transformer/message", {
+          token,
+          phase: "request",
+          method,
+          direction: "client\u2192agent",
+          sessionId: this.sessionId,
+          envelope
+        });
+      } catch (err) {
+        this.logger?.warn(
+          `transformer ${t.name} error on ${intercept}: ${err.message}`
+        );
+        continue;
+      }
+      const action = result?.action ?? "continue";
+      if (action === "stop") {
+        return result?.payload ?? defaultStopPayload(method);
+      }
+      if (action === "processing") {
+        const claimIdx = i;
+        const claimEnvelope = envelope;
+        const claimOriginatedBy = new Set(originatedBy);
+        return new Promise((resolve3) => {
+          const timer = setTimeout(() => {
+            if (this.pendingClaims.delete(token)) {
+              this.broadcastQueueNotification(
+                "hydra-acp/transformer_abandoned_request",
+                { sessionId: this.sessionId, token, transformerName: t.name }
+              );
+              void this.forwardRequest(
+                method,
+                claimEnvelope,
+                /* @__PURE__ */ new Set([...claimOriginatedBy, t.name]),
+                claimIdx + 1
+              ).then(resolve3).catch(() => resolve3(defaultStopPayload(method)));
+            }
+          }, TRANSFORMER_CLAIM_TIMEOUT_MS);
+          if (typeof timer.unref === "function") {
+            timer.unref();
+          }
+          this.pendingClaims.set(token, {
+            resolve: resolve3,
+            timer,
+            transformerName: t.name,
+            method,
+            envelope: claimEnvelope,
+            chainIdx: claimIdx,
+            originatedBy: claimOriginatedBy,
+            side: "request"
+          });
+        });
+      }
+      originatedBy.add(t.name);
+    }
+    return this.agent.connection.request(method, envelope);
+  }
+  // Called by the WS handler when emit_message carries respondsTo.
+  // Discharges the outstanding claim so the original requester unblocks.
+  dischargeClaim(token, result) {
+    const claim = this.pendingClaims.get(token);
+    if (!claim) {
+      return false;
+    }
+    clearTimeout(claim.timer);
+    this.pendingClaims.delete(token);
+    claim.resolve(result);
+    return true;
+  }
+  // Called by the WS handler on hydra-acp/keep_alive.
+  // Resets the abandonment timer for an outstanding processing claim.
+  keepAliveClaim(token, estimatedRemainingMs) {
+    const claim = this.pendingClaims.get(token);
+    if (!claim) {
+      return false;
+    }
+    clearTimeout(claim.timer);
+    const timeout = typeof estimatedRemainingMs === "number" && estimatedRemainingMs > 0 ? Math.min(estimatedRemainingMs * 1.5, 30 * 60 * 1e3) : TRANSFORMER_CLAIM_TIMEOUT_MS;
+    const timer = setTimeout(() => {
+      if (this.pendingClaims.delete(token)) {
+        this.broadcastQueueNotification(
+          "hydra-acp/transformer_abandoned_request",
+          { sessionId: this.sessionId, token, transformerName: claim.transformerName }
+        );
+        if (claim.side === "response") {
+          void this.runResponseChain(
+            claim.envelope,
+            /* @__PURE__ */ new Set([...claim.originatedBy, claim.transformerName]),
+            claim.chainIdx + 1
+          ).then(() => claim.resolve(void 0));
+        } else {
+          void this.forwardRequest(
+            claim.method,
+            claim.envelope,
+            /* @__PURE__ */ new Set([...claim.originatedBy, claim.transformerName]),
+            claim.chainIdx + 1
+          ).then(claim.resolve).catch(() => claim.resolve(defaultStopPayload(claim.method)));
+        }
+      }
+    }, timeout);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    claim.timer = timer;
+    return true;
+  }
+  // Called by the WS handler when a transformer emits via route:"chain".
+  // Finds the emitter's position and re-enters the appropriate chain walk
+  // from the next slot, with the emitter in originatedBy so it cannot see
+  // its own re-emission.
+  async emitToChain(emitterName, method, envelope) {
+    const emitterIdx = this.transformChain.findIndex((t) => t.name === emitterName);
+    const startIdx = emitterIdx >= 0 ? emitterIdx + 1 : 0;
+    const originatedBy = /* @__PURE__ */ new Set([emitterName]);
+    if (method === "session/update") {
+      await this.runResponseChain(envelope, originatedBy, startIdx);
+      return;
+    }
+    await this.forwardRequest(method, envelope, originatedBy, startIdx);
   }
   rewriteForAgent(params) {
     if (params && typeof params === "object" && !Array.isArray(params)) {
@@ -3180,6 +3808,9 @@ var Session = class {
     if (!trimmed || trimmed === this.currentMode) {
       return true;
     }
+    this.logger?.info(
+      `current_mode_update: sessionId=${this.sessionId} ${JSON.stringify(this.currentMode)} \u2192 ${JSON.stringify(trimmed)}`
+    );
     this.currentMode = trimmed;
     for (const handler of this.modeHandlers) {
       try {
@@ -3199,7 +3830,7 @@ var Session = class {
     if (update.sessionUpdate !== "usage_update") {
       return false;
     }
-    const next = { ...this.currentUsage ?? {} };
+    const next = { ...this._currentUsage ?? {} };
     let changed = false;
     if (typeof update.used === "number" && next.used !== update.used) {
       next.used = update.used;
@@ -3223,15 +3854,68 @@ var Session = class {
     if (!changed) {
       return true;
     }
-    this.currentUsage = next;
+    this._currentUsage = next;
+    const total = this.currentUsage ?? next;
     for (const handler of this.usageHandlers) {
       try {
-        handler(next);
+        handler(total);
       } catch {
       }
     }
     return true;
   }
+  // Move currentUsage.costAmount into cumulativeCost and clear it so the
+  // next agent life starts accumulating from $0. Fires usageHandlers so
+  // meta.json is updated before the new agent starts emitting.
+  accumulateAndResetCost() {
+    const amount = this._currentUsage?.costAmount;
+    if (!amount)
+      return;
+    this.cumulativeCost += amount;
+    const next = {
+      ...this._currentUsage ?? {},
+      cumulativeCost: this.cumulativeCost,
+      costAmount: void 0
+    };
+    this._currentUsage = next;
+    for (const handler of this.usageHandlers) {
+      try {
+        handler(next);
+      } catch {
+      }
+    }
+  }
+  // Returns a modified envelope with cost.amount replaced by the running
+  // total (cumulativeCost + raw agent amount). No-op if the envelope
+  // doesn't carry a numeric cost.amount.
+  injectCumulativeCost(envelope) {
+    if (!this.cumulativeCost)
+      return envelope;
+    if (!envelope || typeof envelope !== "object")
+      return envelope;
+    const obj = envelope;
+    if (!obj.update || typeof obj.update !== "object")
+      return envelope;
+    const update = obj.update;
+    if (update.sessionUpdate !== "usage_update")
+      return envelope;
+    if (!update.cost || typeof update.cost !== "object")
+      return envelope;
+    const cost = update.cost;
+    if (typeof cost.amount !== "number")
+      return envelope;
+    return {
+      ...obj,
+      update: {
+        ...update,
+        cost: { ...cost, amount: this.cumulativeCost + cost.amount }
+      }
+    };
+  }
+  // Deprecated alias — currentUsage already returns the total.
+  get totalUsage() {
+    return this.currentUsage;
+  }
   // Update the cached agent command list, fire persist handlers, and
   // broadcast the merged list to attached clients. Idempotent on a
   // structurally identical list so we don't churn meta.json on noisy
@@ -3296,6 +3980,26 @@ var Session = class {
   onModeChange(handler) {
     this.modeHandlers.push(handler);
   }
+  // 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
+  // own. Fires modeHandlers so the persistence hook and any other listeners
+  // see the change, identical to the agent-notification path.
+  applyModeChange(modeId) {
+    const trimmed = modeId.trim();
+    if (!trimmed || trimmed === this.currentMode) {
+      return;
+    }
+    this.logger?.info(
+      `applyModeChange: sessionId=${this.sessionId} ${JSON.stringify(this.currentMode)} \u2192 ${JSON.stringify(trimmed)}`
+    );
+    this.currentMode = trimmed;
+    for (const handler of this.modeHandlers) {
+      try {
+        handler(trimmed);
+      } catch {
+      }
+    }
+  }
   onUsageChange(handler) {
     this.usageHandlers.push(handler);
   }
@@ -3378,6 +4082,8 @@ var Session = class {
         return this.runAgentCommand(arg);
       case "kill":
         return this.runKillCommand();
+      case "restart":
+        return this.runRestartCommand();
       default: {
         const err = new Error(
           `no dispatcher for /hydra verb ${verb}`
@@ -3387,6 +4093,92 @@ var Session = class {
       }
     }
   }
+  async handleSessionsCommand() {
+    let text;
+    if (!this.listSessions) {
+      text = "_(session listing not available)_";
+    } else {
+      const sessions = await this.listSessions();
+      if (sessions.length === 0) {
+        text = "_(no sessions)_";
+      } else {
+        const lines = sessions.map((s) => {
+          const id = s.sessionId.replace(/^hydra_session_/, "").slice(0, 12);
+          const model = s.currentModel ? ` \xB7 ${s.currentModel}` : "";
+          const marker = s.sessionId === this.sessionId ? " \u25C0" : "";
+          const title = s.title ? `  ${s.title}` : "";
+          return `\`${id}\`  ${s.cwd}${model}${marker}${title}`;
+        });
+        text = `Sessions (${sessions.length}):
+${lines.join("\n")}`;
+      }
+    }
+    this.recordAndBroadcast("session/update", {
+      sessionId: this.upstreamSessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: `
+${text}
+` },
+        _meta: { "hydra-acp": { synthetic: true } }
+      }
+    });
+    return { stopReason: "end_turn" };
+  }
+  handleHelpCommand() {
+    const commands = this.mergedAvailableCommands();
+    const lines = commands.map((c) => {
+      const desc = c.description ? `  ${c.description}` : "";
+      return `\`/${c.name}\`${desc}`;
+    });
+    const text = lines.length > 0 ? `Available commands:
+${lines.join("\n")}` : "_(no commands advertised)_";
+    this.recordAndBroadcast("session/update", {
+      sessionId: this.upstreamSessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: `
+${text}
+` },
+        _meta: { "hydra-acp": { synthetic: true } }
+      }
+    });
+    return Promise.resolve({ stopReason: "end_turn" });
+  }
+  async handleModelCommand(text) {
+    const arg = text.slice("/model".length).trim();
+    if (arg === "") {
+      const models = this.agentAdvertisedModels;
+      const current = this.currentModel;
+      let body;
+      if (models.length === 0) {
+        body = current ? `Current model: ${current}` : "_(no models advertised yet)_";
+      } else {
+        const lines = models.map((m) => {
+          const marker = m.modelId === current ? " \u25C0" : "";
+          const desc = m.name && m.name !== m.modelId ? `  ${m.name}` : "";
+          return `${m.modelId}${marker}${desc}`;
+        });
+        body = lines.join("\n");
+      }
+      this.recordAndBroadcast("session/update", {
+        sessionId: this.upstreamSessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: `
+${body}
+` },
+          _meta: { "hydra-acp": { synthetic: true } }
+        }
+      });
+      return { stopReason: "end_turn" };
+    }
+    await this.forwardRequest("session/set_model", {
+      sessionId: this.sessionId,
+      modelId: arg
+    });
+    return { stopReason: "end_turn" };
+  }
   // Runs as a normal queued prompt (so it serializes after any in-flight
   // turn). With an arg, sets the title directly. Without one, runs a
   // suppressed sub-prompt to the agent and uses its reply as the title.
@@ -3463,12 +4255,14 @@ var Session = class {
         cwd: this.cwd,
         agentArgs: this.agentArgs
       });
+      this.accumulateAndResetCost();
       this.wireAgent(fresh.agent);
       const oldAgent = this.agent;
       this.agent = fresh.agent;
       this.agentId = newAgentId;
       this.upstreamSessionId = fresh.upstreamSessionId;
       this.agentMeta = fresh.agentMeta;
+      this.agentCapabilities = fresh.agentCapabilities;
       this.agentAdvertisedCommands = [];
       this.broadcastMergedCommands();
       if (this.agentAdvertisedModels.length > 0) {
@@ -3506,21 +4300,72 @@ var Session = class {
     await this.close({ deleteRecord: false });
     return { stopReason: "end_turn" };
   }
-  // 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
-  // switches don't accumulate banners) and other update kinds we don't
-  // think the next agent benefits from re-seeing (plans, thoughts,
-  // mode/model/usage).
-  //
-  // The header text defaults to the agent-swap framing; callers like
-  // seedFromImport pass a custom header when the new agent is taking
-  // over an imported session rather than swapping mid-conversation.
-  async buildSwitchTranscript(prevAgentId, headerOverride) {
-    const lines = [];
-    const history = await this.getHistorySnapshot();
-    for (const note of history) {
-      if (note.method !== "session/update") {
+  // Restart the underlying agent with a fresh session/new, preserving the
+  // conversation history. Unlike /hydra agent, this allows the same agentId
+  // — useful when the proxy has changed available models (e.g. opus became
+  // available after a quota reset) and the resumed session is locked to a
+  // stale model list.
+  runRestartCommand() {
+    if (!this.spawnReplacementAgent) {
+      throw withCode(
+        new Error("agent restart not configured for this session"),
+        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 {
+        }
+      }
+      return { stopReason: "end_turn" };
+    });
+  }
+  // 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
+  // switches don't accumulate banners) and other update kinds we don't
+  // think the next agent benefits from re-seeing (plans, thoughts,
+  // mode/model/usage).
+  //
+  // The header text defaults to the agent-swap framing; callers like
+  // seedFromImport pass a custom header when the new agent is taking
+  // over an imported session rather than swapping mid-conversation.
+  async buildSwitchTranscript(prevAgentId, headerOverride) {
+    const lines = [];
+    const history = await this.getHistorySnapshot();
+    for (const note of history) {
+      if (note.method !== "session/update") {
         continue;
       }
       const params = note.params ?? {};
@@ -3636,12 +4481,120 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       }
     });
   }
+  // stdin-stream lifecycle. Cat --stream calls openStream() once after
+  // session/new, then forwards stdin chunks via streamWrite(). The agent
+  // either consumes via the file path (when shell tools are available)
+  // or — once the MCP surface lands — via tool calls that route through
+  // streamRead() / streamTail() / streamHead() / streamWaitFor().
+  hasStreamBuffer() {
+    return this.streamBuffer !== void 0;
+  }
+  get streamPath() {
+    return this.streamFilePath;
+  }
+  openStream(opts) {
+    if (this.streamBuffer !== void 0) {
+      throw new Error(
+        `stream buffer already open for session ${this.sessionId}`
+      );
+    }
+    const mode = opts.mode ?? "memory";
+    const filePath = mode === "file" && opts.filePathFor !== void 0 ? opts.filePathFor(this.sessionId) : void 0;
+    const bufferOpts = {};
+    if (opts.capacityBytes !== void 0) {
+      bufferOpts.capacityBytes = opts.capacityBytes;
+    }
+    if (filePath !== void 0) {
+      bufferOpts.filePath = filePath;
+    }
+    if (opts.fileCapBytes !== void 0) {
+      bufferOpts.fileCapBytes = opts.fileCapBytes;
+    }
+    bufferOpts.onFileCapReached = () => {
+      this.recordAndBroadcast("session/update", {
+        sessionId: this.upstreamSessionId,
+        update: {
+          sessionUpdate: "stream_truncated",
+          ...filePath !== void 0 ? { filePath } : {},
+          fileCapBytes: opts.fileCapBytes
+        }
+      });
+    };
+    const buf = new SessionStreamBuffer(bufferOpts);
+    this.streamBuffer = buf;
+    this.streamFilePath = filePath;
+    const result = {
+      capacityBytes: buf.capacity
+    };
+    if (filePath !== void 0) {
+      result.filePath = filePath;
+    }
+    if (opts.fileCapBytes !== void 0) {
+      result.fileCapBytes = opts.fileCapBytes;
+    }
+    return result;
+  }
+  streamWrite(chunkB64, eof) {
+    const buf = this.requireStreamBuffer();
+    if (chunkB64.length > 0) {
+      const chunk = Buffer.from(chunkB64, "base64");
+      buf.append(chunk);
+    }
+    if (eof === true) {
+      buf.close();
+    }
+    return { writeCursor: buf.writeCursorPos };
+  }
+  async streamRead(cursor, maxBytes, waitMs) {
+    const buf = this.requireStreamBuffer();
+    const cap = Math.max(
+      0,
+      Math.min(maxBytes ?? STREAM_READ_MAX_BYTES, STREAM_READ_MAX_BYTES)
+    );
+    let r = buf.read(cursor, cap);
+    if (r.bytes.length === 0 && r.eof !== true && waitMs !== void 0 && waitMs > 0) {
+      const outcome = await buf.waitForData(r.nextCursor, waitMs);
+      if (outcome === "data" || outcome === "eof") {
+        r = buf.read(r.nextCursor, cap);
+      }
+    }
+    const out = {
+      bytes: r.bytes.toString("base64"),
+      nextCursor: r.nextCursor
+    };
+    if (r.gap !== void 0) {
+      out.gap = r.gap;
+    }
+    if (r.eof === true) {
+      out.eof = true;
+    }
+    return out;
+  }
+  requireStreamBuffer() {
+    if (this.streamBuffer === void 0) {
+      const err = new Error(
+        `session ${this.sessionId} has no stream buffer; call hydra-acp/stream_open first`
+      );
+      err.code = JsonRpcErrorCodes.StreamNotEnabled;
+      throw err;
+    }
+    return this.streamBuffer;
+  }
   markClosed(opts) {
     if (this.closed) {
       return;
     }
     this.closed = true;
     this.cancelIdleTimer();
+    if (this.currentEntry?.kind === "user") {
+      this.broadcastTurnComplete(
+        this.currentEntry.clientId,
+        { stopReason: "interrupted" },
+        this.currentEntry.messageId,
+        this.currentEntry.wasAmend
+      );
+      this.currentEntry = void 0;
+    }
     const stranded = this.promptQueue;
     this.promptQueue = [];
     for (const entry of stranded) {
@@ -3654,12 +4607,23 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       } catch {
       }
     }
+    this.notifyChain("session.closed", {});
     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);
     }
     this.clients.clear();
+    if (this.streamBuffer !== void 0) {
+      const buf = this.streamBuffer;
+      const path13 = this.streamFilePath;
+      this.streamBuffer = void 0;
+      this.streamFilePath = void 0;
+      buf.close();
+      if (path13 !== void 0) {
+        void buf.drainFileWrites().then(() => fsp4.unlink(path13).catch(() => void 0));
+      }
+    }
     for (const handler of this.closeHandlers) {
       handler(opts);
     }
@@ -3722,6 +4686,44 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       clearTimeout(this.idleTimer);
       this.idleTimer = void 0;
     }
+    this.cancelIdleEventTimer();
+  }
+  // ── Lifecycle event timer ────────────────────────────────────────────────
+  scheduleIdleEvent() {
+    if (this.closed || this.idleEventTimeoutMs <= 0 || this.transformChain.length === 0) {
+      return;
+    }
+    if (this.idleEventTimer) {
+      clearTimeout(this.idleEventTimer);
+    }
+    this.idleEventTimer = setTimeout(() => {
+      this.idleEventTimer = void 0;
+      this.notifyChain("session.idle", {});
+    }, this.idleEventTimeoutMs);
+    if (typeof this.idleEventTimer.unref === "function") {
+      this.idleEventTimer.unref();
+    }
+  }
+  cancelIdleEventTimer() {
+    if (this.idleEventTimer) {
+      clearTimeout(this.idleEventTimer);
+      this.idleEventTimer = void 0;
+    }
+  }
+  // Send a lifecycle notification to every transformer in the chain that
+  // declared the matching intercept. Fire-and-forget — no response expected.
+  notifyChain(event, payload) {
+    const intercept = `lifecycle:${event}`;
+    for (const t of this.transformChain) {
+      if (!t.intercepts.has(intercept)) {
+        continue;
+      }
+      void t.connection.notify("transformer/session_event", {
+        event,
+        sessionId: this.sessionId,
+        payload
+      }).catch(() => void 0);
+    }
   }
   rewriteForClient(params) {
     if (params && typeof params === "object" && !Array.isArray(params)) {
@@ -3761,6 +4763,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
       }
       this.scheduleIdleCheck();
+      this.scheduleIdleEvent();
     }
     this.updatedAt = Date.now();
     for (const client of this.clients.values()) {
@@ -3917,6 +4920,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       return;
     }
     this.promptInFlight = true;
+    await new Promise((r) => setImmediate(r));
     try {
       while (this.promptQueue.length > 0) {
         const next = this.promptQueue.shift();
@@ -3936,7 +4940,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         try {
           const result = await this.runQueueEntry(next);
           next.resolve(result);
-          await Promise.resolve();
+          await new Promise((r) => setImmediate(r));
         } catch (err) {
           next.reject(err);
         } finally {
@@ -3963,6 +4967,22 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       return entry.task();
     }
     this.broadcastPromptReceived(entry);
+    const promptText = extractPromptText(entry.prompt).trim();
+    if (promptText === "/model" || promptText.startsWith("/model ") || promptText === "/sessions" || promptText === "/help") {
+      let result;
+      if (promptText === "/sessions") {
+        result = await this.handleSessionsCommand();
+      } else if (promptText === "/help") {
+        result = await this.handleHelpCommand();
+      } else {
+        result = await this.handleModelCommand(promptText);
+      }
+      if (!this.closed) {
+        this.broadcastTurnComplete(entry.clientId, result, entry.messageId, entry.wasAmend);
+      }
+      this.clearAmendIfMatches(entry.messageId);
+      return result;
+    }
     let response;
     try {
       response = await this.agent.connection.request(
@@ -3973,21 +4993,25 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
       );
     } catch (err) {
+      if (!this.closed) {
+        this.broadcastTurnComplete(
+          entry.clientId,
+          { stopReason: "error" },
+          entry.messageId,
+          entry.wasAmend
+        );
+      }
+      this.clearAmendIfMatches(entry.messageId);
+      throw err;
+    }
+    if (!this.closed) {
       this.broadcastTurnComplete(
         entry.clientId,
-        { stopReason: "error" },
+        response,
         entry.messageId,
         entry.wasAmend
       );
-      this.clearAmendIfMatches(entry.messageId);
-      throw err;
     }
-    this.broadcastTurnComplete(
-      entry.clientId,
-      response,
-      entry.messageId,
-      entry.wasAmend
-    );
     this.clearAmendIfMatches(entry.messageId);
     return response;
   }
@@ -4252,6 +5276,12 @@ function extractPromptText(prompt) {
     return "";
   }).join("");
 }
+function defaultStopPayload(method) {
+  if (method === "session/prompt") {
+    return { stopReason: "stopped" };
+  }
+  return {};
+}
 function firstLine(text, max) {
   for (const raw of text.split(/\r?\n/)) {
     const line = raw.trim();
@@ -4292,7 +5322,8 @@ var PersistedUsage = z4.object({
   used: z4.number().optional(),
   size: z4.number().optional(),
   costAmount: z4.number().optional(),
-  costCurrency: z4.string().optional()
+  costCurrency: z4.string().optional(),
+  cumulativeCost: z4.number().optional()
 });
 var SessionRecord = z4.object({
   version: z4.literal(1),
@@ -4341,6 +5372,9 @@ var SessionRecord = z4.object({
   // it) so the local history.jsonl gets populated from the agent's
   // memory. Cleared after that first resurrect completes.
   pendingHistorySync: z4.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.
+  parentSessionId: z4.string().optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -4462,6 +5496,7 @@ function recordFromMemorySession(args) {
     agentModes: args.agentModes,
     agentModels: args.agentModels,
     pendingHistorySync: args.pendingHistorySync,
+    parentSessionId: args.parentSessionId,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -4671,7 +5706,9 @@ var SessionManager = class {
     this.sessionHistoryMaxEntries = options.sessionHistoryMaxEntries ?? 1e3;
     this.histories = new HistoryStore({ maxEntries: this.sessionHistoryMaxEntries });
     this.idleTimeoutMs = options.idleTimeoutMs ?? 0;
+    this.idleEventTimeoutMs = options.idleEventTimeoutMs ?? 3e4;
     this.defaultModels = options.defaultModels ?? {};
+    this.defaultTransformers = options.defaultTransformers ?? [];
     this.logger = options.logger;
     this.npmRegistry = options.npmRegistry;
   }
@@ -4683,6 +5720,8 @@ var SessionManager = class {
   histories;
   idleTimeoutMs;
   defaultModels;
+  defaultTransformers;
+  idleEventTimeoutMs;
   sessionHistoryMaxEntries;
   // Serialize meta.json read-modify-write operations per session id so
   // concurrent snapshot updates (e.g. an agent emitting model + mode
@@ -4699,23 +5738,51 @@ var SessionManager = class {
       model: params.model,
       onInstallProgress: params.onInstallProgress
     });
+    if (params.transformChain && params.transformChain.length > 0) {
+      let caps = { ...fresh.agentCapabilities ?? {} };
+      for (const t of params.transformChain) {
+        if (!t.intercepts.has("agent:initialize")) {
+          continue;
+        }
+        try {
+          const result = await t.connection.request("transformer/message", {
+            token: `t_${generateRawSessionId()}`,
+            phase: "response",
+            method: "initialize",
+            direction: "agent\u2192daemon",
+            sessionId: "(pre-session)",
+            envelope: caps
+          });
+          if (result.action === "stop" && result.payload) {
+            caps = result.payload;
+          }
+        } catch {
+        }
+      }
+      fresh.agentCapabilities = caps;
+    }
     const session = new Session({
       cwd: params.cwd,
       agentId: params.agentId,
       agent: fresh.agent,
       upstreamSessionId: fresh.upstreamSessionId,
       agentMeta: fresh.agentMeta,
+      agentCapabilities: fresh.agentCapabilities,
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
+      idleEventTimeoutMs: this.idleEventTimeoutMs,
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: fresh.initialModel,
       currentMode: fresh.initialMode,
       agentModes: fresh.initialModes,
-      agentModels: fresh.initialModels
+      agentModels: fresh.initialModels,
+      transformChain: params.transformChain,
+      parentSessionId: params.parentSessionId
     });
     await this.attachManagerHooks(session);
     return session;
@@ -4769,12 +5836,17 @@ var SessionManager = class {
       cwd: params.cwd,
       plan
     });
+    let agentCapabilities;
     try {
-      await agent.connection.request("initialize", {
-        protocolVersion: ACP_PROTOCOL_VERSION,
-        clientCapabilities: {},
-        clientInfo: { name: "hydra", version: HYDRA_VERSION }
-      });
+      const initResult = await agent.connection.request(
+        "initialize",
+        {
+          protocolVersion: ACP_PROTOCOL_VERSION,
+          clientCapabilities: {},
+          clientInfo: { name: "hydra", version: HYDRA_VERSION }
+        }
+      );
+      agentCapabilities = initResult.agentCapabilities;
     } catch (err) {
       await agent.kill().catch(() => void 0);
       throw err;
@@ -4804,6 +5876,22 @@ var SessionManager = class {
     } else {
       agent.connection.drainBuffered("session/update");
     }
+    const agentReportedMode = extractInitialCurrentMode(loadResult ?? {});
+    const advertisedModes = params.agentModes ?? nonEmptyOrUndefined(extractInitialModes(loadResult ?? {}));
+    this.logger?.info(
+      `resurrect: sessionId=${params.hydraSessionId} persistedMode=${JSON.stringify(params.currentMode)} agentReportedMode=${JSON.stringify(agentReportedMode)} advertisedModes=${JSON.stringify(advertisedModes?.map((m) => m.id))}`
+    );
+    const effectiveMode = await restoreCurrentMode({
+      agent,
+      upstreamSessionId: params.upstreamSessionId,
+      persistedMode: params.currentMode,
+      agentReportedMode,
+      advertisedModes,
+      logger: this.logger
+    });
+    this.logger?.info(
+      `resurrect: effectiveMode=${JSON.stringify(effectiveMode)} for sessionId=${params.hydraSessionId}`
+    );
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd: params.cwd,
@@ -4811,11 +5899,13 @@ var SessionManager = class {
       agent,
       upstreamSessionId: params.upstreamSessionId,
       agentMeta: loadResult?._meta,
+      agentCapabilities,
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       // Prefer what we previously stored from a current_model_update; if
@@ -4823,11 +5913,15 @@ var SessionManager = class {
       // this fix), fall back to the model the agent ships in its
       // session/load response body.
       currentModel: params.currentModel ?? extractInitialModel(loadResult ?? {}),
-      currentMode: params.currentMode ?? extractInitialCurrentMode(loadResult ?? {}),
+      currentMode: effectiveMode,
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
-      agentModes: params.agentModes ?? nonEmptyOrUndefined(extractInitialModes(loadResult ?? {})),
-      agentModels: params.agentModels ?? nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})),
+      agentModes: advertisedModes,
+      // Always prefer the fresh list from session/load over the persisted
+      // snapshot — the proxy's available models can change between daemon
+      // restarts (quota resets, rollouts), so meta.json is intentionally
+      // treated as a cold fallback here, not the authoritative source.
+      agentModels: nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})) ?? params.agentModels,
       // Only gate the first-prompt title heuristic when we actually have
       // a title to preserve. A title-less session (lost to a write race
       // or never seeded) should re-derive from the next prompt rather
@@ -4854,6 +5948,15 @@ var SessionManager = class {
       mcpServers: [],
       onInstallProgress: params.onInstallProgress
     });
+    const advertisedModes = params.agentModes ?? fresh.initialModes;
+    const effectiveMode = await restoreCurrentMode({
+      agent: fresh.agent,
+      upstreamSessionId: fresh.upstreamSessionId,
+      persistedMode: params.currentMode,
+      agentReportedMode: fresh.initialMode,
+      advertisedModes,
+      logger: this.logger
+    });
     const session = new Session({
       sessionId: params.hydraSessionId,
       cwd,
@@ -4861,20 +5964,22 @@ var SessionManager = class {
       agent: fresh.agent,
       upstreamSessionId: fresh.upstreamSessionId,
       agentMeta: fresh.agentMeta,
+      agentCapabilities: fresh.agentCapabilities,
       title: params.title,
       agentArgs: params.agentArgs,
       idleTimeoutMs: this.idleTimeoutMs,
       logger: this.logger,
       spawnReplacementAgent: (p) => this.bootstrapAgent({ ...p, mcpServers: [] }),
+      listSessions: () => this.list(),
       historyStore: this.histories,
       historyMaxEntries: this.sessionHistoryMaxEntries,
       // Prefer the stored value (set by a previous current_model_update);
       // fall back to whatever the agent ships in its session/new response.
       currentModel: params.currentModel ?? fresh.initialModel,
-      currentMode: params.currentMode ?? fresh.initialMode,
+      currentMode: effectiveMode,
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
-      agentModes: params.agentModes ?? fresh.initialModes,
+      agentModes: advertisedModes,
       agentModels: params.agentModels ?? fresh.initialModels,
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
@@ -5042,11 +6147,15 @@ var SessionManager = class {
       plan
     });
     try {
-      await agent.connection.request("initialize", {
-        protocolVersion: ACP_PROTOCOL_VERSION,
-        clientCapabilities: {},
-        clientInfo: { name: "hydra", version: HYDRA_VERSION }
-      });
+      const initResult = await agent.connection.request(
+        "initialize",
+        {
+          protocolVersion: ACP_PROTOCOL_VERSION,
+          clientCapabilities: {},
+          clientInfo: { name: "hydra", version: HYDRA_VERSION }
+        }
+      );
+      const agentCapabilities = initResult.agentCapabilities;
       const newResult = await agent.connection.request(
         "session/new",
         {
@@ -5072,13 +6181,15 @@ var SessionManager = class {
               modelId: desired
             });
             initialModel = desired;
-          } catch {
+          } catch (err) {
+            this.logger?.warn(
+              `defaultModels[${params.agentId}]=${JSON.stringify(desired)} rejected by agent (${err.message}); session will use ${JSON.stringify(initialModel)}`
+            );
           }
         } else {
           const known = initialModels.map((m) => m.modelId).join(", ");
-          process.stderr.write(
-            `hydra-acp: defaultModels[${params.agentId}]=${JSON.stringify(desired)} is not in the agent's availableModels (${known}); skipping session/set_model
-`
+          this.logger?.warn(
+            `defaultModels[${params.agentId}]=${JSON.stringify(desired)} not in agent's availableModels ([${known}]); skipping session/set_model, session will use ${JSON.stringify(initialModel)}`
           );
         }
       }
@@ -5088,6 +6199,7 @@ var SessionManager = class {
         agent,
         upstreamSessionId: sessionIdRaw,
         agentMeta: newResult._meta,
+        agentCapabilities,
         initialModel,
         initialModels: initialModels.length > 0 ? initialModels : void 0,
         initialModes: initialModes.length > 0 ? initialModes : void 0,
@@ -5208,7 +6320,13 @@ var SessionManager = class {
       agentArgs: record.agentArgs,
       currentModel: record.currentModel,
       currentMode: record.currentMode,
-      currentUsage: persistedUsageToSnapshot(record.currentUsage),
+      currentUsage: persistedUsageToSnapshot(
+        record.currentUsage ? {
+          ...record.currentUsage,
+          cumulativeCost: (record.currentUsage.cumulativeCost ?? 0) + (record.currentUsage.costAmount ?? 0),
+          costAmount: void 0
+        } : void 0
+      ),
       agentCommands: record.agentCommands,
       agentModes: record.agentModes,
       agentModels: record.agentModels,
@@ -5248,6 +6366,9 @@ var SessionManager = class {
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
+  liveSessions() {
+    return this.sessions.values();
+  }
   // Snapshot of which agent versions are currently in use by live
   // sessions, keyed by agentId. Read by the registry-fetch prune sweep
   // so it can skip install dirs that still back a running process.
@@ -5310,6 +6431,7 @@ var SessionManager = class {
         agentId: session.agentId,
         currentModel: session.currentModel,
         currentUsage: session.currentUsage,
+        parentSessionId: session.parentSessionId,
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
@@ -5332,9 +6454,13 @@ var SessionManager = class {
         title: r.title,
         agentId: r.agentId,
         currentModel: r.currentModel,
-        currentUsage: r.currentUsage,
+        currentUsage: r.currentUsage ? {
+          ...r.currentUsage,
+          costAmount: (r.currentUsage.cumulativeCost ?? 0) + (r.currentUsage.costAmount ?? 0) || void 0
+        } : void 0,
         importedFromMachine: r.importedFromMachine,
         importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
+        parentSessionId: r.parentSessionId,
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
@@ -5456,6 +6582,7 @@ var SessionManager = class {
         currentMode: args.bundle.session.currentMode,
         currentUsage: args.bundle.session.currentUsage,
         agentCommands: args.bundle.session.agentCommands,
+        agentModes: args.bundle.session.agentModes,
         createdAt: args.preservedCreatedAt ?? now,
         // Fallback path for historyMtimeIso (used when the history file
         // is missing). Keep this consistent with the utimes stamp above.
@@ -5678,6 +6805,7 @@ function mergeForPersistence(session, existing) {
     agentCommands,
     agentModes,
     agentModels,
+    parentSessionId: session.parentSessionId ?? existing?.parentSessionId,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -5698,6 +6826,9 @@ function usageSnapshotToPersisted(usage) {
   if (usage.costCurrency !== void 0) {
     out.costCurrency = usage.costCurrency;
   }
+  if (usage.cumulativeCost !== void 0) {
+    out.cumulativeCost = usage.cumulativeCost;
+  }
   return Object.keys(out).length > 0 ? out : void 0;
 }
 function persistedUsageToSnapshot(usage) {
@@ -5841,6 +6972,47 @@ function extractInitialCurrentMode(result) {
   }
   return void 0;
 }
+async function restoreCurrentMode(opts) {
+  const {
+    agent,
+    upstreamSessionId,
+    persistedMode,
+    agentReportedMode,
+    advertisedModes,
+    logger
+  } = opts;
+  if (!persistedMode) {
+    return agentReportedMode;
+  }
+  if (persistedMode === agentReportedMode) {
+    return persistedMode;
+  }
+  if (advertisedModes && advertisedModes.length > 0 && !advertisedModes.some((m) => m.id === persistedMode)) {
+    const known = advertisedModes.map((m) => m.id).join(", ");
+    logger?.warn(
+      `resurrect: persisted currentMode=${JSON.stringify(persistedMode)} not in agent's availableModes ([${known}]); skipping session/set_mode, session will use ${JSON.stringify(agentReportedMode)}`
+    );
+    return agentReportedMode;
+  }
+  try {
+    logger?.info(
+      `resurrect: pushing persisted modeId=${JSON.stringify(persistedMode)} to agent (agentReported=${JSON.stringify(agentReportedMode)})`
+    );
+    await agent.connection.request("session/set_mode", {
+      sessionId: upstreamSessionId,
+      modeId: persistedMode
+    });
+    logger?.info(
+      `resurrect: session/set_mode accepted, effectiveMode=${JSON.stringify(persistedMode)}`
+    );
+    return persistedMode;
+  } catch (err) {
+    logger?.warn(
+      `resurrect: session/set_mode rejected by agent for modeId=${JSON.stringify(persistedMode)} (${err.message}); session will use ${JSON.stringify(agentReportedMode)}`
+    );
+    return agentReportedMode;
+  }
+}
 function parseModesList(list) {
   if (!Array.isArray(list)) {
     return [];
@@ -5901,7 +7073,7 @@ async function historyMtimeIso(sessionId) {
 // src/core/extensions.ts
 import { spawn as spawn4 } from "child_process";
 import * as fs11 from "fs";
-import * as fsp3 from "fs/promises";
+import * as fsp5 from "fs/promises";
 import * as path7 from "path";
 var RESTART_BASE_MS = 1e3;
 var RESTART_CAP_MS = 6e4;
@@ -5910,8 +7082,10 @@ var ExtensionManager = class {
   entries = /* @__PURE__ */ new Map();
   stopping = false;
   context;
-  constructor(extensions, context) {
+  tokenRegistry;
+  constructor(extensions, context, options = {}) {
     this.context = context;
+    this.tokenRegistry = options.tokenRegistry;
     for (const ext of extensions) {
       this.entries.set(ext.name, this.makeEntry(ext));
     }
@@ -5919,11 +7093,482 @@ var ExtensionManager = class {
   setContext(context) {
     this.context = context;
   }
+  // Called by the WS handler after a process connects and calls initialize
+  // with clientInfo.version. Stored on the entry and surfaced in list().
+  reportVersion(name, version) {
+    const entry = this.entries.get(name);
+    if (entry) {
+      entry.version = version;
+    }
+  }
+  async start() {
+    if (!this.context) {
+      throw new Error("ExtensionManager: setContext must be called before start");
+    }
+    await fsp5.mkdir(paths.extensionsDir(), { recursive: true });
+    await this.reapOrphans();
+    for (const entry of this.entries.values()) {
+      if (!entry.config.enabled) {
+        continue;
+      }
+      this.spawn(entry, 0);
+    }
+  }
+  async stop() {
+    this.stopping = true;
+    const tasks = [];
+    for (const entry of this.entries.values()) {
+      if (entry.restartTimer) {
+        clearTimeout(entry.restartTimer);
+        entry.restartTimer = void 0;
+      }
+      const child = entry.child;
+      if (!child) {
+        continue;
+      }
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      tasks.push(
+        new Promise((resolve3) => {
+          if (child.exitCode !== null || child.signalCode !== null) {
+            resolve3();
+            return;
+          }
+          const timer = setTimeout(() => {
+            try {
+              child.kill("SIGKILL");
+            } catch {
+            }
+            resolve3();
+          }, STOP_GRACE_MS);
+          child.on("exit", () => {
+            clearTimeout(timer);
+            resolve3();
+          });
+        })
+      );
+    }
+    await Promise.allSettled(tasks);
+    for (const entry of this.entries.values()) {
+      try {
+        entry.logStream?.end();
+      } catch {
+      }
+      entry.child = void 0;
+      entry.logStream = void 0;
+      entry.pid = void 0;
+    }
+  }
+  list() {
+    return [...this.entries.values()].map((entry) => this.infoFor(entry));
+  }
+  get(name) {
+    const entry = this.entries.get(name);
+    return entry ? this.infoFor(entry) : void 0;
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  async startByName(name) {
+    const entry = this.entries.get(name);
+    if (!entry) {
+      throw withCode2(new Error(`unknown extension: ${name}`), "NOT_FOUND");
+    }
+    if (entry.child) {
+      throw withCode2(new Error(`extension ${name} already running`), "CONFLICT");
+    }
+    if (entry.restartTimer) {
+      clearTimeout(entry.restartTimer);
+      entry.restartTimer = void 0;
+    }
+    entry.manuallyStopped = false;
+    entry.restartCount = 0;
+    this.spawn(entry, 0);
+    return this.infoFor(entry);
+  }
+  async stopByName(name) {
+    const entry = this.entries.get(name);
+    if (!entry) {
+      throw withCode2(new Error(`unknown extension: ${name}`), "NOT_FOUND");
+    }
+    entry.manuallyStopped = true;
+    if (entry.restartTimer) {
+      clearTimeout(entry.restartTimer);
+      entry.restartTimer = void 0;
+    }
+    const child = entry.child;
+    if (!child) {
+      return this.infoFor(entry);
+    }
+    await this.terminate(entry, child);
+    return this.infoFor(entry);
+  }
+  async restartByName(name) {
+    await this.stopByName(name);
+    return this.startByName(name);
+  }
+  // Register a new extension and (if enabled) start it. Used by the
+  // POST /v1/extensions endpoint so `hydra-acp extensions add` can take
+  // effect without a daemon restart.
+  register(config) {
+    if (this.entries.has(config.name)) {
+      throw withCode2(
+        new Error(`extension ${config.name} already exists`),
+        "CONFLICT"
+      );
+    }
+    if (!this.context) {
+      throw new Error("ExtensionManager: setContext must be called before register");
+    }
+    const entry = this.makeEntry(config);
+    this.entries.set(config.name, entry);
+    if (config.enabled) {
+      this.spawn(entry, 0);
+    }
+    return this.infoFor(entry);
+  }
+  async unregister(name) {
+    const entry = this.entries.get(name);
+    if (!entry) {
+      throw withCode2(new Error(`unknown extension: ${name}`), "NOT_FOUND");
+    }
+    entry.manuallyStopped = true;
+    if (entry.restartTimer) {
+      clearTimeout(entry.restartTimer);
+      entry.restartTimer = void 0;
+    }
+    const child = entry.child;
+    if (child) {
+      await this.terminate(entry, child);
+    }
+    try {
+      entry.logStream?.end();
+    } catch {
+    }
+    this.entries.delete(name);
+  }
+  async terminate(entry, child) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      return;
+    }
+    const exited = new Promise((resolve3) => {
+      entry.exitWaiters.push(resolve3);
+    });
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    const killTimer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, STOP_GRACE_MS);
+    if (typeof killTimer.unref === "function") {
+      killTimer.unref();
+    }
+    try {
+      await exited;
+    } finally {
+      clearTimeout(killTimer);
+    }
+  }
+  infoFor(entry) {
+    let status;
+    if (entry.child) {
+      status = "running";
+    } else if (entry.restartTimer) {
+      status = "restarting";
+    } else if (!entry.config.enabled) {
+      status = "disabled";
+    } else {
+      status = "stopped";
+    }
+    return {
+      name: entry.config.name,
+      status,
+      pid: entry.pid,
+      enabled: entry.config.enabled,
+      restartCount: entry.restartCount,
+      startedAt: entry.startedAt,
+      lastExitCode: entry.lastExitCode,
+      logPath: paths.extensionLogFile(entry.config.name),
+      version: entry.version
+    };
+  }
+  makeEntry(config) {
+    return {
+      config,
+      child: void 0,
+      logStream: void 0,
+      restartTimer: void 0,
+      pid: void 0,
+      startedAt: void 0,
+      restartCount: 0,
+      lastExitCode: void 0,
+      manuallyStopped: false,
+      exitWaiters: [],
+      version: void 0,
+      processToken: void 0
+    };
+  }
+  async reapOrphans() {
+    let entries;
+    try {
+      entries = await fsp5.readdir(paths.extensionsDir());
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT") {
+        return;
+      }
+      throw err;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".pid")) {
+        continue;
+      }
+      const pidPath = path7.join(paths.extensionsDir(), entry);
+      let pid;
+      try {
+        const raw = await fsp5.readFile(pidPath, "utf8");
+        const parsed = Number.parseInt(raw.trim(), 10);
+        if (Number.isInteger(parsed) && parsed > 0) {
+          pid = parsed;
+        }
+      } catch {
+      }
+      if (typeof pid === "number" && isAlive(pid)) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+        }
+        const deadline = Date.now() + STOP_GRACE_MS;
+        while (Date.now() < deadline && isAlive(pid)) {
+          await new Promise((r) => setTimeout(r, 50));
+        }
+        if (isAlive(pid)) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      }
+      await fsp5.unlink(pidPath).catch(() => void 0);
+    }
+  }
+  spawn(entry, attempt) {
+    if (this.stopping || entry.manuallyStopped) {
+      return;
+    }
+    const ctx = this.context;
+    if (!ctx) {
+      throw new Error("ExtensionManager.spawn called before setContext");
+    }
+    const ext = entry.config;
+    const command = ext.command.length > 0 ? ext.command : [ext.name];
+    const logStream = fs11.createWriteStream(paths.extensionLogFile(ext.name), {
+      flags: "a"
+    });
+    logStream.write(
+      `[hydra-acp] ${(/* @__PURE__ */ new Date()).toISOString()} starting extension ${ext.name} (attempt ${attempt + 1})
+`
+    );
+    const processToken = this.tokenRegistry?.mint(ext.name, "extension") ?? ctx.serviceToken;
+    entry.processToken = processToken;
+    entry.version = void 0;
+    const env = {
+      ...process.env,
+      HYDRA_ACP_DAEMON_URL: ctx.daemonUrl,
+      HYDRA_ACP_DAEMON_HOST: ctx.daemonHost,
+      HYDRA_ACP_DAEMON_PORT: String(ctx.daemonPort),
+      HYDRA_ACP_TOKEN: processToken,
+      HYDRA_ACP_WS_URL: ctx.daemonWsUrl,
+      HYDRA_ACP_HOME: ctx.hydraHome,
+      HYDRA_ACP_EXTENSION_NAME: ext.name,
+      ...ext.env
+    };
+    const [cmd, ...baseArgs] = command;
+    if (cmd === void 0) {
+      logStream.write(`[hydra-acp] extension ${ext.name} has empty command
+`);
+      logStream.end();
+      return;
+    }
+    const args = [...baseArgs, ...ext.args];
+    let child;
+    try {
+      child = spawn4(cmd, args, {
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false
+      });
+    } catch (err) {
+      logStream.write(
+        `[hydra-acp] failed to spawn ${ext.name}: ${err.message}
+`
+      );
+      logStream.end();
+      this.scheduleRestart(entry, attempt);
+      return;
+    }
+    if (child.stdout) {
+      child.stdout.pipe(logStream, { end: false });
+    }
+    if (child.stderr) {
+      child.stderr.pipe(logStream, { end: false });
+    }
+    if (typeof child.pid === "number") {
+      try {
+        fs11.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+`, {
+          encoding: "utf8",
+          mode: 384
+        });
+      } catch (err) {
+        logStream.write(
+          `[hydra-acp] failed to write pid file for ${ext.name}: ${err.message}
+`
+        );
+      }
+    }
+    entry.child = child;
+    entry.logStream = logStream;
+    entry.pid = typeof child.pid === "number" ? child.pid : void 0;
+    entry.startedAt = Date.now();
+    entry.lastExitCode = void 0;
+    child.on("error", (err) => {
+      logStream.write(
+        `[hydra-acp] extension ${ext.name} error: ${err.message}
+`
+      );
+    });
+    child.on("exit", (code, signal) => {
+      try {
+        fs11.unlinkSync(paths.extensionPidFile(ext.name));
+      } catch {
+      }
+      logStream.write(
+        `[hydra-acp] extension ${ext.name} exited code=${code ?? "null"} signal=${signal ?? "null"}
+`
+      );
+      entry.child = void 0;
+      entry.pid = void 0;
+      entry.lastExitCode = typeof code === "number" ? code : void 0;
+      if (entry.processToken) {
+        this.tokenRegistry?.revoke(ext.name);
+        entry.processToken = void 0;
+      }
+      const waiters = entry.exitWaiters.splice(0);
+      for (const resolve3 of waiters) {
+        resolve3();
+      }
+      if (this.stopping || entry.manuallyStopped) {
+        try {
+          logStream.end();
+        } catch {
+        }
+        entry.logStream = void 0;
+        return;
+      }
+      entry.restartCount += 1;
+      this.scheduleRestart(entry, attempt + 1);
+    });
+  }
+  scheduleRestart(entry, attempt) {
+    if (this.stopping || entry.manuallyStopped) {
+      return;
+    }
+    const delay = Math.min(
+      RESTART_BASE_MS * 2 ** Math.min(attempt, 10),
+      RESTART_CAP_MS
+    );
+    entry.restartTimer = setTimeout(() => {
+      entry.restartTimer = void 0;
+      this.spawn(entry, attempt);
+    }, delay);
+    if (typeof entry.restartTimer.unref === "function") {
+      entry.restartTimer.unref();
+    }
+  }
+};
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function withCode2(err, code) {
+  err.code = code;
+  return err;
+}
+
+// src/core/transformer-manager.ts
+import { spawn as spawn5 } from "child_process";
+import * as fs12 from "fs";
+import * as fsp6 from "fs/promises";
+import * as path8 from "path";
+var RESTART_BASE_MS2 = 1e3;
+var RESTART_CAP_MS2 = 6e4;
+var STOP_GRACE_MS2 = 3e3;
+var TransformerManager = class {
+  entries = /* @__PURE__ */ new Map();
+  // Transformers that have completed transformer/initialize and are ready to
+  // participate in chains. Keyed by transformer name.
+  connected = /* @__PURE__ */ new Map();
+  stopping = false;
+  context;
+  tokenRegistry;
+  constructor(transformers, context, options = {}) {
+    this.context = context;
+    this.tokenRegistry = options.tokenRegistry;
+    for (const t of transformers) {
+      this.entries.set(t.name, this.makeEntry(t));
+    }
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  reportVersion(name, version) {
+    const entry = this.entries.get(name);
+    if (entry) {
+      entry.version = version;
+    }
+  }
+  // Called by the WS handler after transformer/initialize completes. The
+  // transformer is now eligible to participate in session chains.
+  registerConnection(name, connection, intercepts) {
+    this.connected.set(name, {
+      name,
+      connection,
+      intercepts: new Set(intercepts)
+    });
+  }
+  // Called by the WS handler when the transformer's WS connection closes.
+  deregisterConnection(name) {
+    this.connected.delete(name);
+  }
+  // Resolve a list of transformer names to their live TransformerRef objects.
+  // Names that are configured but not yet connected are silently skipped
+  // (fail-open: session proceeds without that transformer rather than failing).
+  resolveChain(names) {
+    const out = [];
+    for (const name of names) {
+      const ref = this.connected.get(name);
+      if (ref) {
+        out.push(ref);
+      }
+    }
+    return out;
+  }
   async start() {
     if (!this.context) {
-      throw new Error("ExtensionManager: setContext must be called before start");
+      throw new Error("TransformerManager: setContext must be called before start");
     }
-    await fsp3.mkdir(paths.extensionsDir(), { recursive: true });
+    await fsp6.mkdir(paths.transformersDir(), { recursive: true });
     await this.reapOrphans();
     for (const entry of this.entries.values()) {
       if (!entry.config.enabled) {
@@ -5960,7 +7605,7 @@ var ExtensionManager = class {
             } catch {
             }
             resolve3();
-          }, STOP_GRACE_MS);
+          }, STOP_GRACE_MS2);
           child.on("exit", () => {
             clearTimeout(timer);
             resolve3();
@@ -5992,10 +7637,10 @@ var ExtensionManager = class {
   async startByName(name) {
     const entry = this.entries.get(name);
     if (!entry) {
-      throw withCode2(new Error(`unknown extension: ${name}`), "NOT_FOUND");
+      throw withCode3(new Error(`unknown transformer: ${name}`), "NOT_FOUND");
     }
     if (entry.child) {
-      throw withCode2(new Error(`extension ${name} already running`), "CONFLICT");
+      throw withCode3(new Error(`transformer ${name} already running`), "CONFLICT");
     }
     if (entry.restartTimer) {
       clearTimeout(entry.restartTimer);
@@ -6009,7 +7654,7 @@ var ExtensionManager = class {
   async stopByName(name) {
     const entry = this.entries.get(name);
     if (!entry) {
-      throw withCode2(new Error(`unknown extension: ${name}`), "NOT_FOUND");
+      throw withCode3(new Error(`unknown transformer: ${name}`), "NOT_FOUND");
     }
     entry.manuallyStopped = true;
     if (entry.restartTimer) {
@@ -6027,18 +7672,15 @@ var ExtensionManager = class {
     await this.stopByName(name);
     return this.startByName(name);
   }
-  // Register a new extension and (if enabled) start it. Used by the
-  // POST /v1/extensions endpoint so `hydra-acp extensions add` can take
-  // effect without a daemon restart.
   register(config) {
     if (this.entries.has(config.name)) {
-      throw withCode2(
-        new Error(`extension ${config.name} already exists`),
+      throw withCode3(
+        new Error(`transformer ${config.name} already exists`),
         "CONFLICT"
       );
     }
     if (!this.context) {
-      throw new Error("ExtensionManager: setContext must be called before register");
+      throw new Error("TransformerManager: setContext must be called before register");
     }
     const entry = this.makeEntry(config);
     this.entries.set(config.name, entry);
@@ -6050,7 +7692,7 @@ var ExtensionManager = class {
   async unregister(name) {
     const entry = this.entries.get(name);
     if (!entry) {
-      throw withCode2(new Error(`unknown extension: ${name}`), "NOT_FOUND");
+      throw withCode3(new Error(`unknown transformer: ${name}`), "NOT_FOUND");
     }
     entry.manuallyStopped = true;
     if (entry.restartTimer) {
@@ -6083,7 +7725,7 @@ var ExtensionManager = class {
         child.kill("SIGKILL");
       } catch {
       }
-    }, STOP_GRACE_MS);
+    }, STOP_GRACE_MS2);
     if (typeof killTimer.unref === "function") {
       killTimer.unref();
     }
@@ -6112,7 +7754,8 @@ var ExtensionManager = class {
       restartCount: entry.restartCount,
       startedAt: entry.startedAt,
       lastExitCode: entry.lastExitCode,
-      logPath: paths.extensionLogFile(entry.config.name)
+      logPath: paths.transformerLogFile(entry.config.name),
+      version: entry.version
     };
   }
   makeEntry(config) {
@@ -6126,13 +7769,15 @@ var ExtensionManager = class {
       restartCount: 0,
       lastExitCode: void 0,
       manuallyStopped: false,
-      exitWaiters: []
+      exitWaiters: [],
+      version: void 0,
+      processToken: void 0
     };
   }
   async reapOrphans() {
     let entries;
     try {
-      entries = await fsp3.readdir(paths.extensionsDir());
+      entries = await fsp6.readdir(paths.transformersDir());
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -6144,33 +7789,33 @@ var ExtensionManager = class {
       if (!entry.endsWith(".pid")) {
         continue;
       }
-      const pidPath = path7.join(paths.extensionsDir(), entry);
+      const pidPath = path8.join(paths.transformersDir(), entry);
       let pid;
       try {
-        const raw = await fsp3.readFile(pidPath, "utf8");
+        const raw = await fsp6.readFile(pidPath, "utf8");
         const parsed = Number.parseInt(raw.trim(), 10);
         if (Number.isInteger(parsed) && parsed > 0) {
           pid = parsed;
         }
       } catch {
       }
-      if (typeof pid === "number" && isAlive(pid)) {
+      if (typeof pid === "number" && isAlive2(pid)) {
         try {
           process.kill(pid, "SIGTERM");
         } catch {
         }
-        const deadline = Date.now() + STOP_GRACE_MS;
-        while (Date.now() < deadline && isAlive(pid)) {
+        const deadline = Date.now() + STOP_GRACE_MS2;
+        while (Date.now() < deadline && isAlive2(pid)) {
           await new Promise((r) => setTimeout(r, 50));
         }
-        if (isAlive(pid)) {
+        if (isAlive2(pid)) {
           try {
             process.kill(pid, "SIGKILL");
           } catch {
           }
         }
       }
-      await fsp3.unlink(pidPath).catch(() => void 0);
+      await fsp6.unlink(pidPath).catch(() => void 0);
     }
   }
   spawn(entry, attempt) {
@@ -6179,46 +7824,49 @@ var ExtensionManager = class {
     }
     const ctx = this.context;
     if (!ctx) {
-      throw new Error("ExtensionManager.spawn called before setContext");
+      throw new Error("TransformerManager.spawn called before setContext");
     }
-    const ext = entry.config;
-    const command = ext.command.length > 0 ? ext.command : [ext.name];
-    const logStream = fs11.createWriteStream(paths.extensionLogFile(ext.name), {
+    const t = entry.config;
+    const command = t.command.length > 0 ? t.command : [t.name];
+    const logStream = fs12.createWriteStream(paths.transformerLogFile(t.name), {
       flags: "a"
     });
     logStream.write(
-      `[hydra-acp] ${(/* @__PURE__ */ new Date()).toISOString()} starting extension ${ext.name} (attempt ${attempt + 1})
+      `[hydra-acp] ${(/* @__PURE__ */ new Date()).toISOString()} starting transformer ${t.name} (attempt ${attempt + 1})
 `
     );
+    const processToken = this.tokenRegistry?.mint(t.name, "transformer") ?? ctx.serviceToken;
+    entry.processToken = processToken;
+    entry.version = void 0;
     const env = {
       ...process.env,
       HYDRA_ACP_DAEMON_URL: ctx.daemonUrl,
       HYDRA_ACP_DAEMON_HOST: ctx.daemonHost,
       HYDRA_ACP_DAEMON_PORT: String(ctx.daemonPort),
-      HYDRA_ACP_TOKEN: ctx.serviceToken,
+      HYDRA_ACP_TOKEN: processToken,
       HYDRA_ACP_WS_URL: ctx.daemonWsUrl,
       HYDRA_ACP_HOME: ctx.hydraHome,
-      HYDRA_ACP_EXTENSION_NAME: ext.name,
-      ...ext.env
+      HYDRA_ACP_TRANSFORMER_NAME: t.name,
+      ...t.env
     };
     const [cmd, ...baseArgs] = command;
     if (cmd === void 0) {
-      logStream.write(`[hydra-acp] extension ${ext.name} has empty command
+      logStream.write(`[hydra-acp] transformer ${t.name} has empty command
 `);
       logStream.end();
       return;
     }
-    const args = [...baseArgs, ...ext.args];
+    const args = [...baseArgs, ...t.args];
     let child;
     try {
-      child = spawn4(cmd, args, {
+      child = spawn5(cmd, args, {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: false
       });
     } catch (err) {
       logStream.write(
-        `[hydra-acp] failed to spawn ${ext.name}: ${err.message}
+        `[hydra-acp] failed to spawn ${t.name}: ${err.message}
 `
       );
       logStream.end();
@@ -6233,14 +7881,14 @@ var ExtensionManager = class {
     }
     if (typeof child.pid === "number") {
       try {
-        fs11.writeFileSync(paths.extensionPidFile(ext.name), `${child.pid}
+        fs12.writeFileSync(paths.transformerPidFile(t.name), `${child.pid}
 `, {
           encoding: "utf8",
           mode: 384
         });
       } catch (err) {
         logStream.write(
-          `[hydra-acp] failed to write pid file for ${ext.name}: ${err.message}
+          `[hydra-acp] failed to write pid file for ${t.name}: ${err.message}
 `
         );
       }
@@ -6252,22 +7900,26 @@ var ExtensionManager = class {
     entry.lastExitCode = void 0;
     child.on("error", (err) => {
       logStream.write(
-        `[hydra-acp] extension ${ext.name} error: ${err.message}
+        `[hydra-acp] transformer ${t.name} error: ${err.message}
 `
       );
     });
     child.on("exit", (code, signal) => {
       try {
-        fs11.unlinkSync(paths.extensionPidFile(ext.name));
+        fs12.unlinkSync(paths.transformerPidFile(t.name));
       } catch {
       }
       logStream.write(
-        `[hydra-acp] extension ${ext.name} exited code=${code ?? "null"} signal=${signal ?? "null"}
+        `[hydra-acp] transformer ${t.name} exited code=${code ?? "null"} signal=${signal ?? "null"}
 `
       );
       entry.child = void 0;
       entry.pid = void 0;
       entry.lastExitCode = typeof code === "number" ? code : void 0;
+      if (entry.processToken) {
+        this.tokenRegistry?.revoke(t.name);
+        entry.processToken = void 0;
+      }
       const waiters = entry.exitWaiters.splice(0);
       for (const resolve3 of waiters) {
         resolve3();
@@ -6289,8 +7941,8 @@ var ExtensionManager = class {
       return;
     }
     const delay = Math.min(
-      RESTART_BASE_MS * 2 ** Math.min(attempt, 10),
-      RESTART_CAP_MS
+      RESTART_BASE_MS2 * 2 ** Math.min(attempt, 10),
+      RESTART_CAP_MS2
     );
     entry.restartTimer = setTimeout(() => {
       entry.restartTimer = void 0;
@@ -6301,7 +7953,7 @@ var ExtensionManager = class {
     }
   }
 };
-function isAlive(pid) {
+function isAlive2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -6309,14 +7961,14 @@ function isAlive(pid) {
     return false;
   }
 }
-function withCode2(err, code) {
+function withCode3(err, code) {
   err.code = code;
   return err;
 }
 
 // src/core/agent-prune.ts
-import * as fsp4 from "fs/promises";
-import * as path8 from "path";
+import * as fsp7 from "fs/promises";
+import * as path9 from "path";
 var logSink3 = (msg) => {
   process.stderr.write(msg + "\n");
 };
@@ -6334,10 +7986,10 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
     desiredByAgent.set(a.id, a.version ?? "current");
   }
   const activeByAgent = sessionManager.activeAgentVersions();
-  const platformDir = path8.join(paths.agentsDir(), platformKey);
+  const platformDir = path9.join(paths.agentsDir(), platformKey);
   let agentEntries;
   try {
-    agentEntries = await fsp4.readdir(platformDir, { withFileTypes: true });
+    agentEntries = await fsp7.readdir(platformDir, { withFileTypes: true });
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -6356,10 +8008,10 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
       continue;
     }
     const activeVersions = activeByAgent.get(agentId) ?? /* @__PURE__ */ new Set();
-    const agentDir = path8.join(platformDir, agentId);
+    const agentDir = path9.join(platformDir, agentId);
     let versionEntries;
     try {
-      versionEntries = await fsp4.readdir(agentDir, { withFileTypes: true });
+      versionEntries = await fsp7.readdir(agentDir, { withFileTypes: true });
     } catch (err) {
       logSink3(
         `hydra-acp: prune: failed to read ${agentDir}: ${err.message}`
@@ -6380,9 +8032,9 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
       if (version.includes(".partial-")) {
         continue;
       }
-      const versionDir = path8.join(agentDir, version);
+      const versionDir = path9.join(agentDir, version);
       try {
-        await fsp4.rm(versionDir, { recursive: true, force: true });
+        await fsp7.rm(versionDir, { recursive: true, force: true });
         logSink3(`hydra-acp: pruned stale ${agentId} ${version} (${versionDir})`);
       } catch (err) {
         logSink3(
@@ -6394,8 +8046,8 @@ async function pruneStaleAgentVersions(registry, sessionManager) {
 }
 
 // src/core/session-tokens.ts
-import * as fs12 from "fs/promises";
-import * as path9 from "path";
+import * as fs13 from "fs/promises";
+import * as path10 from "path";
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
 var TOKEN_PREFIX = "hydra_session_";
 var DEFAULT_TTL_SEC = 60 * 60 * 24 * 30;
@@ -6403,7 +8055,7 @@ var ID_LENGTH = 12;
 var TOKEN_BYTES = 32;
 var WRITE_DEBOUNCE_MS = 50;
 function tokensFilePath() {
-  return path9.join(paths.home(), "session-tokens.json");
+  return path10.join(paths.home(), "session-tokens.json");
 }
 function sha256Hex(input) {
   return createHash("sha256").update(input).digest("hex");
@@ -6430,7 +8082,7 @@ var SessionTokenStore = class _SessionTokenStore {
   static async load() {
     let records = [];
     try {
-      const raw = await fs12.readFile(tokensFilePath(), "utf8");
+      const raw = await fs13.readFile(tokensFilePath(), "utf8");
       const parsed = JSON.parse(raw);
       if (parsed && Array.isArray(parsed.records)) {
         records = parsed.records.filter(isRecord);
@@ -6558,8 +8210,8 @@ var SessionTokenStore = class _SessionTokenStore {
     const records = Array.from(this.records.values());
     const payload = JSON.stringify({ records }, null, 2) + "\n";
     this.writeInflight = (async () => {
-      await fs12.mkdir(paths.home(), { recursive: true });
-      await fs12.writeFile(tokensFilePath(), payload, {
+      await fs13.mkdir(paths.home(), { recursive: true });
+      await fs13.writeFile(tokensFilePath(), payload, {
         encoding: "utf8",
         mode: 384
       });
@@ -6655,6 +8307,34 @@ function tokenFromUpgradeRequest(req) {
   }
   return void 0;
 }
+var ProcessTokenRegistry = class {
+  tokens = /* @__PURE__ */ new Map();
+  mint(name, kind) {
+    const token = generateServiceToken();
+    this.tokens.set(token, { name, kind });
+    return token;
+  }
+  // Revoke all tokens associated with the named process. Called when a
+  // process exits or is unregistered so stale tokens can't be reused if a
+  // new process happens to reconnect before a full daemon restart.
+  revoke(name) {
+    for (const [token, identity] of this.tokens) {
+      if (identity.name === name) {
+        this.tokens.delete(token);
+      }
+    }
+  }
+  resolve(token) {
+    return this.tokens.get(token);
+  }
+  async validate(token) {
+    const identity = this.tokens.get(token);
+    if (!identity) {
+      return void 0;
+    }
+    return `${identity.kind}:${identity.name}`;
+  }
+};
 function constantTimeEqual(a, b) {
   if (a.length !== b.length) {
     return false;
@@ -6739,7 +8419,13 @@ var Bundle = z5.object({
   exportedAt: z5.string(),
   exportedFrom: z5.object({
     hydraVersion: z5.string(),
-    machine: z5.string()
+    machine: z5.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: z5.string().optional()
   }),
   session: BundleSession,
   history: z5.array(HistoryEntrySchema),
@@ -6751,7 +8437,8 @@ function encodeBundle(params) {
     exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
     exportedFrom: {
       hydraVersion: params.hydraVersion,
-      machine: params.machine
+      machine: params.machine,
+      ...params.hydraHost !== void 0 && params.hydraHost.length > 0 ? { hydraHost: params.hydraHost } : {}
     },
     session: {
       sessionId: params.record.sessionId,
@@ -7095,7 +8782,7 @@ function isUpstreamInterrupted(u, errorText) {
 }
 function mapPlan(u) {
   const entries = u.entries;
-  if (!Array.isArray(entries)) {
+  if (!Array.isArray(entries) || entries.length === 0) {
     return null;
   }
   const normalized = [];
@@ -7131,7 +8818,15 @@ function mapModel(u) {
   if (!model) {
     return null;
   }
-  return { kind: "model-changed", model: sanitizeSingleLine(model) };
+  const raw = u.availableModels;
+  const availableModels = Array.isArray(raw) ? raw.map(
+    (m) => typeof m === "object" && m !== null ? m.modelId : typeof m === "string" ? m : void 0
+  ).filter((id) => typeof id === "string" && id.length > 0) : void 0;
+  return {
+    kind: "model-changed",
+    model: sanitizeSingleLine(model),
+    ...availableModels && availableModels.length > 0 ? { availableModels } : {}
+  };
 }
 function mapTurnComplete(u) {
   const stopReason = readString(u, "stopReason");
@@ -7431,7 +9126,21 @@ function formatNumber(n) {
   return n.toLocaleString("en-US");
 }
 
+// src/core/remote-url.ts
+function isLoopbackHost(host) {
+  return host === "127.0.0.1" || host === "::1" || host === "localhost" || host === "[::1]";
+}
+
 // src/daemon/routes/sessions.ts
+function resolveHydraHost(defaults) {
+  if (defaults.publicHost && defaults.publicHost.length > 0) {
+    return defaults.publicHost;
+  }
+  if (defaults.host && !isLoopbackHost(defaults.host)) {
+    return defaults.port !== void 0 ? `${defaults.host}:${defaults.port}` : defaults.host;
+  }
+  return void 0;
+}
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
     const query = request.query;
@@ -7531,7 +9240,8 @@ function registerSessionRoutes(app, manager, defaults) {
       history: exported.history,
       promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
       hydraVersion: HYDRA_VERSION,
-      machine: os3.hostname()
+      machine: os3.hostname(),
+      hydraHost: resolveHydraHost(defaults)
     });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     reply.header(
@@ -7553,7 +9263,8 @@ function registerSessionRoutes(app, manager, defaults) {
       history: exported.history,
       promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
       hydraVersion: HYDRA_VERSION,
-      machine: os3.hostname()
+      machine: os3.hostname(),
+      hydraHost: resolveHydraHost(defaults)
     });
     reply.header("Content-Type", "text/markdown; charset=utf-8");
     reply.code(200).send(bundleToMarkdown(bundle));
@@ -7866,6 +9577,122 @@ function parseRegisterBody(body) {
   };
 }
 
+// src/daemon/routes/transformers.ts
+var NAME_RE2 = /^[A-Za-z0-9._-]+$/;
+function registerTransformerRoutes(app, transformers) {
+  app.get("/v1/transformers", async () => {
+    return { transformers: transformers.list() };
+  });
+  app.get("/v1/transformers/:name", async (request, reply) => {
+    const name = request.params.name;
+    const info = transformers.get(name);
+    if (!info) {
+      reply.code(404).send({ error: `unknown transformer: ${name}` });
+      return;
+    }
+    return info;
+  });
+  app.post("/v1/transformers", async (request, reply) => {
+    const body = request.body ?? {};
+    const parsed = parseRegisterBody2(body);
+    if ("error" in parsed) {
+      reply.code(400).send({ error: parsed.error });
+      return;
+    }
+    try {
+      const info = transformers.register(parsed.config);
+      reply.code(201).send(info);
+    } catch (err) {
+      sendError2(reply, err);
+    }
+  });
+  app.delete("/v1/transformers/:name", async (request, reply) => {
+    const name = request.params.name;
+    try {
+      await transformers.unregister(name);
+      reply.code(204).send();
+    } catch (err) {
+      sendError2(reply, err);
+    }
+  });
+  app.post("/v1/transformers/:name/start", async (request, reply) => {
+    const name = request.params.name;
+    try {
+      const info = await transformers.startByName(name);
+      reply.code(200).send(info);
+    } catch (err) {
+      sendError2(reply, err);
+    }
+  });
+  app.post("/v1/transformers/:name/stop", async (request, reply) => {
+    const name = request.params.name;
+    try {
+      const info = await transformers.stopByName(name);
+      reply.code(200).send(info);
+    } catch (err) {
+      sendError2(reply, err);
+    }
+  });
+  app.post("/v1/transformers/:name/restart", async (request, reply) => {
+    const name = request.params.name;
+    try {
+      const info = await transformers.restartByName(name);
+      reply.code(200).send(info);
+    } catch (err) {
+      sendError2(reply, err);
+    }
+  });
+}
+function sendError2(reply, err) {
+  const code = err.code;
+  const message = err.message ?? "unknown error";
+  if (code === "NOT_FOUND") {
+    reply.code(404).send({ error: message });
+    return;
+  }
+  if (code === "CONFLICT") {
+    reply.code(409).send({ error: message });
+    return;
+  }
+  reply.code(500).send({ error: message });
+}
+function parseRegisterBody2(body) {
+  const name = body.name;
+  if (typeof name !== "string" || !NAME_RE2.test(name)) {
+    return { error: "name must match [A-Za-z0-9._-]+" };
+  }
+  const command = body.command;
+  if (command !== void 0 && (!Array.isArray(command) || command.some((c) => typeof c !== "string"))) {
+    return { error: "command must be string[]" };
+  }
+  const args = body.args;
+  if (args !== void 0 && (!Array.isArray(args) || args.some((a) => typeof a !== "string"))) {
+    return { error: "args must be string[]" };
+  }
+  const env = body.env;
+  if (env !== void 0 && (typeof env !== "object" || env === null || Array.isArray(env))) {
+    return { error: "env must be an object of string\u2192string" };
+  }
+  if (env && Object.values(env).some(
+    (v) => typeof v !== "string"
+  )) {
+    return { error: "env values must be strings" };
+  }
+  const enabled = body.enabled;
+  if (enabled !== void 0 && typeof enabled !== "boolean") {
+    return { error: "enabled must be a boolean" };
+  }
+  return {
+    config: {
+      name,
+      command: command ?? [],
+      args: args ?? [],
+      env: env ?? {},
+      enabled: enabled === void 0 ? true : enabled
+    }
+  };
+}
+
 // src/daemon/routes/config.ts
 function registerConfigRoutes(app, defaults) {
   app.get("/v1/config", async () => {
@@ -7880,19 +9707,19 @@ function registerConfigRoutes(app, defaults) {
 import { z as z6 } from "zod";
 
 // src/core/password.ts
-import * as fs13 from "fs/promises";
-import * as path10 from "path";
+import * as fs14 from "fs/promises";
+import * as path11 from "path";
 import { randomBytes as randomBytes2, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { promisify } from "util";
 var scryptAsync = promisify(scrypt);
 function passwordHashPath() {
-  return path10.join(paths.home(), "password-hash");
+  return path11.join(paths.home(), "password-hash");
 }
 var DEFAULT_N = 1 << 15;
 var MAX_MEM = 128 * 1024 * 1024;
 async function hasPassword() {
   try {
-    const text = await fs13.readFile(passwordHashPath(), "utf8");
+    const text = await fs14.readFile(passwordHashPath(), "utf8");
     return text.trim().length > 0;
   } catch (err) {
     const e = err;
@@ -7908,7 +9735,7 @@ async function verifyPassword(plaintext) {
   }
   let line;
   try {
-    line = (await fs13.readFile(passwordHashPath(), "utf8")).trim();
+    line = (await fs14.readFile(passwordHashPath(), "utf8")).trim();
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -8102,6 +9929,8 @@ function wsToMessageStream(ws) {
 }
 
 // src/daemon/acp-ws.ts
+import * as os4 from "os";
+import * as path12 from "path";
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, async (socket, request) => {
     const token = tokenFromUpgradeRequest({
@@ -8112,10 +9941,12 @@ function registerAcpWsEndpoint(app, deps) {
       socket.close(4401, "Unauthorized");
       return;
     }
+    const processIdentity = deps.processRegistry?.resolve(token);
     const stream = wsToMessageStream(socket);
     const connection = new JsonRpcConnection(stream);
     const state = {
       clientId: `hydra_client_${nanoid2(12)}`,
+      processIdentity,
       attached: /* @__PURE__ */ new Map()
     };
     connection.onClose(() => {
@@ -8136,14 +9967,158 @@ function registerAcpWsEndpoint(app, deps) {
       }
     };
     connection.onRequest("initialize", async (raw) => {
-      InitializeParams.parse(raw ?? {});
+      const params = InitializeParams.parse(raw ?? {});
+      const version = params.clientInfo?.version;
+      if (version && processIdentity) {
+        if (processIdentity.kind === "extension") {
+          deps.onExtensionVersion?.(processIdentity.name, version);
+        } else {
+          deps.onTransformerVersion?.(processIdentity.name, version);
+        }
+      }
       return buildInitializeResult();
     });
+    if (processIdentity?.kind === "transformer") {
+      connection.onRequest("transformer/initialize", async (raw) => {
+        const params = raw ?? {};
+        const intercepts = Array.isArray(params.intercepts) ? params.intercepts.filter(
+          (v) => typeof v === "string"
+        ) : [];
+        if (deps.transformers) {
+          deps.transformers.registerConnection(
+            processIdentity.name,
+            connection,
+            intercepts
+          );
+          if (deps.manager?.defaultTransformers.includes(processIdentity.name)) {
+            const ref = deps.transformers.resolveChain([processIdentity.name])[0];
+            if (ref) {
+              for (const session of deps.manager.liveSessions()) {
+                session.addTransformer(ref);
+              }
+            }
+          }
+        }
+        return { ack: true };
+      });
+      connection.onClose(() => {
+        deps.transformers?.deregisterConnection(processIdentity.name);
+      });
+      connection.onRequest("hydra-acp/emit_message", 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;
+        const envelope = params.envelope;
+        const route = params.route;
+        if (!sessionId || !method) {
+          throw Object.assign(new Error("emit_message requires sessionId and method"), { code: -32602 });
+        }
+        const session = deps.manager.get(sessionId);
+        if (!session) {
+          throw Object.assign(new Error(`session ${sessionId} not found`), { code: JsonRpcErrorCodes.SessionNotFound });
+        }
+        const respondsTo = typeof params.respondsTo === "string" ? params.respondsTo : void 0;
+        if (respondsTo) {
+          session.dischargeClaim(respondsTo, envelope);
+          return { ok: true };
+        }
+        if (route === "chain") {
+          await session.emitToChain(processIdentity.name, method, envelope);
+          return { ok: true };
+        }
+        if (route === "daemon") {
+          await session.emitToChain(processIdentity.name, method, envelope);
+          return { ok: true };
+        }
+        throw Object.assign(new Error(`unsupported route: ${JSON.stringify(route)}`), { code: -32602 });
+      });
+      connection.onRequest("hydra-acp/spawn_child_session", 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;
+        const parentSessionId = typeof params.parentSessionId === "string" ? params.parentSessionId : void 0;
+        if (!cwd) {
+          throw Object.assign(new Error("spawn_child_session requires cwd"), { code: -32602 });
+        }
+        const child = await deps.manager.create({
+          agentId,
+          cwd,
+          parentSessionId,
+          transformChain: []
+          // children start with no chain by default
+        });
+        return { childSessionId: child.sessionId };
+      });
+      connection.onRequest("hydra-acp/await_child", async (raw) => {
+        const params = raw ?? {};
+        const childSessionId = typeof params.childSessionId === "string" ? params.childSessionId : void 0;
+        const until = params.until === "idle" ? "idle" : "turn_complete";
+        const timeoutMs = typeof params.timeoutMs === "number" ? Math.min(params.timeoutMs, 30 * 6e4) : 5 * 6e4;
+        if (!childSessionId) {
+          throw Object.assign(new Error("await_child requires childSessionId"), { code: -32602 });
+        }
+        const child = deps.manager.get(childSessionId);
+        if (!child) {
+          throw Object.assign(
+            new Error(`child session ${childSessionId} not found`),
+            { code: JsonRpcErrorCodes.SessionNotFound }
+          );
+        }
+        return new Promise((resolve3) => {
+          const entries = [];
+          let unsubscribe;
+          const finish = () => {
+            clearTimeout(timer);
+            unsubscribe?.();
+            resolve3({ entries });
+          };
+          unsubscribe = child.onBroadcast((entry) => {
+            entries.push(entry);
+            if (until === "turn_complete") {
+              const upd = entry.params?.update;
+              if (upd?.sessionUpdate === "turn_complete") {
+                finish();
+              }
+            }
+          });
+          const timer = setTimeout(finish, timeoutMs);
+          if (typeof timer.unref === "function") {
+            timer.unref();
+          }
+          child.onClose(() => finish());
+        });
+      });
+      connection.onRequest("hydra-acp/close_child_session", async (raw) => {
+        const params = raw ?? {};
+        const childSessionId = typeof params.childSessionId === "string" ? params.childSessionId : void 0;
+        if (!childSessionId) {
+          throw Object.assign(new Error("close_child_session requires childSessionId"), { code: -32602 });
+        }
+        const child = deps.manager.get(childSessionId);
+        if (child) {
+          await child.close({ deleteRecord: false });
+        }
+        return { ok: true };
+      });
+      connection.onRequest("hydra-acp/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;
+        const estimatedRemainingMs = typeof params.estimatedRemainingMs === "number" ? params.estimatedRemainingMs : void 0;
+        if (token2 && sessionId) {
+          const session = deps.manager.get(sessionId);
+          session?.keepAliveClaim(token2, estimatedRemainingMs);
+        }
+        return { ok: true };
+      });
+    }
     connection.onRequest("session/new", async (raw) => {
       const params = SessionNewParams.parse(raw);
       const hydraMeta = extractHydraMeta(
         raw?._meta
       );
+      const transformerNames = Array.isArray(hydraMeta.transformers) && hydraMeta.transformers.every((t) => typeof t === "string") ? hydraMeta.transformers : deps.manager.defaultTransformers ?? [];
+      const transformChain = deps.transformers?.resolveChain(transformerNames) ?? [];
       const session = await deps.manager.create({
         cwd: params.cwd,
         agentId: params.agentId ?? deps.defaultAgent,
@@ -8151,7 +10126,8 @@ function registerAcpWsEndpoint(app, deps) {
         title: hydraMeta.name,
         agentArgs: hydraMeta.agentArgs,
         model: hydraMeta.model,
-        onInstallProgress: makeInstallProgressForwarder(connection)
+        onInstallProgress: makeInstallProgressForwarder(connection),
+        transformChain
       });
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "full");
@@ -8183,6 +10159,14 @@ function registerAcpWsEndpoint(app, deps) {
     });
     connection.onRequest("session/attach", async (raw) => {
       const params = SessionAttachParams.parse(raw);
+      const attachVersion = params.clientInfo?.version;
+      if (attachVersion && processIdentity) {
+        if (processIdentity.kind === "extension") {
+          deps.onExtensionVersion?.(processIdentity.name, attachVersion);
+        } else {
+          deps.onTransformerVersion?.(processIdentity.name, attachVersion);
+        }
+      }
       const hydraHints = extractHydraMeta(params._meta).resume;
       const readonly = params.readonly === true;
       app.log.info(
@@ -8229,16 +10213,13 @@ function registerAcpWsEndpoint(app, deps) {
         let resurrectParams = fromDisk;
         if (hydraHints) {
           resurrectParams = {
+            ...fromDisk,
             hydraSessionId: params.sessionId,
             upstreamSessionId: hydraHints.upstreamSessionId,
             agentId: hydraHints.agentId,
             cwd: hydraHints.cwd,
-            title: hydraHints.title ?? fromDisk?.title,
-            agentArgs: hydraHints.agentArgs ?? fromDisk?.agentArgs,
-            currentModel: fromDisk?.currentModel,
-            currentMode: fromDisk?.currentMode,
-            agentCommands: fromDisk?.agentCommands,
-            createdAt: fromDisk?.createdAt
+            ...hydraHints.title !== void 0 ? { title: hydraHints.title } : {},
+            ...hydraHints.agentArgs !== void 0 ? { agentArgs: hydraHints.agentArgs } : {}
           };
         }
         if (!resurrectParams) {
@@ -8252,6 +10233,7 @@ function registerAcpWsEndpoint(app, deps) {
           ...resurrectParams,
           onInstallProgress: makeInstallProgressForwarder(connection)
         });
+        wireDefaultTransformers(session, deps);
       }
       const client = bindClientToSession(
         connection,
@@ -8341,6 +10323,7 @@ function registerAcpWsEndpoint(app, deps) {
           `session/prompt auto-resurrecting cold sessionId=${params.sessionId}`
         );
         session = await deps.manager.resurrect(fromDisk);
+        wireDefaultTransformers(session, deps);
         const client = bindClientToSession(
           connection,
           session,
@@ -8428,6 +10411,51 @@ function registerAcpWsEndpoint(app, deps) {
       }
       return session.amendPrompt(att.clientId, params);
     });
+    connection.onRequest("hydra-acp/stream_open", async (raw) => {
+      const params = StreamOpenParams.parse(raw);
+      denyIfReadonly(params.sessionId, "hydra-acp/stream_open");
+      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) => path12.join(os4.tmpdir(), `hydra-stdin-${sid}.log`);
+      }
+      return session.openStream(openOpts);
+    });
+    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`);
+        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);
+    });
     connection.onRequest("session/load", async (raw) => {
       const rawObj = raw ?? {};
       const rawSessionId = typeof rawObj.sessionId === "string" ? rawObj.sessionId : void 0;
@@ -8448,6 +10476,7 @@ function registerAcpWsEndpoint(app, deps) {
           throw err;
         }
         session = await deps.manager.resurrect(fromDisk);
+        wireDefaultTransformers(session, deps);
       }
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "pending_only");
@@ -8498,6 +10527,32 @@ function registerAcpWsEndpoint(app, deps) {
       app.log.info(decision.logMessage);
       return decision.session.forwardRequest("session/set_model", rawParams);
     });
+    connection.onRequest("session/set_mode", async (rawParams) => {
+      const params = rawParams;
+      const sessionIdField = params?.sessionId;
+      if (typeof sessionIdField === "string") {
+        denyIfReadonly(sessionIdField, "session/set_mode");
+      }
+      if (!params || typeof params.sessionId !== "string") {
+        const err = new Error("session/set_mode requires string sessionId");
+        err.code = JsonRpcErrorCodes.InvalidParams;
+        throw err;
+      }
+      if (typeof params.modeId !== "string") {
+        const err = new Error("session/set_mode requires string modeId");
+        err.code = JsonRpcErrorCodes.InvalidParams;
+        throw err;
+      }
+      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 result = await session.forwardRequest("session/set_mode", rawParams);
+      session.applyModeChange(params.modeId);
+      return result;
+    });
     connection.setDefaultHandler(async (rawParams, method) => {
       if (!method.startsWith("session/") || rawParams === null || typeof rawParams !== "object") {
         const err = new Error(`Method not found: ${method}`);
@@ -8717,6 +10772,9 @@ function buildResponseMeta(session) {
   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;
@@ -8767,6 +10825,17 @@ function buildInitializeResult() {
     })
   };
 }
+function wireDefaultTransformers(session, deps) {
+  if (!deps.transformers || !deps.manager) {
+    return;
+  }
+  for (const name of deps.manager.defaultTransformers) {
+    const ref = deps.transformers.resolveChain([name])[0];
+    if (ref) {
+      session.addTransformer(ref);
+    }
+  }
+}
 function bindClientToSession(connection, session, state, clientInfo, callerClientId) {
   void state;
   void session;
@@ -8781,10 +10850,10 @@ function bindClientToSession(connection, session, state, clientInfo, callerClien
 async function startDaemon(config, serviceToken) {
   ensureLoopbackOrTls(config);
   const httpsOptions = config.daemon.tls ? {
-    key: await fsp5.readFile(config.daemon.tls.key),
-    cert: await fsp5.readFile(config.daemon.tls.cert)
+    key: await fsp8.readFile(config.daemon.tls.key),
+    cert: await fsp8.readFile(config.daemon.tls.cert)
   } : void 0;
-  await fsp5.mkdir(paths.home(), { recursive: true });
+  await fsp8.mkdir(paths.home(), { recursive: true });
   const { stream: logStream, fileStream } = await buildLogStream(
     config.daemon.logLevel
   );
@@ -8809,9 +10878,11 @@ async function startDaemon(config, serviceToken) {
   });
   const sessionTokenStore = await SessionTokenStore.load();
   const authRateLimiter = new AuthRateLimiter();
+  const processRegistry = new ProcessTokenRegistry();
   const validator = new CompositeTokenValidator([
     new StaticTokenValidator(serviceToken),
-    new SessionTokenValidator(sessionTokenStore)
+    new SessionTokenValidator(sessionTokenStore),
+    processRegistry
   ]);
   const auth = bearerAuth({ validator });
   app.addHook("onRequest", async (request, reply) => {
@@ -8848,18 +10919,28 @@ async function startDaemon(config, serviceToken) {
   const manager = new SessionManager(registry, spawner, void 0, {
     idleTimeoutMs: config.daemon.sessionIdleTimeoutSeconds * 1e3,
     defaultModels: config.defaultModels,
+    defaultTransformers: config.defaultTransformers,
     sessionHistoryMaxEntries: config.daemon.sessionHistoryMaxEntries,
     logger: agentLogger,
     npmRegistry: config.npmRegistry
   });
-  const extensions = new ExtensionManager(extensionList(config));
+  const extensions = new ExtensionManager(extensionList(config), void 0, {
+    tokenRegistry: processRegistry
+  });
+  const transformers = new TransformerManager(transformerList(config), void 0, {
+    tokenRegistry: processRegistry
+  });
   registerHealthRoutes(app, HYDRA_VERSION);
   registerSessionRoutes(app, manager, {
     agentId: config.defaultAgent,
-    cwd: config.defaultCwd
+    cwd: config.defaultCwd,
+    publicHost: config.daemon.publicHost,
+    host: config.daemon.host,
+    port: config.daemon.port
   });
   registerAgentRoutes(app, registry, manager, { npmRegistry: config.npmRegistry });
   registerExtensionRoutes(app, extensions);
+  registerTransformerRoutes(app, transformers);
   registerConfigRoutes(app, {
     defaultAgent: config.defaultAgent,
     defaultCwd: config.defaultCwd
@@ -8871,13 +10952,17 @@ async function startDaemon(config, serviceToken) {
   registerAcpWsEndpoint(app, {
     validator,
     manager,
-    defaultAgent: config.defaultAgent
+    defaultAgent: config.defaultAgent,
+    processRegistry,
+    onExtensionVersion: (name, version) => extensions.reportVersion(name, version),
+    onTransformerVersion: (name, version) => transformers.reportVersion(name, version),
+    transformers
   });
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();
   const boundPort = address && typeof address === "object" ? address.port : config.daemon.port;
-  await fsp5.mkdir(paths.home(), { recursive: true });
-  await fsp5.writeFile(
+  await fsp8.mkdir(paths.home(), { recursive: true });
+  await fsp8.writeFile(
     paths.pidFile(),
     JSON.stringify({
       pid: process.pid,
@@ -8889,15 +10974,18 @@ async function startDaemon(config, serviceToken) {
   );
   const scheme = config.daemon.tls ? "https" : "http";
   const wsScheme = config.daemon.tls ? "wss" : "ws";
-  extensions.setContext({
+  const processContext = {
     daemonUrl: `${scheme}://${config.daemon.host}:${boundPort}`,
     daemonHost: config.daemon.host,
     daemonPort: boundPort,
     serviceToken,
     daemonWsUrl: `${wsScheme}://${config.daemon.host}:${boundPort}/acp`,
     hydraHome: paths.home()
-  });
+  };
+  extensions.setContext(processContext);
+  transformers.setContext(processContext);
   await extensions.start();
+  await transformers.start();
   void manager.resurrectPendingQueues().catch((err) => {
     app.log.warn(
       `queue replay scan failed: ${err.message}`
@@ -8907,6 +10995,7 @@ async function startDaemon(config, serviceToken) {
     clearInterval(sweepInterval);
     await sessionTokenStore.flush();
     await extensions.stop();
+    await transformers.stop();
     await manager.closeAll();
     await manager.flushMetaWrites();
     setBinaryInstallLogger(null);
@@ -8914,7 +11003,7 @@ async function startDaemon(config, serviceToken) {
     setAgentPruneLogger(null);
     await app.close();
     try {
-      fs14.unlinkSync(paths.pidFile());
+      fs15.unlinkSync(paths.pidFile());
     } catch {
     }
     try {
@@ -8922,7 +11011,7 @@ async function startDaemon(config, serviceToken) {
     } catch {
     }
   };
-  return { app, manager, registry, extensions, shutdown };
+  return { app, manager, registry, extensions, transformers, shutdown };
 }
 async function buildLogStream(level) {
   const fileStream = await createPinoRoll({