@hydra-acp/cli 0.1.49 → 0.1.51

package/dist/index.js

@@ -1304,6 +1304,9 @@ function extractHydraMeta(meta) {
   if (typeof obj.promptUpdating === "boolean") {
     out.promptUpdating = obj.promptUpdating;
   }
+  if (typeof obj.mcpStdin === "boolean") {
+    out.mcpStdin = obj.mcpStdin;
+  }
   if (typeof obj.promptAmending === "boolean") {
     out.promptAmending = obj.promptAmending;
   }
@@ -1419,6 +1422,10 @@ var SessionListEntry = z3.object({
   importedFromUpstreamSessionId: z3.string().optional(),
   // Set when this session was spawned as a child by a transformer.
   parentSessionId: z3.string().optional(),
+  // clientInfo from the process that issued session/new. Lets list views
+  // hide cat-style ancillary sessions by default while letting an
+  // override flag surface them.
+  originatingClient: z3.object({ name: z3.string(), version: z3.string().optional() }).optional(),
   updatedAt: z3.string(),
   attachedClients: z3.number().int().nonnegative(),
   status: z3.enum(["live", "cold"]).default("live"),
@@ -2021,14 +2028,30 @@ import { customAlphabet } from "nanoid";
 
 // src/core/stream-buffer.ts
 import * as fsp3 from "fs/promises";
-var DEFAULT_CAPACITY_BYTES = 16 * 1024 * 1024;
+var DEFAULT_CAPACITY_BYTES = 64 * 1024 * 1024;
+var INITIAL_CAPACITY_BYTES = 1 * 1024 * 1024;
 var STREAM_READ_MAX_BYTES = 64 * 1024;
 var STREAM_WAIT_MAX_MS = 6e4;
+var STREAM_GREP_DEFAULT_MATCHES = 100;
+var STREAM_GREP_MAX_MATCHES = 1e3;
+var STREAM_GREP_DEFAULT_BYTES = 64 * 1024;
+var STREAM_GREP_MAX_BYTES = 256 * 1024;
+var STREAM_GREP_MAX_CONTEXT = 20;
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var SessionStreamBuffer = class {
   storage;
-  capacityBytes;
+  // The configured cap. Eviction begins once writeCursor exceeds this.
+  maxCapacityBytes;
+  // The size of the currently-allocated `storage`. Starts at
+  // INITIAL_CAPACITY_BYTES (clamped to maxCapacityBytes) and doubles on
+  // demand. Once it reaches maxCapacityBytes the ring behaves like a
+  // fixed-size buffer; before then, writeCursor < currentCapacityBytes
+  // always, so no wrap-around math is in play.
+  currentCapacityBytes;
   // Absolute monotonic byte offset of the next byte to be written. Also
-  // the count of bytes ever appended. `writeCursor - capacityBytes`
+  // the count of bytes ever appended. `writeCursor - currentCapacityBytes`
   // (clamped at 0) is the oldest still-resident byte's cursor.
   writeCursor = 0;
   closed = false;
@@ -2043,24 +2066,33 @@ var SessionStreamBuffer = class {
   // calls don't interleave their writes.
   fileWriteChain = Promise.resolve();
   constructor(opts = {}) {
-    this.capacityBytes = opts.capacityBytes ?? DEFAULT_CAPACITY_BYTES;
-    if (this.capacityBytes <= 0) {
+    this.maxCapacityBytes = opts.capacityBytes ?? DEFAULT_CAPACITY_BYTES;
+    if (this.maxCapacityBytes <= 0) {
       throw new Error("capacityBytes must be > 0");
     }
-    this.storage = Buffer.alloc(this.capacityBytes);
+    this.currentCapacityBytes = Math.min(
+      INITIAL_CAPACITY_BYTES,
+      this.maxCapacityBytes
+    );
+    this.storage = Buffer.alloc(this.currentCapacityBytes);
     this.filePath = opts.filePath;
     this.fileCapBytes = opts.fileCapBytes ?? Number.POSITIVE_INFINITY;
     this.onFileCapReached = opts.onFileCapReached;
     this.logWriteError = opts.logWriteError;
   }
   get capacity() {
-    return this.capacityBytes;
+    return this.maxCapacityBytes;
+  }
+  // Currently-allocated storage size (for observability / tests). May be
+  // anywhere between INITIAL_CAPACITY_BYTES and capacity.
+  get allocatedBytes() {
+    return this.currentCapacityBytes;
   }
   get writeCursorPos() {
     return this.writeCursor;
   }
   get oldestAvailable() {
-    return Math.max(0, this.writeCursor - this.capacityBytes);
+    return Math.max(0, this.writeCursor - this.currentCapacityBytes);
   }
   get isClosed() {
     return this.closed;
@@ -2205,6 +2237,136 @@ var SessionStreamBuffer = class {
       this.waiters.push(waiter);
     });
   }
+  // Scan the resident region line-by-line, returning lines that match
+  // `pattern`. Server-side filtering so the agent doesn't have to pull
+  // and decode 64 KiB base64 windows just to grep a multi-MB log.
+  //
+  // Lines are split on `\n` (LF). A trailing partial line (no LF) is
+  // skipped when the buffer is still open — its bytes might be the
+  // start of a longer line that's still being written — but is treated
+  // as a final full line once the buffer is closed.
+  //
+  // Caps: max 1000 matches and 256 KiB of output bytes per call. The
+  // agent should re-call with `cursor = nextCursor` to resume when
+  // `truncated:true`.
+  grep(opts) {
+    const oldest = this.oldestAvailable;
+    const requested = opts.cursor;
+    let start = requested ?? oldest;
+    let gap = 0;
+    if (requested !== void 0 && requested < oldest) {
+      gap = oldest - requested;
+      start = oldest;
+    }
+    if (start > this.writeCursor) {
+      start = this.writeCursor;
+    }
+    const slice = this.sliceFromRing(start, this.writeCursor - start);
+    const useRegex = opts.regex ?? true;
+    const flags = opts.caseInsensitive === true ? "i" : "";
+    const re = useRegex ? new RegExp(opts.pattern, flags) : new RegExp(escapeRegex(opts.pattern), flags);
+    const invert = opts.invert ?? false;
+    const maxMatches = Math.max(
+      1,
+      Math.min(
+        opts.maxMatches ?? STREAM_GREP_DEFAULT_MATCHES,
+        STREAM_GREP_MAX_MATCHES
+      )
+    );
+    const maxBytes = Math.max(
+      1,
+      Math.min(opts.maxBytes ?? STREAM_GREP_DEFAULT_BYTES, STREAM_GREP_MAX_BYTES)
+    );
+    const contextBefore = Math.max(
+      0,
+      Math.min(opts.contextBefore ?? 0, STREAM_GREP_MAX_CONTEXT)
+    );
+    const contextAfter = Math.max(
+      0,
+      Math.min(opts.contextAfter ?? 0, STREAM_GREP_MAX_CONTEXT)
+    );
+    const matches = [];
+    const beforeRing = [];
+    const pendingAfter = [];
+    let bytesUsed = 0;
+    let truncated = false;
+    let lineStartByte = 0;
+    let resumeFromLineStart = 0;
+    const processLine = (lineCursor, lineText) => {
+      for (const pa of pendingAfter) {
+        if (pa.remaining > 0) {
+          if (pa.match.after === void 0) {
+            pa.match.after = [];
+          }
+          pa.match.after.push({ cursor: lineCursor, line: lineText });
+          pa.remaining--;
+          bytesUsed += lineText.length;
+        }
+      }
+      while (pendingAfter.length > 0 && pendingAfter[0].remaining === 0) {
+        pendingAfter.shift();
+      }
+      const matched = re.test(lineText) !== invert;
+      if (matched && matches.length < maxMatches) {
+        const m = { cursor: lineCursor, line: lineText };
+        if (contextBefore > 0 && beforeRing.length > 0) {
+          m.before = beforeRing.slice();
+          for (const b of m.before) {
+            bytesUsed += b.line.length;
+          }
+        }
+        bytesUsed += lineText.length;
+        matches.push(m);
+        if (contextAfter > 0) {
+          pendingAfter.push({ match: m, remaining: contextAfter });
+        }
+      }
+      if (contextBefore > 0) {
+        beforeRing.push({ cursor: lineCursor, line: lineText });
+        while (beforeRing.length > contextBefore) {
+          beforeRing.shift();
+        }
+      }
+      const hitMaxMatches = matches.length >= maxMatches && pendingAfter.length === 0;
+      const hitMaxBytes = bytesUsed >= maxBytes;
+      return hitMaxMatches || hitMaxBytes;
+    };
+    for (let i = 0; i < slice.length; i++) {
+      if (slice[i] !== 10) {
+        continue;
+      }
+      const lineText = slice.subarray(lineStartByte, i).toString("utf8");
+      const lineCursor = start + lineStartByte;
+      lineStartByte = i + 1;
+      resumeFromLineStart = lineStartByte;
+      if (processLine(lineCursor, lineText)) {
+        truncated = true;
+        break;
+      }
+    }
+    if (!truncated && lineStartByte < slice.length && this.closed) {
+      const lineText = slice.subarray(lineStartByte).toString("utf8");
+      const lineCursor = start + lineStartByte;
+      if (processLine(lineCursor, lineText)) {
+        truncated = true;
+      }
+      resumeFromLineStart = slice.length;
+    }
+    const nextCursor = Math.min(start + resumeFromLineStart, this.writeCursor);
+    const result = {
+      matches,
+      truncated,
+      nextCursor,
+      scannedBytes: resumeFromLineStart
+    };
+    if (gap > 0) {
+      result.gap = gap;
+    }
+    if (this.closed && nextCursor >= this.writeCursor) {
+      result.eof = true;
+    }
+    return result;
+  }
   wakeWaiters(outcome) {
     if (this.waiters.length === 0) {
       return;
@@ -2215,15 +2377,42 @@ var SessionStreamBuffer = class {
       w.resolve(outcome);
     }
   }
+  // Grow `storage` if needed to fit `additionalBytes` more bytes without
+  // wrapping. Caps at maxCapacityBytes; once we're at the cap, callers
+  // fall back to ring-wrap behavior. Doubles each grow so we amortize.
+  // Only called before we've ever wrapped (writeCursor < currentCapacity
+  // always holds while we're growing), so the existing bytes live at
+  // storage[0..writeCursor] and we can just copy them flat.
+  growIfNeeded(additionalBytes) {
+    if (this.currentCapacityBytes >= this.maxCapacityBytes) {
+      return;
+    }
+    const needed = this.writeCursor + additionalBytes;
+    if (needed <= this.currentCapacityBytes) {
+      return;
+    }
+    let next = this.currentCapacityBytes;
+    while (next < needed && next < this.maxCapacityBytes) {
+      next = Math.min(this.maxCapacityBytes, next * 2);
+    }
+    if (next === this.currentCapacityBytes) {
+      return;
+    }
+    const newStorage = Buffer.alloc(next);
+    this.storage.copy(newStorage, 0, 0, this.writeCursor);
+    this.storage = newStorage;
+    this.currentCapacityBytes = next;
+  }
   writeRing(chunk) {
     const len = chunk.length;
-    if (len >= this.capacityBytes) {
-      const tailStart = len - this.capacityBytes;
+    this.growIfNeeded(len);
+    if (len >= this.currentCapacityBytes) {
+      const tailStart = len - this.currentCapacityBytes;
       chunk.copy(this.storage, 0, tailStart, len);
       return;
     }
-    const offset = this.writeCursor % this.capacityBytes;
-    const tailRoom = this.capacityBytes - offset;
+    const offset = this.writeCursor % this.currentCapacityBytes;
+    const tailRoom = this.currentCapacityBytes - offset;
     if (len <= tailRoom) {
       chunk.copy(this.storage, offset, 0, len);
     } else {
@@ -2236,8 +2425,8 @@ var SessionStreamBuffer = class {
       return Buffer.alloc(0);
     }
     const out = Buffer.alloc(length);
-    const offset = fromCursor % this.capacityBytes;
-    const tailLen = Math.min(length, this.capacityBytes - offset);
+    const offset = fromCursor % this.currentCapacityBytes;
+    const tailLen = Math.min(length, this.currentCapacityBytes - offset);
     this.storage.copy(out, 0, offset, offset + tailLen);
     if (tailLen < length) {
       this.storage.copy(out, tailLen, 0, length - tailLen);
@@ -2379,6 +2568,7 @@ var Session = class {
   agentCapabilities;
   agentArgs;
   parentSessionId;
+  originatingClient;
   title;
   // Snapshot state delivered to attaching clients via the attach
   // response _meta rather than via history replay (which would be
@@ -2533,6 +2723,7 @@ var Session = class {
     this.agentCapabilities = init.agentCapabilities;
     this.agentArgs = init.agentArgs;
     this.parentSessionId = init.parentSessionId;
+    this.originatingClient = init.originatingClient;
     this.title = init.title;
     this.currentModel = init.currentModel;
     this.currentMode = init.currentMode;
@@ -4720,6 +4911,43 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     }
     return out;
   }
+  streamTail(bytes) {
+    const buf = this.requireStreamBuffer();
+    const r = buf.tail(bytes);
+    return {
+      bytes: r.bytes.toString("base64"),
+      startCursor: r.startCursor,
+      endCursor: r.endCursor,
+      truncated: r.truncated
+    };
+  }
+  streamHead(bytes) {
+    const buf = this.requireStreamBuffer();
+    const r = buf.head(bytes);
+    return {
+      bytes: r.bytes.toString("base64"),
+      startCursor: r.startCursor,
+      endCursor: r.endCursor,
+      truncated: r.truncated
+    };
+  }
+  async streamWaitFor(cursor, timeoutMs) {
+    const buf = this.requireStreamBuffer();
+    return buf.waitForData(cursor, timeoutMs);
+  }
+  streamGrep(opts) {
+    const buf = this.requireStreamBuffer();
+    return buf.grep(opts);
+  }
+  streamInfo() {
+    const buf = this.requireStreamBuffer();
+    return {
+      writeCursor: buf.writeCursorPos,
+      oldestAvailable: buf.oldestAvailable,
+      capacity: buf.capacity,
+      closed: buf.isClosed
+    };
+  }
   requireStreamBuffer() {
     if (this.streamBuffer === void 0) {
       const err = new Error(
@@ -5479,6 +5707,10 @@ var PersistedUsage = z4.object({
   costCurrency: z4.string().optional(),
   cumulativeCost: z4.number().optional()
 });
+var PersistedOriginatingClient = z4.object({
+  name: z4.string(),
+  version: z4.string().optional()
+});
 var SessionRecord = z4.object({
   version: z4.literal(1),
   sessionId: z4.string(),
@@ -5529,6 +5761,10 @@ var SessionRecord = z4.object({
   // 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(),
+  // clientInfo from the process that issued session/new. Picker and
+  // `sessions list` use this to hide cat-style ancillary sessions by
+  // default; carried in meta.json so cold sessions filter the same way.
+  originatingClient: PersistedOriginatingClient.optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -5651,6 +5887,7 @@ function recordFromMemorySession(args) {
     agentModels: args.agentModels,
     pendingHistorySync: args.pendingHistorySync,
     parentSessionId: args.parentSessionId,
+    originatingClient: args.originatingClient,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -5939,6 +6176,7 @@ var SessionManager = class {
       agentModels: fresh.initialModels,
       transformChain: params.transformChain,
       parentSessionId: params.parentSessionId,
+      originatingClient: params.originatingClient,
       extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
@@ -6110,6 +6348,7 @@ var SessionManager = class {
       // than stay stuck.
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
+      originatingClient: params.originatingClient,
       extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
@@ -6177,6 +6416,7 @@ var SessionManager = class {
       agentModels: advertisedModels,
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0,
+      originatingClient: params.originatingClient,
       extensionCommands: this.extensionCommands
     });
     await this.attachManagerHooks(session);
@@ -6526,7 +6766,8 @@ var SessionManager = class {
       agentModes: record.agentModes,
       agentModels: record.agentModels,
       createdAt: record.createdAt,
-      pendingHistorySync: record.pendingHistorySync
+      pendingHistorySync: record.pendingHistorySync,
+      originatingClient: record.originatingClient
     };
   }
   async clearPendingHistorySync(sessionId) {
@@ -6627,6 +6868,7 @@ var SessionManager = class {
         currentModel: session.currentModel,
         currentUsage: session.currentUsage,
         parentSessionId: session.parentSessionId,
+        originatingClient: session.originatingClient,
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
@@ -6656,6 +6898,7 @@ var SessionManager = class {
         importedFromMachine: r.importedFromMachine,
         importedFromUpstreamSessionId: r.importedFromUpstreamSessionId,
         parentSessionId: r.parentSessionId,
+        originatingClient: r.originatingClient,
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
@@ -7001,6 +7244,7 @@ function mergeForPersistence(session, existing) {
     agentModes,
     agentModels,
     parentSessionId: session.parentSessionId ?? existing?.parentSessionId,
+    originatingClient: session.originatingClient ?? existing?.originatingClient,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -10590,6 +10834,7 @@ function wsToMessageStream(ws) {
 // src/daemon/acp-ws.ts
 import * as os4 from "os";
 import * as path12 from "path";
+import { randomBytes as randomBytes3 } from "crypto";
 function registerAcpWsEndpoint(app, deps) {
   app.get("/acp", { websocket: true }, async (socket, request) => {
     const token = tokenFromUpgradeRequest({
@@ -10627,6 +10872,12 @@ function registerAcpWsEndpoint(app, deps) {
     };
     connection.onRequest("initialize", async (raw) => {
       const params = InitializeParams.parse(raw ?? {});
+      if (params.clientInfo?.name) {
+        state.clientInfo = {
+          name: params.clientInfo.name,
+          ...params.clientInfo.version !== void 0 ? { version: params.clientInfo.version } : {}
+        };
+      }
       const version = params.clientInfo?.version;
       if (version && processIdentity) {
         if (processIdentity.kind === "extension") {
@@ -10806,16 +11057,50 @@ function registerAcpWsEndpoint(app, deps) {
       );
       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,
-        mcpServers: params.mcpServers,
-        title: hydraMeta.name,
-        agentArgs: hydraMeta.agentArgs,
-        model: hydraMeta.model,
-        onInstallProgress: makeInstallProgressForwarder(connection),
-        transformChain
-      });
+      let stdinToken;
+      let stdinReservation;
+      let augmentedMcpServers = params.mcpServers;
+      if (hydraMeta.mcpStdin === true && deps.stdinMcpRegistry !== void 0 && deps.getDaemonOrigin !== void 0) {
+        stdinToken = randomBytes3(32).toString("hex");
+        stdinReservation = deps.stdinMcpRegistry.reserve(stdinToken);
+        const url = `${deps.getDaemonOrigin()}/mcp/stdin`;
+        const descriptor = {
+          name: "hydra_stdin",
+          type: "http",
+          url,
+          headers: [
+            { name: "Authorization", value: `Bearer ${stdinToken}` }
+          ]
+        };
+        augmentedMcpServers = [...params.mcpServers ?? [], descriptor];
+      }
+      let session;
+      try {
+        session = await deps.manager.create({
+          cwd: params.cwd,
+          agentId: params.agentId ?? deps.defaultAgent,
+          mcpServers: augmentedMcpServers,
+          title: hydraMeta.name,
+          agentArgs: hydraMeta.agentArgs,
+          model: hydraMeta.model,
+          onInstallProgress: makeInstallProgressForwarder(connection),
+          transformChain,
+          originatingClient: state.clientInfo
+        });
+      } catch (err) {
+        if (stdinReservation !== void 0) {
+          stdinReservation.abandon(err instanceof Error ? err : void 0);
+        }
+        throw err;
+      }
+      if (stdinToken !== void 0 && stdinReservation !== void 0 && deps.stdinMcpRegistry !== void 0) {
+        const token2 = stdinToken;
+        const registry = deps.stdinMcpRegistry;
+        stdinReservation.complete(session);
+        session.onClose(() => {
+          void registry.unbind(token2);
+        });
+      }
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
@@ -11536,6 +11821,336 @@ function bindClientToSession(connection, session, state, clientInfo, callerClien
   };
 }
 
+// src/daemon/mcp/stdin-registry.ts
+var StdinMcpRegistry = class {
+  byToken = /* @__PURE__ */ new Map();
+  // Reserve a token slot before the session exists. Used by acp-ws when
+  // we need to inject the bearer into the agent's mcpServers BEFORE
+  // manager.create() returns — claude-acp connects to /mcp/stdin during
+  // session/new initialization (eagerly), so the route handler must be
+  // able to find the token by the time the agent's first request lands.
+  reserve(token) {
+    if (this.byToken.has(token)) {
+      throw new Error(`stdin MCP token already bound`);
+    }
+    let resolveSession;
+    let rejectSession;
+    const sessionReady = new Promise((resolve3, reject) => {
+      resolveSession = resolve3;
+      rejectSession = reject;
+    });
+    sessionReady.catch(() => void 0);
+    const entry = { session: void 0, sessionReady };
+    this.byToken.set(token, entry);
+    return {
+      complete: (session) => {
+        entry.session = session;
+        resolveSession(session);
+      },
+      abandon: (reason) => {
+        this.byToken.delete(token);
+        rejectSession(reason ?? new Error("stdin MCP reservation abandoned"));
+      }
+    };
+  }
+  // Convenience for callers that already have the session in hand (and
+  // for tests). Equivalent to reserve() + complete() back-to-back.
+  bind(token, session) {
+    const { complete } = this.reserve(token);
+    complete(session);
+  }
+  lookup(token) {
+    return this.byToken.get(token);
+  }
+  attachTransport(token, server, transport) {
+    const ep = this.byToken.get(token);
+    if (!ep) {
+      return;
+    }
+    ep.server = server;
+    ep.transport = transport;
+  }
+  async unbind(token) {
+    const ep = this.byToken.get(token);
+    if (!ep) {
+      return;
+    }
+    this.byToken.delete(token);
+    if (ep.transport) {
+      try {
+        await ep.transport.close();
+      } catch {
+      }
+    }
+    if (ep.server) {
+      try {
+        await ep.server.close();
+      } catch {
+      }
+    }
+  }
+  size() {
+    return this.byToken.size;
+  }
+};
+
+// src/daemon/mcp/stdin-server.ts
+import { randomUUID } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z as z7 } from "zod";
+var BEARER_PREFIX2 = "Bearer ";
+function extractBearer(req) {
+  const header = req.headers.authorization;
+  if (typeof header !== "string") {
+    return void 0;
+  }
+  if (!header.startsWith(BEARER_PREFIX2)) {
+    return void 0;
+  }
+  const token = header.slice(BEARER_PREFIX2.length).trim();
+  return token.length > 0 ? token : void 0;
+}
+function buildMcpServer(session) {
+  const server = new McpServer(
+    { name: "hydra-stdin", version: "1.0.0" },
+    {
+      instructions: "Piped input from `hydra cat --stream` is exposed here as a byte stream. Use `tail_stdin` for the latest N bytes (good for finding the end of a log), `head_stdin` for the first N bytes (good for headers/preamble), `read_stdin` for windowed reads against an absolute byte cursor, `wait_for_more` to block until new bytes arrive past a cursor, and `stdin_info` for the current cursors/capacity/closed status. Byte payloads come back base64-encoded."
+    }
+  );
+  server.registerTool(
+    "tail_stdin",
+    {
+      description: "Return the most recent `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means older bytes existed but have been evicted from the ring.",
+      inputSchema: {
+        bytes: z7.number().int().min(1).describe("How many trailing bytes to return.")
+      }
+    },
+    async ({ bytes }) => {
+      const r = session.streamTail(bytes);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  server.registerTool(
+    "head_stdin",
+    {
+      description: "Return the first `bytes` bytes of piped stdin (capped server-side, default 64 KiB max). `truncated:true` means the head has already been evicted from the ring and the returned bytes start at the oldest still-resident cursor.",
+      inputSchema: {
+        bytes: z7.number().int().min(1).describe("How many leading bytes to return.")
+      }
+    },
+    async ({ bytes }) => {
+      const r = session.streamHead(bytes);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  server.registerTool(
+    "read_stdin",
+    {
+      description: "Read up to `max_bytes` bytes starting at absolute byte `cursor`. Returns `{bytes, nextCursor, gap?, eof?}` \u2014 `gap` is the number of bytes silently skipped because the ring had evicted them; `eof:true` means the producer closed and there is nothing left to read.",
+      inputSchema: {
+        cursor: z7.number().int().min(0).describe(
+          "Absolute byte offset to start reading from. Use 0 to read from the very beginning (may produce a gap if old bytes have been evicted)."
+        ),
+        max_bytes: z7.number().int().min(1).optional().describe(
+          "Optional cap on how many bytes to return. Server caps at 64 KiB regardless."
+        ),
+        wait_ms: z7.number().int().min(0).optional().describe(
+          "If no bytes are available, block up to this many ms for more (capped server-side at 60_000)."
+        )
+      }
+    },
+    async ({ cursor, max_bytes, wait_ms }) => {
+      const r = await session.streamRead(cursor, max_bytes, wait_ms);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  server.registerTool(
+    "wait_for_more",
+    {
+      description: "Block until bytes are available past `cursor`, the stream closes, or `timeout_ms` elapses. Returns one of {data, eof, timeout} plus the current `writeCursor`. Use this when you've consumed everything up to a cursor and want to wait for more without busy-polling.",
+      inputSchema: {
+        cursor: z7.number().int().min(0).describe("The cursor you've already consumed up to."),
+        timeout_ms: z7.number().int().min(0).describe("Maximum ms to block (server caps at 60_000).")
+      }
+    },
+    async ({ cursor, timeout_ms }) => {
+      const outcome = await session.streamWaitFor(cursor, timeout_ms);
+      const info = session.streamInfo();
+      const payload = { outcome, writeCursor: info.writeCursor, closed: info.closed };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(payload)
+          }
+        ],
+        structuredContent: payload
+      };
+    }
+  );
+  server.registerTool(
+    "grep_stdin",
+    {
+      description: "Scan piped stdin line-by-line and return lines matching `pattern`. Prefer this over `read_stdin` when the question is 'find lines that mention X' \u2014 it filters server-side so you don't pull and decode 64 KiB base64 windows. Returns `{matches: [{cursor, line, before?, after?}], truncated, nextCursor, gap?, scannedBytes, eof?}`. Lines come back as decoded UTF-8 strings (not base64). When `truncated:true`, re-call with `cursor: nextCursor` to resume.",
+      inputSchema: {
+        pattern: z7.string().min(1).describe(
+          "Search pattern. Treated as a JavaScript regular expression by default (set `regex:false` for a literal substring match)."
+        ),
+        regex: z7.boolean().optional().describe("Default true. Pass false to treat `pattern` as a literal substring."),
+        case_insensitive: z7.boolean().optional().describe("Default false. Pass true for case-insensitive matching."),
+        invert: z7.boolean().optional().describe("Default false. Pass true to return lines that do NOT match the pattern."),
+        max_matches: z7.number().int().min(1).optional().describe("Default 100. Capped server-side at 1000."),
+        max_bytes: z7.number().int().min(1).optional().describe("Default 64 KiB output. Capped server-side at 256 KiB."),
+        context_before: z7.number().int().min(0).optional().describe("Default 0. Number of lines before each match to include (capped at 20)."),
+        context_after: z7.number().int().min(0).optional().describe("Default 0. Number of lines after each match to include (capped at 20)."),
+        cursor: z7.number().int().min(0).optional().describe(
+          "Optional absolute byte offset to start scanning from. Omit to scan from the oldest still-resident byte. Pass the `nextCursor` from a previous truncated call to resume."
+        )
+      }
+    },
+    async (args) => {
+      const opts = { pattern: args.pattern };
+      if (args.regex !== void 0) {
+        opts.regex = args.regex;
+      }
+      if (args.case_insensitive !== void 0) {
+        opts.caseInsensitive = args.case_insensitive;
+      }
+      if (args.invert !== void 0) {
+        opts.invert = args.invert;
+      }
+      if (args.max_matches !== void 0) {
+        opts.maxMatches = args.max_matches;
+      }
+      if (args.max_bytes !== void 0) {
+        opts.maxBytes = args.max_bytes;
+      }
+      if (args.context_before !== void 0) {
+        opts.contextBefore = args.context_before;
+      }
+      if (args.context_after !== void 0) {
+        opts.contextAfter = args.context_after;
+      }
+      if (args.cursor !== void 0) {
+        opts.cursor = args.cursor;
+      }
+      const r = session.streamGrep(opts);
+      const payload = r;
+      return {
+        content: [{ type: "text", text: JSON.stringify(r) }],
+        structuredContent: payload
+      };
+    }
+  );
+  server.registerTool(
+    "stdin_info",
+    {
+      description: "Report cursor / capacity / closed state of the stdin ring. Cheap; safe to call repeatedly.",
+      inputSchema: {}
+    },
+    async () => {
+      const r = session.streamInfo();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(r)
+          }
+        ],
+        structuredContent: r
+      };
+    }
+  );
+  return server;
+}
+async function ensureTransport(token, session, registry) {
+  const existing = registry.lookup(token);
+  if (existing?.transport !== void 0) {
+    return existing.transport;
+  }
+  const server = buildMcpServer(session);
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID()
+  });
+  await server.connect(transport);
+  registry.attachTransport(token, server, transport);
+  return transport;
+}
+var SESSION_READY_TIMEOUT_MS = 1e4;
+async function handle(req, reply, registry) {
+  const token = extractBearer(req);
+  if (token === void 0) {
+    reply.code(401).send({ error: "missing bearer token" });
+    return;
+  }
+  const ep = registry.lookup(token);
+  if (ep === void 0) {
+    reply.code(404).send({ error: "unknown stdin token" });
+    return;
+  }
+  let session;
+  if (ep.session !== void 0) {
+    session = ep.session;
+  } else {
+    let timer;
+    const timeout = new Promise((resolve3) => {
+      timer = setTimeout(() => resolve3(void 0), SESSION_READY_TIMEOUT_MS);
+    });
+    const resolved = await Promise.race([
+      ep.sessionReady.catch(() => void 0),
+      timeout
+    ]);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+    if (resolved === void 0) {
+      reply.code(503).send({ error: "session not ready" });
+      return;
+    }
+    session = resolved;
+  }
+  const transport = await ensureTransport(token, session, registry);
+  reply.hijack();
+  await transport.handleRequest(req.raw, reply.raw, req.body);
+}
+function registerStdinMcpRoutes(app, registry) {
+  const opts = { config: { skipAuth: true } };
+  app.post("/mcp/stdin", opts, async (req, reply) => {
+    await handle(req, reply, registry);
+  });
+  app.get("/mcp/stdin", opts, async (req, reply) => {
+    await handle(req, reply, registry);
+  });
+  app.delete("/mcp/stdin", opts, async (req, reply) => {
+    await handle(req, reply, registry);
+  });
+}
+
 // src/daemon/server.ts
 async function startDaemon(config, serviceToken) {
   ensureLoopbackOrTls(config);
@@ -11641,6 +12256,19 @@ async function startDaemon(config, serviceToken) {
     store: sessionTokenStore,
     rateLimiter: authRateLimiter
   });
+  const stdinMcpRegistry = new StdinMcpRegistry();
+  registerStdinMcpRoutes(app, stdinMcpRegistry);
+  let daemonOriginCached;
+  const getDaemonOrigin = () => {
+    if (daemonOriginCached !== void 0) {
+      return daemonOriginCached;
+    }
+    const addr = app.server.address();
+    const port = addr && typeof addr === "object" ? addr.port : config.daemon.port;
+    const scheme2 = config.daemon.tls ? "https" : "http";
+    daemonOriginCached = `${scheme2}://${config.daemon.host}:${port}`;
+    return daemonOriginCached;
+  };
   registerAcpWsEndpoint(app, {
     validator,
     manager,
@@ -11649,7 +12277,9 @@ async function startDaemon(config, serviceToken) {
     onExtensionVersion: (name, version) => extensions.reportVersion(name, version),
     onTransformerVersion: (name, version) => transformers.reportVersion(name, version),
     transformers,
-    extensionCommands
+    extensionCommands,
+    stdinMcpRegistry,
+    getDaemonOrigin
   });
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();