@sjawhar/claude-envoy 1.18.0 → 1.19.0

package/dist/envoy-channel.js

@@ -36572,6 +36572,16 @@ function actorLabel(actor, titles) {
   return `${actorName(actor, titles)}${actorAttribution(actor)}`;
 }
 // ../contracts/src/agent-stream.ts
+var AGENT_STREAM_SUBJECT_PREFIX = "agentstream.";
+var AGENT_STREAM_PROTOCOL = 1;
+function agentStreamFramesSubject(sessionID) {
+  return `${AGENT_STREAM_SUBJECT_PREFIX}${sessionID}.frames`;
+}
+function agentStreamControlSubject(sessionID) {
+  return `${AGENT_STREAM_SUBJECT_PREFIX}${sessionID}.control`;
+}
+var AGENT_STREAM_WATCH_TTL_MS = 30000;
+var AGENT_STREAM_WATCH_INTERVAL_MS = 1e4;
 var AGENT_STREAM_LIMITS = {
   partChars: 16000,
   toolChars: 8000,
@@ -36583,6 +36593,16 @@ var AGENT_STREAM_LIMITS = {
   commandNameChars: 100,
   commandDescriptionChars: 200
 };
+var AGENT_STREAM_TRUNCATION_SUFFIX = `
+\u2026 truncated`;
+function isTypableCommandName(name) {
+  return /^[^\s\p{Cc}]+$/u.test(name);
+}
+function capAgentStreamText(text, limit) {
+  if (text.length <= limit)
+    return text;
+  return text.slice(0, limit) + AGENT_STREAM_TRUNCATION_SUFFIX;
+}
 // ../contracts/src/claim-holds.ts
 var HOLDING_OF = {
   gone: "lapsed",
@@ -36657,6 +36677,24 @@ function isIdPrefix(value) {
 function pictureCaption(name) {
   return name.replace(/[\\[\]`]/g, "\\$&").replace(/\s+/g, " ");
 }
+var PICTURE_CAPTION = String.raw`(?:\\.|[^\\\]\n]){0,512}`;
+var PICTURE_ADDRESS = String.raw`dispatch://[^\s()]{1,2048}@v[1-9][0-9]{0,18}`;
+var PICTURE_TITLE = String.raw`(?:\s{1,4}"(?:\\.|[^\\"]){0,256}")?`;
+var PICTURE_SYNTAX = String.raw`!\[${PICTURE_CAPTION}\]\((${PICTURE_ADDRESS})${PICTURE_TITLE}\)`;
+function pictureSyntax() {
+  return new RegExp(PICTURE_SYNTAX, "g");
+}
+function blockPlaceholder(type) {
+  return `[${type}]`;
+}
+var PICTURE_PLACEHOLDER = blockPlaceholder("image");
+function trimmedLines(text) {
+  return text.split(`
+`).map((line) => line.trim()).filter((line) => line !== "");
+}
+function comparableLines(text) {
+  return trimmedLines(text.replace(pictureSyntax(), ""));
+}
 var PICTURE_TYPES = {
   "image/png": true,
   "image/jpeg": true,
@@ -42699,9 +42737,9 @@ class DispatchClient {
   async messageReply(id, input, options = {}) {
     return this.#json("POST", ["api", "v1", "messages", id, "reply"], input, options.followUp === true ? { follow_up: "true" } : undefined);
   }
-  async deliveryReply(resource, id, input) {
+  async deliveryReply(resource, id, input, options = {}) {
     const collection = resource === "message" ? "messages" : "comments";
-    await this.#json("POST", ["api", "v1", collection, id, "reply"], input);
+    await this.#json("POST", ["api", "v1", collection, id, "reply"], input, options.followUp === true ? { follow_up: "true" } : undefined);
   }
   async getMessage(issue, id) {
     return this.#json("GET", [
@@ -43221,6 +43259,9 @@ function toolImage(bytes) {
     return;
   return { data: Buffer.from(bytes).toString("base64"), mimeType };
 }
+function imageBlocks(images) {
+  return images.map(({ data, mimeType }) => ({ type: "image", data, mimeType }));
+}
 function pictureLine(name, address) {
   return `![${pictureCaption(name)}](${address})`;
 }
@@ -43234,9 +43275,8 @@ function withPictureLines(text, lines) {
 ${lines.join(`
 `)}`;
 }
-var PICTURE_SYNTAX = /!\[(?:\\.|[^\\\]])*\]\((dispatch:\/\/[^\s()]+@v[1-9][0-9]*)(?:\s+"(?:\\.|[^\\"])*")?\)/g;
 function pictureAddresses(text) {
-  return [...text.matchAll(PICTURE_SYNTAX)].map((match) => match[1]);
+  return [...text.matchAll(pictureSyntax())].map((match) => match[1]);
 }
 function picturesNewestFirst(texts) {
   const ordered = texts.map((item, index) => ({ item, index, at: Date.parse(item.at) })).sort((left, right) => (Number.isNaN(right.at) ? 0 : right.at) - (Number.isNaN(left.at) ? 0 : left.at) || left.index - right.index);
@@ -43329,13 +43369,14 @@ function dispatchReplyPath(resource, id) {
   return `/api/v1/${collection}/${encodeURIComponent(id)}/reply`;
 }
 async function postDeliveryReply(config, sessionId, delivery, result) {
+  const { followUp, ...reply } = result;
   const client = new DispatchClient(config.url, config.credential);
   await client.deliveryReply(delivery.resource, delivery.id, {
     actor: { kind: "session", id: sessionId },
     attempt: delivery.attempt,
     ...delivery.replyFields,
-    ...result
-  });
+    ...reply
+  }, followUp === undefined ? {} : { followUp });
 }
 function expectsLaneReceipt(frame) {
   return frame.reply !== undefined && frame.reply !== "" && frame.subject === frame.directSubject && frame.envelopeTopic !== undefined && frame.envelopeTopic !== frame.directSubject;
@@ -46490,6 +46531,154 @@ function createConsumerDelivery(options) {
   };
 }
 
+// ../envoy-client/src/dispatch-config.ts
+var DEFAULT_SERVER_URL = "http://localhost:8766";
+function withoutTrailingSlashes2(url) {
+  let end = url.length;
+  while (end > 0 && url[end - 1] === "/")
+    end -= 1;
+  return url.slice(0, end);
+}
+function checkoutPair(checkout, serverUrl) {
+  const { token } = checkout.dispatch;
+  if (token === undefined) {
+    throw new Error(`${checkout.path}: dispatch.serverUrl requires dispatch.token in the same file`);
+  }
+  return {
+    kind: "file",
+    token,
+    field: "dispatch.token",
+    path: checkout.path,
+    server: serverUrl,
+    checkout: true
+  };
+}
+function writtenToken(config, checkout) {
+  if (checkout?.dispatch.token !== undefined) {
+    throw new Error(`${checkout.path}: dispatch.token requires dispatch.serverUrl in the same file`);
+  }
+  const own = config.dispatch;
+  if (own.token === undefined)
+    return;
+  const server = own.serverUrl ?? DEFAULT_SERVER_URL;
+  return {
+    token: own.token,
+    field: "dispatch.token",
+    path: config.path,
+    server,
+    checkout: false
+  };
+}
+function lostDispatchUrlNotice(env, config) {
+  if (nonEmpty(env.DISPATCH_TOKEN_FILE) === undefined)
+    return;
+  const link = config.missing?.link ?? null;
+  const old = config.missing?.oldUserFileNotice;
+  return [
+    "DISPATCH_TOKEN_FILE is set and DISPATCH_URL is not, so Dispatch is off: this shell lost the DISPATCH_URL it started with. Export DISPATCH_URL again, set to the Dispatch server that token is for",
+    ...link === null ? [] : [`${config.path} is a link to ${link}, which does not exist`],
+    ...old === undefined ? [] : [old]
+  ].join("; ");
+}
+function dispatchSettings(env, config, options = {}) {
+  const target = dispatchTarget(env, config);
+  if (!target.enabled)
+    return target;
+  const { url, source } = target;
+  let credential;
+  try {
+    credential = source.kind === "broker" ? brokerCredential(env, options.session) : bearerCredential(source.kind === "variable" ? source.token : fileBearer(source, url, "DISPATCH", env, options.commands));
+  } catch (error) {
+    return offWithError(messageFor(error));
+  }
+  const publicUrl = nonEmpty(env.DISPATCH_PUBLIC_URL);
+  const publicParsed = publicUrl === undefined ? undefined : httpUrl2(publicUrl);
+  if (publicUrl !== undefined && (publicParsed === undefined || publicParsed.port === "0")) {
+    return offWithError("DISPATCH_PUBLIC_URL must be an http or https URL");
+  }
+  return {
+    enabled: true,
+    url,
+    credential,
+    ...publicUrl === undefined ? {} : { publicUrl: publicUrl.replace(/\/+$/, "") }
+  };
+}
+function dispatchUrl(env, config) {
+  const target = dispatchTarget(env, config);
+  return target.enabled ? target.url : undefined;
+}
+function brokerRouteForced(env) {
+  const written = (env.DISPATCH_TOKEN_BROKER ?? "").trim();
+  if (written === "")
+    return false;
+  if (written === "1")
+    return true;
+  return offWithError(`DISPATCH_TOKEN_BROKER is "${written}" and takes 1: set it to 1 where this session's Dispatch credential is this machine's own identity traded at the secrets broker, and leave it unset where a bearer is read as usual`);
+}
+function dispatchTarget(env, config) {
+  if (config.kind === "failed")
+    return offWithError(config.error);
+  const forced = brokerRouteForced(env);
+  if (typeof forced !== "boolean")
+    return forced;
+  const explicitUrl = nonEmpty(env.DISPATCH_URL);
+  const checkoutFile = explicitUrl === undefined ? config.checkout : null;
+  if (checkoutFile?.kind === "invalid")
+    return offWithError(checkoutFile.error);
+  const checkout = checkoutFile?.kind === "valid" ? checkoutFile : null;
+  const own = config.dispatch;
+  if (own.enabled === false) {
+    return offWithNotice(`${config.path} sets dispatch.enabled to false: Dispatch is off`);
+  }
+  if (checkout?.dispatch.enabled === false) {
+    return offWithNotice(`${checkout.path} sets dispatch.enabled to false: Dispatch is off`);
+  }
+  const checkoutServer = checkout?.dispatch.serverUrl;
+  const addressed = explicitUrl !== undefined || checkoutServer !== undefined || own.serverUrl !== undefined || own.enabled === true;
+  if (!addressed) {
+    const lost = lostDispatchUrlNotice(env, config);
+    if (lost !== undefined)
+      return offWithNotice(lost);
+    return offWithNotice(config.missing === null ? `${config.path} names no Dispatch server, and DISPATCH_URL is not set: Dispatch is off` : missingConfigNotice(config.path, config.missing, "Dispatch is off"));
+  }
+  if (explicitUrl !== undefined && httpUrl2(explicitUrl) === undefined) {
+    return offWithError("DISPATCH_URL must be an http or https URL");
+  }
+  let source = { kind: "none" };
+  if (!forced) {
+    try {
+      source = checkout !== null && checkoutServer !== undefined ? checkoutPair(checkout, checkoutServer) : bearerSource(env, "DISPATCH", () => writtenToken(config, checkout));
+    } catch (error) {
+      return offWithError(messageFor(error));
+    }
+  }
+  if (source.kind === "none") {
+    let route;
+    try {
+      route = brokerRouteConfigured(env);
+    } catch (error) {
+      return offWithError(messageFor(error));
+    }
+    if (route.traded) {
+      const brokered = withoutTrailingSlashes2(explicitUrl ?? own.serverUrl ?? DEFAULT_SERVER_URL);
+      return { enabled: true, url: brokered, source: { kind: "broker" } };
+    }
+    if (forced) {
+      return offWithError(`DISPATCH_TOKEN_BROKER is set, so this session's Dispatch credential is this machine's own identity traded at the secrets broker, and ${route.gap}: Dispatch is off rather than written with whatever bearer this box holds`);
+    }
+    return offWithError(explicitUrl === undefined ? `${config.path}: dispatch is enabled and no token is: set dispatch.token, or DISPATCH_TOKEN or DISPATCH_TOKEN_FILE` : `DISPATCH_URL is set and no token is: set DISPATCH_TOKEN or DISPATCH_TOKEN_FILE, or dispatch.token in ${config.path}`);
+  }
+  const url = (explicitUrl ?? (source.kind === "file" ? source.server : own.serverUrl ?? DEFAULT_SERVER_URL)).replace(/\/+$/, "");
+  return { enabled: true, url, source };
+}
+function activeDispatchSettings(resolution) {
+  if (resolution.enabled)
+    return resolution;
+  if (resolution.error !== null)
+    throw new Error(`dispatch config: ${resolution.error}`);
+  return null;
+}
+
 // ../envoy-client/src/dispatch-session-directory.ts
 import { randomUUID } from "crypto";
 import { renameSync, rmSync as rmSync2, writeFileSync } from "fs";
@@ -51310,164 +51499,23 @@ function natsConnectionOptions(input) {
   };
 }
 
-// ../envoy-client/src/dispatch-config.ts
-var DEFAULT_SERVER_URL = "http://localhost:8766";
-function withoutTrailingSlashes2(url) {
-  let end = url.length;
-  while (end > 0 && url[end - 1] === "/")
-    end -= 1;
-  return url.slice(0, end);
-}
-function checkoutPair(checkout, serverUrl) {
-  const { token } = checkout.dispatch;
-  if (token === undefined) {
-    throw new Error(`${checkout.path}: dispatch.serverUrl requires dispatch.token in the same file`);
-  }
-  return {
-    kind: "file",
-    token,
-    field: "dispatch.token",
-    path: checkout.path,
-    server: serverUrl,
-    checkout: true
-  };
-}
-function writtenToken(config, checkout) {
-  if (checkout?.dispatch.token !== undefined) {
-    throw new Error(`${checkout.path}: dispatch.token requires dispatch.serverUrl in the same file`);
+// ../envoy-client/src/session-settings.ts
+function sessionConfigFile(harness, env) {
+  try {
+    return { path: envoyConfigPath(harness, env), error: null };
+  } catch (error) {
+    return { path: null, error: messageFor(error) };
   }
-  const own = config.dispatch;
-  if (own.token === undefined)
-    return;
-  const server = own.serverUrl ?? DEFAULT_SERVER_URL;
-  return {
-    token: own.token,
-    field: "dispatch.token",
-    path: config.path,
-    server,
-    checkout: false
-  };
-}
-function lostDispatchUrlNotice(env, config) {
-  if (nonEmpty(env.DISPATCH_TOKEN_FILE) === undefined)
-    return;
-  const link = config.missing?.link ?? null;
-  const old = config.missing?.oldUserFileNotice;
-  return [
-    "DISPATCH_TOKEN_FILE is set and DISPATCH_URL is not, so Dispatch is off: this shell lost the DISPATCH_URL it started with. Export DISPATCH_URL again, set to the Dispatch server that token is for",
-    ...link === null ? [] : [`${config.path} is a link to ${link}, which does not exist`],
-    ...old === undefined ? [] : [old]
-  ].join("; ");
 }
-function dispatchSettings(env, config, options = {}) {
-  const target = dispatchTarget(env, config);
-  if (!target.enabled)
-    return target;
-  const { url, source } = target;
-  let credential;
+function handedConfigFile(env) {
   try {
-    credential = source.kind === "broker" ? brokerCredential(env, options.session) : bearerCredential(source.kind === "variable" ? source.token : fileBearer(source, url, "DISPATCH", env, options.commands));
+    const handed = handedConfigPath(env);
+    return handed === undefined ? null : { path: handed, error: null };
   } catch (error) {
-    return offWithError(messageFor(error));
-  }
-  const publicUrl = nonEmpty(env.DISPATCH_PUBLIC_URL);
-  const publicParsed = publicUrl === undefined ? undefined : httpUrl2(publicUrl);
-  if (publicUrl !== undefined && (publicParsed === undefined || publicParsed.port === "0")) {
-    return offWithError("DISPATCH_PUBLIC_URL must be an http or https URL");
+    return { path: null, error: messageFor(error) };
   }
-  return {
-    enabled: true,
-    url,
-    credential,
-    ...publicUrl === undefined ? {} : { publicUrl: publicUrl.replace(/\/+$/, "") }
-  };
-}
-function dispatchUrl(env, config) {
-  const target = dispatchTarget(env, config);
-  return target.enabled ? target.url : undefined;
-}
-function brokerRouteForced(env) {
-  const written = (env.DISPATCH_TOKEN_BROKER ?? "").trim();
-  if (written === "")
-    return false;
-  if (written === "1")
-    return true;
-  return offWithError(`DISPATCH_TOKEN_BROKER is "${written}" and takes 1: set it to 1 where this session's Dispatch credential is this machine's own identity traded at the secrets broker, and leave it unset where a bearer is read as usual`);
 }
-function dispatchTarget(env, config) {
-  if (config.kind === "failed")
-    return offWithError(config.error);
-  const forced = brokerRouteForced(env);
-  if (typeof forced !== "boolean")
-    return forced;
-  const explicitUrl = nonEmpty(env.DISPATCH_URL);
-  const checkoutFile = explicitUrl === undefined ? config.checkout : null;
-  if (checkoutFile?.kind === "invalid")
-    return offWithError(checkoutFile.error);
-  const checkout = checkoutFile?.kind === "valid" ? checkoutFile : null;
-  const own = config.dispatch;
-  if (own.enabled === false) {
-    return offWithNotice(`${config.path} sets dispatch.enabled to false: Dispatch is off`);
-  }
-  if (checkout?.dispatch.enabled === false) {
-    return offWithNotice(`${checkout.path} sets dispatch.enabled to false: Dispatch is off`);
-  }
-  const checkoutServer = checkout?.dispatch.serverUrl;
-  const addressed = explicitUrl !== undefined || checkoutServer !== undefined || own.serverUrl !== undefined || own.enabled === true;
-  if (!addressed) {
-    const lost = lostDispatchUrlNotice(env, config);
-    if (lost !== undefined)
-      return offWithNotice(lost);
-    return offWithNotice(config.missing === null ? `${config.path} names no Dispatch server, and DISPATCH_URL is not set: Dispatch is off` : missingConfigNotice(config.path, config.missing, "Dispatch is off"));
-  }
-  if (explicitUrl !== undefined && httpUrl2(explicitUrl) === undefined) {
-    return offWithError("DISPATCH_URL must be an http or https URL");
-  }
-  let source = { kind: "none" };
-  if (!forced) {
-    try {
-      source = checkout !== null && checkoutServer !== undefined ? checkoutPair(checkout, checkoutServer) : bearerSource(env, "DISPATCH", () => writtenToken(config, checkout));
-    } catch (error) {
-      return offWithError(messageFor(error));
-    }
-  }
-  if (source.kind === "none") {
-    let route;
-    try {
-      route = brokerRouteConfigured(env);
-    } catch (error) {
-      return offWithError(messageFor(error));
-    }
-    if (route.traded) {
-      const brokered = withoutTrailingSlashes2(explicitUrl ?? own.serverUrl ?? DEFAULT_SERVER_URL);
-      return { enabled: true, url: brokered, source: { kind: "broker" } };
-    }
-    if (forced) {
-      return offWithError(`DISPATCH_TOKEN_BROKER is set, so this session's Dispatch credential is this machine's own identity traded at the secrets broker, and ${route.gap}: Dispatch is off rather than written with whatever bearer this box holds`);
-    }
-    return offWithError(explicitUrl === undefined ? `${config.path}: dispatch is enabled and no token is: set dispatch.token, or DISPATCH_TOKEN or DISPATCH_TOKEN_FILE` : `DISPATCH_URL is set and no token is: set DISPATCH_TOKEN or DISPATCH_TOKEN_FILE, or dispatch.token in ${config.path}`);
-  }
-  const url = (explicitUrl ?? (source.kind === "file" ? source.server : own.serverUrl ?? DEFAULT_SERVER_URL)).replace(/\/+$/, "");
-  return { enabled: true, url, source };
-}
-
-// ../envoy-client/src/session-settings.ts
-function sessionConfigFile(harness, env) {
-  try {
-    return { path: envoyConfigPath(harness, env), error: null };
-  } catch (error) {
-    return { path: null, error: messageFor(error) };
-  }
-}
-function handedConfigFile(env) {
-  try {
-    const handed = handedConfigPath(env);
-    return handed === undefined ? null : { path: handed, error: null };
-  } catch (error) {
-    return { path: null, error: messageFor(error) };
-  }
-}
-function startNotice(config, dispatch, envoy, nats, lost) {
+function startNotice(config, dispatch, envoy, nats, lost) {
   if (config.kind === "failed")
     return `${config.error}: Dispatch and Envoy are off`;
   const { missing, checkout } = config;
@@ -55214,604 +55262,953 @@ var import_nats2 = __toESM(require_mod4(), 1);
 
 // package.json
 var name = "@sjawhar/claude-envoy";
-var version2 = "1.18.0";
+var version2 = "1.19.0";
 var legion = {
   daemonApiVersion: 56
 };
 
-// src/channel-forwarder.ts
-var DeliveryIdentity = DedupeIdentitySchema.extend({
-  event_id: DedupeIdentitySchema.shape.event_id.catch(undefined),
-  dedupe_key: DedupeIdentitySchema.shape.dedupe_key.catch(undefined),
-  source: DedupeIdentitySchema.shape.source.catch(undefined),
-  source_event_id: DedupeIdentitySchema.shape.source_event_id.catch(undefined),
-  topic: string2().min(1).optional().catch(undefined)
-});
-var decoder5 = new TextDecoder;
-var DEFAULT_DRAIN_TIMEOUT_MS = 1000;
-function deliveryIdentity(raw) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
+// ../pi-shared/src/agent-stream.ts
+var encoder4 = new TextEncoder;
+var REPLAY_ARRAY_BYTES = 2;
+function jsonBytes(value) {
+  return encoder4.encode(JSON.stringify(value)).length;
+}
+var SEQ_PER_MS = 1000;
+function modelReference(provider, id) {
+  if (typeof id !== "string" || id === "")
     return;
-  }
-  const identity = DeliveryIdentity.safeParse(parsed);
-  return identity.success ? identity.data : undefined;
+  if (typeof provider !== "string" || provider === "")
+    return;
+  return `${provider}/${id}`;
 }
-function report(what, error) {
-  process.stderr.write(`envoy-channel: ${what} \u2014 ${messageFor(error)}
-`);
+function readModel(message) {
+  const model = modelReference(message.provider, message.model);
+  return model === undefined ? undefined : capAgentStreamText(model, AGENT_STREAM_LIMITS.modelChars);
 }
-function createChannelForwarder(connection, options) {
-  const following = new Map;
-  const dedupe = options.dedupe ?? createDeliveryDedupe();
-  const drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
-  const deliver = async (topic, subscription) => {
-    try {
-      for await (const { message, receivedAt } of readArrivals(subscription)) {
-        const raw = decoder5.decode(message.data);
-        const identity = deliveryIdentity(raw);
-        let claim = options.relayed?.(topic) === true ? undefined : dedupe.claim(identity);
-        if (claim !== undefined && identity !== undefined && options.ledger?.delivered(identity)) {
-          claim.settle();
-          claim = undefined;
-        }
-        const inbound = {
-          subject: message.subject,
-          data: message.data,
-          raw,
-          ...message.reply ? { reply: message.reply } : {},
-          ...identity?.topic === undefined ? {} : { envelopeTopic: identity.topic },
-          ...claim === undefined ? { duplicate: true } : {}
-        };
-        let handed;
-        try {
-          handed = await options.deliver(inbound);
-        } catch (error) {
-          claim?.release();
-          report(`could not deliver a message on ${message.subject}`, error);
-          if (claim !== undefined)
-            options.failed?.(inbound, topic, error, receivedAt);
-          continue;
-        }
-        if (claim === undefined)
-          continue;
-        if (!handed) {
-          claim.release();
-          continue;
-        }
-        const taken = claim;
-        const settle = () => taken.settle();
-        if (identity === undefined || options.ledger === undefined)
-          settle();
-        else
-          options.ledger.recordDelivered(identity).then(settle, settle);
-      }
-    } catch (error) {
-      report(`delivery from ${topic} stopped`, error);
-    }
-  };
-  const stop = async (topics) => {
-    const stopping = topics.flatMap((topic) => {
-      const entry = following.get(topic);
-      if (entry === undefined)
-        return [];
-      following.delete(topic);
-      entry.subscription.unsubscribe();
-      return [entry.done];
-    });
-    await Promise.all(stopping);
-  };
+function readMessage(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const message = raw;
+  if (typeof message.role !== "string" || typeof message.timestamp !== "number")
+    return null;
   return {
-    follow(topic) {
-      for (const subject of expandSubscriptionTopics([topic])) {
-        if (following.has(subject))
-          continue;
-        const subscription = connection.subscribe(subject);
-        following.set(subject, { subscription, done: deliver(subject, subscription) });
-      }
-    },
-    unfollow(topics) {
-      return stop(topics.length === 0 ? [...following.keys()] : expandSubscriptionTopics(topics));
-    },
-    topics() {
-      return [...following.keys()];
-    },
-    isClosed() {
-      return connection.isClosed();
-    },
-    async close() {
-      await stop([...following.keys()]);
-      if (connection.isClosed())
-        return;
-      const timeout = Promise.withResolvers();
-      const timer = setTimeout(timeout.resolve, drainTimeoutMs);
-      try {
-        await Promise.race([connection.drain(), timeout.promise]);
-      } catch (error) {
-        report("draining the broker connection failed", error);
-      }
-      clearTimeout(timer);
-      if (connection.isClosed())
-        return;
-      try {
-        await connection.close();
-      } catch (error) {
-        report("closing the broker connection failed", error);
-      }
-    }
-  };
+    host: message,
+    isError: message.isError === true,
+    model: readModel(message),
+    role: message.role,
+    timestamp: message.timestamp,
+    toolCallId: typeof message.toolCallId === "string" ? message.toolCallId : undefined,
+    toolName: typeof message.toolName === "string" ? message.toolName : undefined,
+    tag: typeof message.tag === "string" ? message.tag : undefined
+  };
+}
+function keyFor(message) {
+  if (message.role === "toolResult") {
+    return message.toolCallId === undefined ? null : `t:${message.toolCallId}`;
+  }
+  if (message.role === "assistant")
+    return `m:a${message.timestamp}`;
+  if (message.role !== "user")
+    return null;
+  return message.tag === undefined ? `m:u${message.timestamp}` : `m:u${message.timestamp}:${message.tag}`;
 }
-
-// src/claude-channel.ts
-import { spawnSync } from "child_process";
-import { readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync as readlinkSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename2, join as join6, resolve as resolve3, sep } from "path";
-var PLUGIN_SERVER = "envoy";
-var CHANNEL_FLAGS = {
-  "--channels": false,
-  "--dangerously-load-development-channels": true
-};
-function parseEntry(value, dev) {
-  if (value.startsWith("plugin:")) {
-    const spec = value.slice("plugin:".length);
-    const at = spec.indexOf("@");
-    if (at <= 0 || at === spec.length - 1)
-      return;
-    return { kind: "plugin", name: spec.slice(0, at), marketplace: spec.slice(at + 1), dev };
-  }
-  if (value.startsWith("server:") && value.length > "server:".length) {
-    return { kind: "server", name: value.slice("server:".length), dev };
+function contentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const pieces = [];
+  for (const raw of content) {
+    if (typeof raw !== "object" || raw === null)
+      continue;
+    const part = raw;
+    if (typeof part.text === "string")
+      pieces.push(part.text);
+    else if (typeof part.type === "string")
+      pieces.push(blockPlaceholder(part.type));
   }
-  return;
+  return pieces.join(`
+`);
 }
-var VALUE_OPTIONS = new Set([
-  "--prefill",
-  "--prefill-b64",
-  "--deep-link-repo",
-  "--deep-link-last-fetch",
-  "--deep-link-cwd-b64",
-  "--handle-uri",
-  "--settings",
-  "--managed-settings",
-  "--setting-sources",
-  "--client-data-url",
-  "--watch-artifact",
-  "--watch-artifact-no-autoreact",
-  "--team-name",
-  "--agent-id",
-  "--agent-name",
-  "--agent-color",
-  "--parent-session-id",
-  "--agent-type",
-  "--model",
-  "--agent",
-  "--routine",
-  "--effort",
-  "--fast-mode",
-  "--permission-mode",
-  "--inherit-permission-mode",
-  "--proactivity",
-  "--debug-file",
-  "--system-prompt",
-  "--system-prompt-file",
-  "--append-system-prompt",
-  "--append-system-prompt-file",
-  "--system-prompt-snapshot",
-  "--append-subagent-system-prompt",
-  "--append-subagent-system-prompt-file",
-  "--plan-mode-instructions",
-  "--permission-prompt-tool",
-  "--permission-prompts",
-  "--json-schema",
-  "--fallback-model",
-  "--advisor",
-  "--agents",
-  "--name",
-  "-n",
-  "--allowedTools",
-  "--allowed-tools",
-  "--disallowedTools",
-  "--disallowed-tools",
-  "--tools",
-  "--add-dir",
-  "--mcp-config",
-  "--betas",
-  "--file",
-  "--channels",
-  "--dangerously-load-development-channels",
-  "--plugin-dir",
-  "--plugin-dir-no-mcp",
-  "--plugin-url",
-  "--remote-control-session-name-prefix",
-  "--exec",
-  "-m",
-  "--sdk-url",
-  "--thinking",
-  "--thinking-display",
-  "--max-thinking-tokens",
-  "--max-turns",
-  "--max-budget-usd",
-  "--task-budget",
-  "--autocompact",
-  "--rewind-files",
-  "--resume-session-at",
-  "--resume-drops-turn",
-  "--workload",
-  "--output-format",
-  "--input-format",
-  "--teammate-mode",
-  "--messaging-socket-path",
-  "--session-id",
-  "--environment",
-  "--pool",
-  "--ref",
-  "--on-branch",
-  "--correlation-id",
-  "--forward-home-settings",
-  "--project-config-root",
-  "--attach-serve"
-]);
-var OPTIONAL_VALUE_OPTIONS = new Set([
-  "-d",
-  "--debug",
-  "-r",
-  "--resume",
-  "--from-pr",
-  "-w",
-  "--worktree",
-  "--teleport",
-  "--cloud",
-  "--remote",
-  "--project",
-  "--remote-control",
-  "--rc",
-  "--prompt-suggestions"
-]);
-var MULTI_VALUE_OPTIONS = new Set([
-  "--allowedTools",
-  "--allowed-tools",
-  "--disallowedTools",
-  "--disallowed-tools",
-  "--tools",
-  "--add-dir",
-  "--mcp-config",
-  "--betas",
-  "--file",
-  "--channels",
-  "--dangerously-load-development-channels"
-]);
-function isOption(argument) {
-  return argument.length > 1 && argument.startsWith("-");
-}
-function lastValueIndex(argv, index) {
-  const argument = argv[index] ?? "";
-  if (OPTIONAL_VALUE_OPTIONS.has(argument)) {
-    const next = argv[index + 1];
-    return next !== undefined && !isOption(next) ? index + 1 : index;
-  }
-  if (!VALUE_OPTIONS.has(argument))
-    return index;
-  let last = index + 1;
-  if (MULTI_VALUE_OPTIONS.has(argument)) {
-    while (last + 1 < argv.length && !isOption(argv[last + 1] ?? ""))
-      last++;
-  }
-  return last;
-}
-function asksForPrintMode(argv) {
-  for (let index = 1;index < argv.length; index++) {
-    const argument = argv[index] ?? "";
-    if (argument === "--")
-      return false;
-    if (argument === "-p" || argument === "--print" || argument === "--init-only" || argument.startsWith("--sdk-url")) {
-      return true;
-    }
-    index = lastValueIndex(argv, index);
-  }
-  return false;
+function boundedStrings(_key, value) {
+  return typeof value === "string" ? capAgentStreamText(value, AGENT_STREAM_LIMITS.toolChars) : value;
 }
-function claudeChannelEntries(argv, exact = true, stdoutIsTerminal = undefined) {
-  const interactive = !exact || !asksForPrintMode(argv) && stdoutIsTerminal !== false;
-  const approved = [];
-  const development = [];
-  for (let index = 1;index < argv.length; index++) {
-    const argument = argv[index] ?? "";
-    if (exact && argument === "--")
-      break;
-    const equals = argument.indexOf("=");
-    const flag = equals === -1 ? argument : argument.slice(0, equals);
-    const dev = CHANNEL_FLAGS[flag];
-    if (dev === undefined) {
-      if (exact)
-        index = lastValueIndex(argv, index);
-      continue;
-    }
-    const values = [];
-    if (equals !== -1)
-      values.push(argument.slice(equals + 1));
-    else {
-      while (index + 1 < argv.length && !isOption(argv[index + 1] ?? "-")) {
-        values.push(argv[index + 1] ?? "");
-        index++;
-      }
-    }
-    if (dev && !interactive)
-      continue;
-    for (const value of values) {
-      const entry = parseEntry(value, dev);
-      if (entry !== undefined)
-        (dev ? development : approved).push(entry);
-    }
+function renderArguments(value) {
+  if (value === undefined || value === null)
+    return "";
+  try {
+    return JSON.stringify(value, boundedStrings, 2) ?? "";
+  } catch {
+    return "[unserialisable arguments]";
   }
-  return [...approved, ...development];
 }
-function claudeChannelGate(input) {
-  const { commandLine, plugin, allowlist } = input;
-  if (commandLine === undefined)
-    return { loaded: true };
-  const ours = plugin === undefined ? "server:<name>" : `plugin:${plugin.name}@${plugin.marketplace ?? "<marketplace>"}`;
-  const entry = claudeChannelEntries(commandLine.argv, commandLine.exact, commandLine.stdoutIsTerminal).find((candidate) => plugin === undefined ? candidate.kind === "server" : candidate.kind === "plugin" && candidate.name === plugin.name || candidate.kind === "server" && candidate.name === `plugin:${plugin.name}:${PLUGIN_SERVER}`);
-  if (entry === undefined) {
-    return {
-      loaded: false,
-      why: `claude was started without --channels ${ours} (or --dangerously-load-development-channels ${ours})`
-    };
-  }
-  if (entry.kind === "server") {
-    return entry.dev ? { loaded: true } : {
-      loaded: false,
-      why: `server:${entry.name} is not on Claude Code's approved channels allowlist (use --dangerously-load-development-channels server:${entry.name})`
-    };
+function conversationParts(content) {
+  const { partChars, toolChars } = AGENT_STREAM_LIMITS;
+  if (typeof content === "string") {
+    return content === "" ? [] : [{ text: capAgentStreamText(content, partChars), type: "text" }];
   }
-  const asked = `plugin:${entry.name}@${entry.marketplace}`;
-  if (plugin?.marketplace !== undefined && cacheDirectoryName(entry.marketplace ?? "") !== cacheDirectoryName(plugin.marketplace)) {
+  if (!Array.isArray(content))
+    return [];
+  const parts = [];
+  for (const raw of content) {
+    if (typeof raw !== "object" || raw === null)
+      continue;
+    const part = raw;
+    if (part.type === "text" && typeof part.text === "string") {
+      parts.push({ text: capAgentStreamText(part.text, partChars), type: "text" });
+    } else if (part.type === "thinking" && typeof part.thinking === "string") {
+      parts.push({ text: capAgentStreamText(part.thinking, partChars), type: "reasoning" });
+    } else if (part.type === "toolCall" && typeof part.id === "string") {
+      parts.push({
+        argsText: capAgentStreamText(renderArguments(part.arguments), toolChars),
+        toolCallId: part.id,
+        toolName: typeof part.name === "string" ? part.name : "tool",
+        type: "tool-call"
+      });
+    } else if (typeof part.type === "string") {
+      parts.push({ text: blockPlaceholder(part.type), type: "text" });
+    }
+  }
+  return parts;
+}
+function frameFor(entry) {
+  const { dispatchMessageId, message } = entry;
+  if (message.role === "toolResult" && message.toolCallId !== undefined) {
     return {
-      loaded: false,
-      why: `claude asked for ${asked} but this plugin is installed from ${plugin.marketplace}`
+      kind: "tool-result",
+      result: {
+        at: message.timestamp,
+        isError: message.isError,
+        output: capAgentStreamText(contentText(message.host.content), AGENT_STREAM_LIMITS.toolChars),
+        toolCallId: message.toolCallId,
+        toolName: message.toolName ?? "tool"
+      },
+      seq: entry.seq,
+      v: AGENT_STREAM_PROTOCOL
     };
   }
-  if (entry.dev)
-    return { loaded: true };
-  if (allowlist === undefined) {
-    return {
-      loaded: false,
-      why: `${asked} is not on Claude Code's approved channels allowlist (add it to allowedChannelPlugins in ${MANAGED_SETTINGS_HINT}; for one session use --dangerously-load-development-channels ${asked})`
-    };
+  return {
+    kind: "message",
+    message: {
+      at: message.timestamp,
+      id: entry.key.slice(2),
+      parts: conversationParts(message.host.content),
+      role: message.role === "assistant" ? "assistant" : "user",
+      streaming: entry.streaming,
+      ...dispatchMessageId === undefined ? {} : { dispatchMessageId },
+      ...message.role === "assistant" && message.model !== undefined ? { model: message.model } : {}
+    },
+    seq: entry.seq,
+    v: AGENT_STREAM_PROTOCOL
+  };
+}
+
+class AgentStreamPublisher {
+  #deps;
+  #history = new Map;
+  #settled = new Set;
+  #publishedAt = new Map;
+  #seq;
+  #watchedUntil = 0;
+  #listedCommands;
+  #commands;
+  #commandsSeq = 0;
+  #settings;
+  #settingsSeq = 0;
+  #settingsJson;
+  constructor(deps) {
+    this.#deps = deps;
+    this.#seq = Math.trunc(deps.now()) * SEQ_PER_MS;
+  }
+  noteViewer() {
+    this.#watchedUntil = this.#deps.now() + AGENT_STREAM_WATCH_TTL_MS;
+  }
+  publishState(subject) {
+    if (!this.watched)
+      return;
+    if (this.#settings !== undefined) {
+      this.#deps.publish(subject, JSON.stringify(this.#settingsFrame(this.#settings)));
+    }
+    if (this.#commands !== undefined) {
+      this.#deps.publish(subject, JSON.stringify(this.#commandsFrame(this.#commands)));
+    }
+  }
+  get watched() {
+    return this.#deps.now() < this.#watchedUntil;
+  }
+  reset() {
+    this.#history.clear();
+    this.#settled.clear();
+    this.#publishedAt.clear();
+    this.#watchedUntil = 0;
+    this.#listedCommands = undefined;
+    this.#commands = undefined;
+    this.#settings = undefined;
+    this.#settingsJson = undefined;
+  }
+  setCommands(subject, commands) {
+    const seen = new Set;
+    const listed = [];
+    for (const command of commands) {
+      if (listed.length >= AGENT_STREAM_LIMITS.commands)
+        break;
+      const name = command.name;
+      if (name.length > AGENT_STREAM_LIMITS.commandNameChars)
+        continue;
+      if (!isTypableCommandName(name) || seen.has(name))
+        continue;
+      seen.add(name);
+      listed.push({
+        name,
+        source: command.source,
+        ...command.description !== undefined && {
+          description: capAgentStreamText(command.description, AGENT_STREAM_LIMITS.commandDescriptionChars)
+        },
+        ...command.terminalOnly === true && { terminalOnly: true }
+      });
+    }
+    this.#listedCommands = listed;
+    this.#fitCommands(subject);
   }
-  return allowlist.some((allowed) => allowed.marketplace === entry.marketplace && allowed.plugin === entry.name) ? { loaded: true } : {
-    loaded: false,
-    why: `${asked} is not on Claude Code's approved channels allowlist (allowedChannelPlugins in ${MANAGED_SETTINGS_HINT})`
-  };
-}
-var MANAGED_SETTINGS_HINT = `${join6(managedSettingsDirectory(), "managed-settings.json")}, or in the server-managed settings when the account receives them`;
-function cacheDirectoryName(marketplace) {
-  return marketplace.replace(/[^a-zA-Z0-9\-_]/g, "-");
-}
-function processExecutable(pid) {
-  if (process.platform === "linux") {
-    try {
-      return readlinkSync3(`/proc/${pid}/exe`);
-    } catch {
+  setSettings(subject, settings) {
+    const kept = settings.reported ? {
+      ...settings.model !== undefined && { model: settings.model },
+      models: [...settings.models],
+      reported: true,
+      thinking: settings.thinking === null ? null : { level: settings.thinking.level, levels: [...settings.thinking.levels] }
+    } : { reported: false };
+    const json = JSON.stringify(kept);
+    if (json === this.#settingsJson)
+      return;
+    this.#settings = kept;
+    this.#settingsJson = json;
+    this.#seq += 1;
+    this.#settingsSeq = this.#seq;
+    if (this.watched)
+      this.#deps.publish(subject, JSON.stringify(this.#settingsFrame(kept)));
+    this.#fitCommands(subject);
+  }
+  #fitCommands(subject) {
+    const listed = this.#listedCommands;
+    if (listed === undefined)
       return;
+    const settings = this.#settings === undefined ? 0 : jsonBytes(this.#settingsFrame(this.#settings)) + 1;
+    const limit = AGENT_STREAM_LIMITS.historyBytes - REPLAY_ARRAY_BYTES - settings;
+    let bytes = jsonBytes(this.#commandsFrame([], this.#seq + 1));
+    const kept = [];
+    for (const command of listed) {
+      const cost = jsonBytes(command) + (kept.length === 0 ? 0 : 1);
+      if (bytes + cost > limit)
+        break;
+      bytes += cost;
+      kept.push(command);
     }
+    if (JSON.stringify(kept) === JSON.stringify(this.#commands))
+      return;
+    this.#commands = kept;
+    this.#seq += 1;
+    this.#commandsSeq = this.#seq;
+    if (this.watched)
+      this.#deps.publish(subject, JSON.stringify(this.#commandsFrame(kept)));
   }
-  if (process.platform === "win32")
-    return;
-  const result = spawnSync("lsof", ["-a", "-p", String(pid), "-d", "txt", "-Fn"], {
-    encoding: "utf8",
-    timeout: 2000
-  });
-  const first = (result.stdout ?? "").split(`
-`).find((line) => line.startsWith("n"));
-  return first === undefined ? undefined : first.slice(1);
-}
-function stdoutIsTerminal(pid) {
-  if (process.platform !== "linux")
-    return;
-  try {
-    const target = readlinkSync3(`/proc/${pid}/fd/1`);
-    return target.startsWith("/dev/pts/") || /^\/dev\/tty[^S]/.test(target) || target === "/dev/tty";
-  } catch {
-    return;
+  #commandsFrame(commands, seq = this.#commandsSeq) {
+    return { commands, kind: "commands", seq, v: AGENT_STREAM_PROTOCOL };
   }
-}
-function workingDirectory(pid) {
-  try {
-    return readlinkSync3(`/proc/${pid}/cwd`);
-  } catch {
-    return;
+  #settingsFrame(settings) {
+    return { ...settings, kind: "settings", seq: this.#settingsSeq, v: AGENT_STREAM_PROTOCOL };
   }
-}
-function processCommandLine(pid, executable = processExecutable) {
-  let commandLine;
-  if (process.platform === "linux") {
-    try {
-      const pieces = readFileSync6(`/proc/${pid}/cmdline`, "utf8").split("\x00");
-      let trailing = 0;
-      while (pieces.length > 0 && pieces.at(-1) === "") {
-        pieces.pop();
-        trailing++;
-      }
-      if (trailing > 1 && pieces.length === 1)
-        return;
-      for (let blank = 1;blank < trailing; blank++)
-        pieces.push("");
-      const argv = pieces;
-      const terminal = stdoutIsTerminal(pid);
-      const cwd = workingDirectory(pid);
-      commandLine = argv.length === 0 ? undefined : {
-        argv,
-        exact: true,
-        ...terminal === undefined ? {} : { stdoutIsTerminal: terminal },
-        ...cwd === undefined ? {} : { cwd }
-      };
-    } catch {
-      commandLine = undefined;
+  record(subject, raw, streaming, dispatchMessageId) {
+    const message = readMessage(raw);
+    if (message === null)
+      return false;
+    const key = keyFor(message);
+    if (key === null)
+      return false;
+    const stillStreaming = message.role === "assistant" && streaming;
+    if (stillStreaming && this.#settled.has(key))
+      return false;
+    this.#seq += 1;
+    const entry = {
+      at: message.timestamp,
+      dispatchMessageId: dispatchMessageId ?? this.#history.get(key)?.dispatchMessageId,
+      key,
+      message,
+      seq: this.#seq,
+      streaming: stillStreaming
+    };
+    this.#history.set(key, entry);
+    if (!stillStreaming)
+      this.#settled.add(key);
+    while (this.#history.size > AGENT_STREAM_LIMITS.historyMessages) {
+      const oldest = this.#history.keys().next();
+      if (oldest.done === true)
+        break;
+      this.#history.delete(oldest.value);
+      this.#settled.delete(oldest.value);
+      this.#publishedAt.delete(oldest.value);
     }
-  } else if (process.platform !== "win32") {
-    const result = spawnSync("ps", ["-ww", "-o", "args=", "-p", String(pid)], {
-      encoding: "utf8",
-      timeout: 1000
-    });
-    const line = result.status === 0 ? result.stdout.trim() : "";
-    commandLine = line === "" ? undefined : { argv: line.split(/\s+/), exact: false };
+    if (!this.watched)
+      return true;
+    const now = this.#deps.now();
+    const published = this.#publishedAt.get(key);
+    const tooSoon = published !== undefined && now - published < AGENT_STREAM_LIMITS.snapshotIntervalMs;
+    if (stillStreaming && tooSoon)
+      return true;
+    this.#publishedAt.set(key, now);
+    this.#deps.publish(subject, JSON.stringify(frameFor(entry)));
+    return true;
+  }
+  replay(sessionID) {
+    if (!this.watched)
+      return { frames: [], session_id: sessionID, v: AGENT_STREAM_PROTOCOL };
+    const ordered = [...this.#history.values()].sort((left, right) => left.at === right.at ? left.seq - right.seq : left.at - right.at);
+    const tail = [];
+    if (this.#settings !== undefined)
+      tail.push(this.#settingsFrame(this.#settings));
+    if (this.#commands !== undefined)
+      tail.push(this.#commandsFrame(this.#commands));
+    let used = REPLAY_ARRAY_BYTES + tail.reduce((bytes, frame, index) => bytes + jsonBytes(frame) + (index === 0 ? 0 : 1), 0);
+    const kept = [];
+    for (let index = ordered.length - 1;index >= 0; index -= 1) {
+      const entry = ordered[index];
+      if (entry === undefined)
+        continue;
+      const frame = frameFor(entry);
+      const separated = kept.length > 0 || tail.length > 0;
+      const cost = jsonBytes(frame) + (separated ? 1 : 0);
+      if (used + cost > AGENT_STREAM_LIMITS.historyBytes)
+        break;
+      used += cost;
+      kept.unshift(frame);
+    }
+    kept.push(...tail);
+    return { frames: kept, session_id: sessionID, v: AGENT_STREAM_PROTOCOL };
   }
-  if (commandLine === undefined || commandLine.argv.length > 1)
-    return commandLine;
-  return basename2(executable(pid) ?? "").startsWith("node") ? undefined : commandLine;
 }
-function parentProcess(pid) {
-  try {
-    if (process.platform === "linux") {
-      const stat = readFileSync6(`/proc/${pid}/stat`, "utf8");
-      const parent = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
-      return Number.isInteger(parent) && parent > 0 ? parent : undefined;
+
+// src/claude-rows.ts
+var COMMAND_BOOKKEEPING_TAGS = [
+  "<local-command-caveat>",
+  "<local-command-stdout>",
+  "<local-command-stderr>"
+];
+var COMMAND_OUTPUT_TAGS = ["local-command-stdout", "local-command-stderr"];
+function claudeRowText(value) {
+  if (typeof value === "string")
+    return value;
+  if (!Array.isArray(value))
+    return "";
+  const pieces = [];
+  for (const item of value) {
+    if (typeof item === "string") {
+      pieces.push(item);
+      continue;
     }
-    if (process.platform === "win32")
-      return;
-    const result = spawnSync("ps", ["-o", "ppid=", "-p", String(pid)], {
-      encoding: "utf8",
-      timeout: 1000
-    });
-    const parent = Number((result.stdout ?? "").trim());
-    return result.status === 0 && Number.isInteger(parent) && parent > 0 ? parent : undefined;
-  } catch {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const block = item;
+    const text = block["text"];
+    const type = block["type"];
+    if (typeof text === "string")
+      pieces.push(text);
+    else if (typeof type === "string")
+      pieces.push(`[${type}]`);
+  }
+  return pieces.join(`
+`);
+}
+function taggedValue(text, tag) {
+  const open = `<${tag}>`;
+  const from = text.indexOf(open);
+  if (from === -1)
     return;
-  }
+  const to = text.indexOf(`</${tag}>`, from + open.length);
+  if (to === -1)
+    return;
+  return text.slice(from + open.length, to).trim();
 }
-var MAX_CLAUDE_DEPTH = 8;
-function claudeCommandLine(pid, read = processCommandLine, parent = parentProcess) {
-  let current = pid;
-  for (let depth = 0;current !== undefined && current > 1 && depth < MAX_CLAUDE_DEPTH; depth++) {
-    const commandLine = read(current);
-    if (commandLine === undefined)
-      return;
-    if (basename2(commandLine.argv[0] ?? "") === "claude")
-      return commandLine;
-    current = parent(current);
+function claudeEchoedCommandLine(content) {
+  const text = claudeRowText(content);
+  const name = taggedValue(text, "command-name");
+  if (name === undefined || name === "")
+    return;
+  const args = taggedValue(text, "command-args") ?? "";
+  return args === "" ? name : `${name} ${args}`;
+}
+function claudeCommandOutput(content) {
+  const text = claudeRowText(content);
+  for (const tag of COMMAND_OUTPUT_TAGS) {
+    const value = taggedValue(text, tag);
+    if (value !== undefined)
+      return value;
   }
   return;
 }
-function pluginCacheSegments(bundlePath) {
-  const parts = bundlePath.split(sep);
-  for (let index = 0;index + 1 < parts.length; index++) {
-    if (parts[index] === "plugins" && parts[index + 1] === "cache")
-      return parts.slice(index + 2);
+function isCommandBookkeeping(content) {
+  const text = claudeRowText(content);
+  return COMMAND_BOOKKEEPING_TAGS.some((tag) => text.startsWith(tag));
+}
+var PICTURE_ATTACHMENT_ROW = /^\[Image: source: \/[^\]]+\]$/;
+function isPictureAttachmentRow(content) {
+  return PICTURE_ATTACHMENT_ROW.test(claudeRowText(content).trim());
+}
+var MID_TURN_OPEN = "<system-reminder>";
+var MID_TURN_CLOSE = "</system-reminder>";
+var MID_TURN_ANNOUNCEMENT = "The user sent a new message while you were working:";
+var MID_TURN_NOTE = "This is how Claude Code surfaces messages the user sends mid-turn";
+function claudeMidTurnMessage(text) {
+  const body = text.trim();
+  if (!body.startsWith(MID_TURN_OPEN) || !body.endsWith(MID_TURN_CLOSE))
+    return;
+  const inner = body.slice(MID_TURN_OPEN.length, body.length - MID_TURN_CLOSE.length).trimStart();
+  if (!inner.startsWith(MID_TURN_ANNOUNCEMENT))
+    return;
+  const note = inner.lastIndexOf(MID_TURN_NOTE);
+  if (note < MID_TURN_ANNOUNCEMENT.length)
+    return;
+  return inner.slice(MID_TURN_ANNOUNCEMENT.length, note).trim();
+}
+
+// src/agent-stream-claude.ts
+var CLAUDE_PROVIDER = "anthropic";
+var CLAUDE_THINKING_HIDDEN = "Claude Code hides what the model thought here: it sends the thinking text only when the terminal session turns on the showThinkingSummaries setting.";
+var CLAUDE_EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function partOf(block) {
+  const text = block["text"];
+  if (block.type === "text" && typeof text === "string") {
+    return { type: "text", text: claudeMidTurnMessage(text) ?? text };
+  }
+  const thinking = block["thinking"];
+  if (block.type === "thinking" && typeof thinking === "string") {
+    return { type: "thinking", thinking };
+  }
+  const id = block["id"];
+  if (block.type === "tool_use" && typeof id === "string") {
+    const name = block["name"];
+    return {
+      arguments: block["input"],
+      id,
+      name: typeof name === "string" ? name : "tool",
+      type: "toolCall"
+    };
   }
-  return;
+  return { type: block.type };
 }
-function installedMarketplace(bundlePath) {
-  return pluginCacheSegments(bundlePath)?.[0];
+function shows(part) {
+  if (part.type === "text")
+    return part.text !== "";
+  if (part.type === "thinking")
+    return part.thinking !== "";
+  return true;
 }
-function installedPluginVersion(bundlePath) {
-  return pluginCacheSegments(bundlePath)?.[2];
+function roleOf(message) {
+  if (message.role !== undefined)
+    return message.role;
+  return message.type === "assistant" ? "assistant" : "user";
 }
-var INLINE_MARKETPLACE = "inline";
-function loadedMarketplace(pluginRoot, bundlePath, commandLine) {
-  if (commandLine !== undefined) {
-    const { argv, cwd } = commandLine;
-    const root = resolve3(pluginRoot);
-    for (let index = 1;index < argv.length; index++) {
-      const argument = argv[index] ?? "";
-      if (argument === "--")
-        break;
-      const equals = argument.indexOf("=");
-      const flag = equals === -1 ? argument : argument.slice(0, equals);
-      if (flag === "--plugin-dir" || flag === "--plugin-dir-no-mcp") {
-        const value = equals === -1 ? argv[index + 1] : argument.slice(equals + 1);
-        if (value !== undefined && resolve3(cwd, value) === root)
-          return INLINE_MARKETPLACE;
+var PANE_SEEDED_COMMAND = "/rename";
+function isPaneSeededRename(line) {
+  return line === PANE_SEEDED_COMMAND || line.startsWith(`${PANE_SEEDED_COMMAND} `);
+}
+function callArguments(args) {
+  if (args === "")
+    return;
+  try {
+    return JSON.parse(args);
+  } catch {
+    return args;
+  }
+}
+function listedModels(rows) {
+  const row = rows.find((candidate) => candidate.key === "model");
+  const options = row?.options ?? [];
+  return options.flatMap((option) => modelReference(CLAUDE_PROVIDER, option) ?? []);
+}
+function claudeAgentStreamCommands(commands) {
+  const listed = [];
+  for (const command of commands) {
+    const name = command.name.startsWith("/") ? command.name.slice(1) : command.name;
+    if (!isTypableCommandName(name))
+      continue;
+    listed.push({
+      name,
+      source: command.source === "builtin" ? "builtin" : command.source === "plugin" ? "extension" : "prompt",
+      ...command.description === "" ? {} : { description: command.description }
+    });
+  }
+  return listed;
+}
+function createClaudeAgentStream(deps) {
+  const { isPane, publisher, now } = deps;
+  const stepAt = new Map;
+  let allocated = 0;
+  let observed;
+  let picked;
+  const timestampFor = (turnId, index) => {
+    const key = `${turnId}\x00${index}`;
+    const kept = stepAt.get(key);
+    if (kept !== undefined)
+      return kept;
+    const at = Math.max(now(), allocated + 1);
+    allocated = at;
+    stepAt.set(key, at);
+    return at;
+  };
+  const record = (subject, message, streaming, dispatchMessageId) => {
+    publisher.record(subject, message, streaming, dispatchMessageId);
+  };
+  const recordRow = (subject, uuid, role, content) => {
+    record(subject, { content, role, tag: uuid, timestamp: now() }, false, deps.tagFor?.(uuid));
+  };
+  const recordStep = (subject, event) => {
+    if (event.effort !== picked)
+      picked = undefined;
+    observed = { model: event.model, effort: event.effort };
+    const content = [];
+    let hiddenThinkingShown = false;
+    for (const part of event.parts) {
+      if (part.type === "text") {
+        content.push({ text: part.text, type: "text" });
+      } else if (part.type === "reasoning") {
+        if (part.text !== "") {
+          content.push({ thinking: part.text, type: "thinking" });
+        } else if (!hiddenThinkingShown) {
+          hiddenThinkingShown = true;
+          content.push({ thinking: CLAUDE_THINKING_HIDDEN, type: "thinking" });
+        }
+      } else {
+        content.push({
+          arguments: callArguments(part.args),
+          id: part.id,
+          name: part.name,
+          type: "toolCall"
+        });
       }
-      if (equals === -1)
-        index = lastValueIndex(argv, index);
     }
-  }
-  return installedMarketplace(bundlePath);
+    record(subject, {
+      content,
+      model: event.model,
+      provider: CLAUDE_PROVIDER,
+      role: "assistant",
+      timestamp: timestampFor(event.turnId, event.index)
+    }, !event.done);
+  };
+  const recordAppend = (subject, event) => {
+    const { door, message, origin, uuid } = event;
+    if (door === "response")
+      return;
+    if (message.isMeta === true && deps.appendedRow?.(uuid) !== true)
+      return;
+    if (isPictureAttachmentRow(message.content))
+      return;
+    if (door === "prompt") {
+      if (deps.runsUnreadPrompt?.(uuid) === true)
+        return;
+      if (isPane && isPaneSeededRename(claudeRowText(message.content)))
+        return;
+      const content = message.content.map(partOf);
+      if (!content.some(shows))
+        return;
+      recordRow(subject, uuid, "user", content);
+      return;
+    }
+    if (door === "tool-result") {
+      for (const block of message.content) {
+        const toolCallId = block["tool_use_id"];
+        if (typeof toolCallId !== "string")
+          continue;
+        record(subject, {
+          content: claudeRowText(block["content"]),
+          isError: block["is_error"] === true,
+          role: "toolResult",
+          timestamp: now(),
+          toolCallId,
+          ...origin.tool === undefined ? {} : { toolName: origin.tool }
+        }, false);
+      }
+      return;
+    }
+    if (door === "command") {
+      const line = claudeEchoedCommandLine(message.content);
+      if (line !== undefined) {
+        if (isPane && isPaneSeededRename(line))
+          return;
+        if (deps.runsCommandRow?.(uuid) === true)
+          return;
+        recordRow(subject, uuid, "user", [{ text: line, type: "text" }]);
+        return;
+      }
+      if (isCommandBookkeeping(message.content))
+        return;
+    }
+    const content = message.content.map(partOf);
+    if (!content.some(shows))
+      return;
+    recordRow(subject, uuid, roleOf(message), content);
+  };
+  return {
+    record(subject, event) {
+      if (event.kind === "step")
+        recordStep(subject, event);
+      else if (event.kind === "append")
+        recordAppend(subject, event);
+    },
+    pickedEffort(effort) {
+      picked = effort;
+    },
+    settings(model, rows) {
+      if (rows === undefined)
+        return { reported: false };
+      const reference = modelReference(CLAUDE_PROVIDER, model);
+      return {
+        models: listedModels(rows),
+        reported: true,
+        thinking: picked !== undefined ? { level: String(picked), levels: CLAUDE_EFFORT_LEVELS } : observed !== undefined && observed.model === model ? observed.effort === undefined ? null : { level: String(observed.effort), levels: CLAUDE_EFFORT_LEVELS } : { level: null, levels: CLAUDE_EFFORT_LEVELS },
+        ...reference === undefined ? {} : { model: reference }
+      };
+    },
+    reset() {
+      stepAt.clear();
+      observed = undefined;
+      picked = undefined;
+    }
+  };
 }
-var AllowedChannelEntry = union([
-  object({ marketplace: string2(), plugin: string2() }),
-  string2().regex(/^[^@]+@[^@]+$/).transform((value) => {
-    const at = value.indexOf("@");
-    return { plugin: value.slice(0, at), marketplace: value.slice(at + 1) };
-  })
-]);
-function allowedEntries(value) {
-  if (!Array.isArray(value))
-    return;
-  return value.flatMap((entry) => {
-    const parsed = AllowedChannelEntry.safeParse(entry);
-    return parsed.success ? [parsed.data] : [];
-  });
+
+// src/bounded-set.ts
+function rememberBounded(remembered, value, max) {
+  remembered.add(value);
+  while (remembered.size > max) {
+    const oldest = remembered.values().next().value;
+    if (oldest === undefined)
+      break;
+    remembered.delete(oldest);
+  }
 }
-function managedSettingsDirectory() {
-  switch (process.platform) {
-    case "darwin":
-      return "/Library/Application Support/ClaudeCode";
-    case "win32":
-      return "C:\\Program Files\\ClaudeCode";
-    default:
-      return "/etc/claude-code";
+function rememberBoundedEntry(remembered, key, value, max) {
+  remembered.set(key, value);
+  while (remembered.size > max) {
+    const oldest = remembered.keys().next().value;
+    if (oldest === undefined)
+      break;
+    remembered.delete(oldest);
   }
 }
-var COMPOSITION_KEYS = new Set([
-  "managedSourcesBehavior",
-  "wslInheritsWindowsSettings"
-]);
-function readChannelSettings(file, asSource = false) {
-  try {
-    const value = JSON.parse(readFileSync6(file, "utf8"));
-    if (typeof value !== "object" || value === null || Array.isArray(value))
+
+// src/agent-stream-runner.ts
+var encoder5 = new TextEncoder;
+var decoder5 = new TextDecoder;
+var AGENT_STREAM_CALL_TIMEOUT_MS = 5000;
+var AGENT_STREAM_RESUBSCRIBE_MS = 1000;
+var AGENT_STREAM_SEEN_ROWS_MAX = 512;
+function startAgentStream(options) {
+  const { connection, link } = options;
+  const now = options.now ?? Date.now;
+  const warn = options.warn ?? ((text) => void process.stderr.write(`envoy-channel: ${text}
+`));
+  const publisher = new AgentStreamPublisher({
+    now,
+    publish: (subject, payload) => connection.publish(subject, encoder5.encode(payload))
+  });
+  const stream = createClaudeAgentStream({
+    isPane: options.isPane === true,
+    now,
+    publisher,
+    ...options.appendedRow === undefined ? {} : { appendedRow: options.appendedRow },
+    ...options.runsCommandRow === undefined ? {} : { runsCommandRow: options.runsCommandRow },
+    ...options.runsUnreadPrompt === undefined ? {} : { runsUnreadPrompt: options.runsUnreadPrompt },
+    ...options.tagFor === undefined ? {} : { tagFor: options.tagFor }
+  });
+  let session = options.sessionId;
+  let subscription;
+  let stopped = false;
+  let model;
+  let configRows;
+  let listedCommands;
+  let readingSettings = false;
+  let readingCommands = false;
+  let viewerAttached = false;
+  let commandsRefreshedOnWatchAt = Number.NEGATIVE_INFINITY;
+  let primed = false;
+  const seenRows = new Set;
+  const readTwice = (uuid) => {
+    if (seenRows.has(uuid))
+      return true;
+    rememberBounded(seenRows, uuid, AGENT_STREAM_SEEN_ROWS_MAX);
+    return false;
+  };
+  const framesSubject = () => agentStreamFramesSubject(session);
+  const publishSettings = () => {
+    publisher.setSettings(framesSubject(), stream.settings(model, configRows));
+  };
+  const publishCommands = () => {
+    if (listedCommands !== undefined)
+      publisher.setCommands(framesSubject(), listedCommands);
+  };
+  const refreshSettings = () => {
+    if (stopped || readingSettings || !link.connected())
       return;
-    if (asSource && Object.keys(value).every((key) => COMPOSITION_KEYS.has(key)))
+    readingSettings = true;
+    Promise.all([
+      link.request("session.model", undefined, { timeoutMs: AGENT_STREAM_CALL_TIMEOUT_MS }),
+      link.request("config.list", undefined, { timeoutMs: AGENT_STREAM_CALL_TIMEOUT_MS })
+    ]).then(([answeredModel, rows]) => {
+      model = answeredModel;
+      configRows = rows;
+      if (!stopped)
+        publishSettings();
+    }).catch((error) => {
+      warn(`the live view could not read this session's model \u2014 ${messageFor(error)}`);
+    }).finally(() => {
+      readingSettings = false;
+    });
+  };
+  const refreshCommands = () => {
+    if (stopped || readingCommands || !link.connected())
       return;
-    const record = value;
-    const behavior = record["managedSourcesBehavior"];
-    return {
-      list: allowedEntries(record["allowedChannelPlugins"]),
-      behavior: typeof behavior === "string" ? behavior : undefined
-    };
-  } catch {
-    return;
+    readingCommands = true;
+    link.request("command.list", undefined, { timeoutMs: AGENT_STREAM_CALL_TIMEOUT_MS }).then((commands) => {
+      listedCommands = claudeAgentStreamCommands(commands);
+      if (!stopped)
+        publishCommands();
+    }).catch((error) => {
+      warn(`the live view could not read this session's commands \u2014 ${messageFor(error)}`);
+    }).finally(() => {
+      readingCommands = false;
+    });
+  };
+  const pump = async (taken, forSession) => {
+    try {
+      for await (const message of taken) {
+        try {
+          const parsed = JSON.parse(decoder5.decode(message.data));
+          if (typeof parsed !== "object" || parsed === null)
+            continue;
+          const request = parsed;
+          if (request.type !== "replay" && request.type !== "watch")
+            continue;
+          refreshSettings();
+          if (request.type === "replay" || !viewerAttached || now() - commandsRefreshedOnWatchAt >= AGENT_STREAM_WATCH_INTERVAL_MS) {
+            refreshCommands();
+            if (request.type === "watch" && viewerAttached)
+              commandsRefreshedOnWatchAt = now();
+          }
+          const reply = message.reply;
+          const answer = request.type === "replay" && reply !== undefined ? JSON.stringify(publisher.replay(forSession)) : undefined;
+          const arming = !publisher.watched;
+          publisher.noteViewer();
+          viewerAttached = true;
+          if (arming)
+            publisher.publishState(agentStreamFramesSubject(forSession));
+          if (answer === undefined || reply === undefined)
+            continue;
+          connection.publish(reply, encoder5.encode(answer));
+        } catch (error) {
+          warn(`a live view control message failed \u2014 ${messageFor(error)}`);
+        }
+      }
+    } catch {}
+    if (subscription === taken)
+      subscription = undefined;
+    if (stopped || session !== forSession)
+      return;
+    const retry = setTimeout(() => {
+      if (stopped || session !== forSession)
+        return;
+      subscribe();
+    }, AGENT_STREAM_RESUBSCRIBE_MS);
+    retry.unref();
+  };
+  function subscribe() {
+    if (stopped)
+      return;
+    subscription?.unsubscribe();
+    const taken = connection.subscribe(agentStreamControlSubject(session));
+    subscription = taken;
+    pump(taken, session);
   }
+  link.onSessionId((next) => {
+    if (stopped || !options.followsSessionId || next === session)
+      return;
+    session = next;
+    publisher.reset();
+    stream.reset();
+    viewerAttached = false;
+    commandsRefreshedOnWatchAt = Number.NEGATIVE_INFINITY;
+    publishSettings();
+    publishCommands();
+    subscribe();
+  });
+  const reading = (async () => {
+    for await (const event of link.events) {
+      if (!primed) {
+        primed = true;
+        refreshSettings();
+        refreshCommands();
+      }
+      if (event.kind === "append" && readTwice(event.uuid))
+        continue;
+      if (event.kind === "model")
+        model = event.model;
+      options.observe?.(event);
+      stream.record(framesSubject(), event);
+      if (event.kind === "step" || event.kind === "model")
+        publishSettings();
+    }
+  })();
+  reading.catch((error) => {
+    warn(`the live view stopped reading this session's events \u2014 ${messageFor(error)}`);
+  });
+  subscribe();
+  return {
+    refresh() {
+      refreshSettings();
+    },
+    pickedEffort(effort) {
+      if (stopped)
+        return;
+      stream.pickedEffort(effort);
+      publishSettings();
+    },
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      subscription?.unsubscribe();
+      subscription = undefined;
+    }
+  };
 }
-function channelAllowlist(directories) {
-  const remote = readChannelSettings(join6(directories.configDirectory, "remote-settings.json"), true);
-  const dropIns = join6(directories.managedDirectory, "managed-settings.d");
-  let dropInFiles = [];
+
+// src/channel-forwarder.ts
+var DeliveryIdentity = DedupeIdentitySchema.extend({
+  event_id: DedupeIdentitySchema.shape.event_id.catch(undefined),
+  dedupe_key: DedupeIdentitySchema.shape.dedupe_key.catch(undefined),
+  source: DedupeIdentitySchema.shape.source.catch(undefined),
+  source_event_id: DedupeIdentitySchema.shape.source_event_id.catch(undefined),
+  topic: string2().min(1).optional().catch(undefined)
+});
+var decoder6 = new TextDecoder;
+var DEFAULT_DRAIN_TIMEOUT_MS = 1000;
+function deliveryIdentity(raw) {
+  let parsed;
   try {
-    dropInFiles = readdirSync3(dropIns).filter((name) => name.endsWith(".json") && !name.startsWith(".")).sort().map((name) => join6(dropIns, name));
+    parsed = JSON.parse(raw);
   } catch {
-    dropInFiles = [];
-  }
-  const files = [join6(directories.managedDirectory, "managed-settings.json"), ...dropInFiles].map((file) => readChannelSettings(file)).filter((settings) => settings !== undefined);
-  const lists = files.map((settings) => settings.list).filter((list) => list !== undefined);
-  const fileList = lists.length === 0 ? undefined : lists.flat();
-  const behavior = remote?.behavior ?? files.find((settings) => settings.behavior)?.behavior;
-  if (remote === undefined)
-    return fileList;
-  return behavior === "merge" ? remote.list ?? fileList : remote.list;
-}
-function detectClaudeChannel(input) {
-  const override = input.environment["ENVOY_CHANNEL_LOADED"]?.trim();
-  if (override === "1")
-    return { loaded: true };
-  if (override === "0")
-    return { loaded: false, why: "ENVOY_CHANNEL_LOADED=0" };
-  const configDirectory = input.environment["CLAUDE_CONFIG_DIR"]?.trim() || join6(homedir3(), ".claude");
-  const commandLine = claudeCommandLine(input.claudePid);
-  const pluginRoot = input.environment["CLAUDE_PLUGIN_ROOT"]?.trim();
-  const plugin = pluginRoot ? {
-    name: "claude-envoy",
-    marketplace: loadedMarketplace(pluginRoot, input.bundlePath, commandLine?.exact && commandLine.cwd !== undefined ? { argv: commandLine.argv, cwd: commandLine.cwd } : undefined)
-  } : undefined;
-  return claudeChannelGate({
-    commandLine,
-    plugin,
-    allowlist: channelAllowlist({ managedDirectory: managedSettingsDirectory(), configDirectory })
-  });
+    return;
+  }
+  const identity = DeliveryIdentity.safeParse(parsed);
+  return identity.success ? identity.data : undefined;
+}
+function report(what, error) {
+  process.stderr.write(`envoy-channel: ${what} \u2014 ${messageFor(error)}
+`);
+}
+function createChannelForwarder(connection, options) {
+  const following = new Map;
+  const dedupe = options.dedupe ?? createDeliveryDedupe();
+  const drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
+  const deliver = async (topic, subscription) => {
+    try {
+      for await (const { message, receivedAt } of readArrivals(subscription)) {
+        const raw = decoder6.decode(message.data);
+        const identity = deliveryIdentity(raw);
+        let claim = options.relayed?.(topic) === true ? undefined : dedupe.claim(identity);
+        if (claim !== undefined && identity !== undefined && options.ledger?.delivered(identity)) {
+          claim.settle();
+          claim = undefined;
+        }
+        const inbound = {
+          subject: message.subject,
+          data: message.data,
+          raw,
+          ...message.reply ? { reply: message.reply } : {},
+          ...identity?.topic === undefined ? {} : { envelopeTopic: identity.topic },
+          ...claim === undefined ? { duplicate: true } : {}
+        };
+        let handed;
+        try {
+          handed = await options.deliver(inbound);
+        } catch (error) {
+          claim?.release();
+          report(`could not deliver a message on ${message.subject}`, error);
+          if (claim !== undefined)
+            options.failed?.(inbound, topic, error, receivedAt);
+          continue;
+        }
+        if (claim === undefined)
+          continue;
+        if (!handed) {
+          claim.release();
+          continue;
+        }
+        const taken = claim;
+        const settle = () => taken.settle();
+        if (identity === undefined || options.ledger === undefined)
+          settle();
+        else
+          options.ledger.recordDelivered(identity).then(settle, settle);
+      }
+    } catch (error) {
+      report(`delivery from ${topic} stopped`, error);
+    }
+  };
+  const stop = async (topics) => {
+    const stopping = topics.flatMap((topic) => {
+      const entry = following.get(topic);
+      if (entry === undefined)
+        return [];
+      following.delete(topic);
+      entry.subscription.unsubscribe();
+      return [entry.done];
+    });
+    await Promise.all(stopping);
+  };
+  return {
+    follow(topic) {
+      for (const subject of expandSubscriptionTopics([topic])) {
+        if (following.has(subject))
+          continue;
+        const subscription = connection.subscribe(subject);
+        following.set(subject, { subscription, done: deliver(subject, subscription) });
+      }
+    },
+    unfollow(topics) {
+      return stop(topics.length === 0 ? [...following.keys()] : expandSubscriptionTopics(topics));
+    },
+    topics() {
+      return [...following.keys()];
+    },
+    isClosed() {
+      return connection.isClosed();
+    },
+    async close() {
+      await stop([...following.keys()]);
+      if (connection.isClosed())
+        return;
+      const timeout = Promise.withResolvers();
+      const timer = setTimeout(timeout.resolve, drainTimeoutMs);
+      try {
+        await Promise.race([connection.drain(), timeout.promise]);
+      } catch (error) {
+        report("draining the broker connection failed", error);
+      }
+      clearTimeout(timer);
+      if (connection.isClosed())
+        return;
+      try {
+        await connection.close();
+      } catch (error) {
+        report("closing the broker connection failed", error);
+      }
+    }
+  };
 }
 
 // src/claude-session.ts
@@ -55833,12 +56230,12 @@ function claudeProjectDirectory(environment, fallback) {
 
 // src/session-identity.ts
 import { readFile as readFile2 } from "fs/promises";
-import { basename as basename3, join as join8 } from "path";
+import { basename as basename2, join as join7 } from "path";
 
 // src/session-state.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { mkdir, readdir, rename, rm, stat, utimes, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join7 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 async function writeAtomicStateFile(file, contents) {
   await mkdir(dirname2(file), { recursive: true, mode: 448 });
   const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
@@ -55856,7 +56253,7 @@ async function pruneStateDirectory(directory, isStale) {
     throw error;
   });
   for (const entry of entries) {
-    const file = join7(directory, entry);
+    const file = join6(directory, entry);
     if (!await isStale(file))
       continue;
     await rm(file, { recursive: true, force: true });
@@ -55871,7 +56268,7 @@ async function writtenLongAgo(file) {
 }
 var TITLES_DIRECTORY = "titles";
 function sessionTitleFile(stateDirectory, sessionId) {
-  return join7(stateDirectory, TITLES_DIRECTORY, `${encodeURIComponent(sessionId)}.txt`);
+  return join6(stateDirectory, TITLES_DIRECTORY, `${encodeURIComponent(sessionId)}.txt`);
 }
 async function writeChosenTitle(file, title) {
   await writeAtomicStateFile(file, `${title}
@@ -55882,7 +56279,7 @@ async function removeChosenTitle(file) {
 }
 function readChosenTitleSync(file) {
   try {
-    return readFileSync7(file, "utf8");
+    return readFileSync6(file, "utf8");
   } catch {
     return;
   }
@@ -55899,7 +56296,7 @@ async function recordChosenTitle(sessionId, title) {
     await writeChosenTitle(file, chosen);
 }
 async function pruneStaleSessionTitles(stateDirectory) {
-  await pruneStateDirectory(join7(stateDirectory, TITLES_DIRECTORY), writtenLongAgo);
+  await pruneStateDirectory(join6(stateDirectory, TITLES_DIRECTORY), writtenLongAgo);
 }
 
 // src/session-identity.ts
@@ -55924,14 +56321,14 @@ class SessionIdentity {
   }
 }
 function sessionHandoffDirectory(stateDirectory, claudePid) {
-  return join8(stateDirectory, "sessions", String(claudePid));
+  return join7(stateDirectory, "sessions", String(claudePid));
 }
 function sessionHandoffFile(stateDirectory, claudePid) {
-  return join8(sessionHandoffDirectory(stateDirectory, claudePid), "session-id");
+  return join7(sessionHandoffDirectory(stateDirectory, claudePid), "session-id");
 }
 var ROLES_DIRECTORY = "roles";
 function roleStateFile(stateDirectory, sessionId) {
-  return join8(stateDirectory, ROLES_DIRECTORY, `${encodeURIComponent(sessionId)}.json`);
+  return join7(stateDirectory, ROLES_DIRECTORY, `${encodeURIComponent(sessionId)}.json`);
 }
 
 class UnparseableRoleRecordError extends Error {
@@ -55982,14 +56379,14 @@ function processExists(pid) {
   }
 }
 async function pruneStaleSessionHandoffs(stateDirectory) {
-  await pruneStateDirectory(join8(stateDirectory, "sessions"), (file) => {
-    const pid = basename3(file);
+  await pruneStateDirectory(join7(stateDirectory, "sessions"), (file) => {
+    const pid = basename2(file);
     return /^\d+$/.test(pid) && !processExists(Number(pid));
   });
 }
 async function pruneStaleSessionRoles(stateDirectory, currentSessionId) {
   const own = roleStateFile(stateDirectory, currentSessionId);
-  await pruneStateDirectory(join8(stateDirectory, ROLES_DIRECTORY), async (file) => file !== own && await writtenLongAgo(file));
+  await pruneStateDirectory(join7(stateDirectory, ROLES_DIRECTORY), async (file) => file !== own && await writtenLongAgo(file));
 }
 
 // src/envoy-off.ts
@@ -56005,6 +56402,15 @@ function inboundOffChannelSession(options) {
     onRoleRegained: () => {
       return;
     },
+    capabilitiesChanged: () => {
+      return;
+    },
+    observe: () => {
+      return;
+    },
+    messageOf: () => {
+      return;
+    },
     async rememberRole(role) {
       await writePersistedRole(roleStateFile(stateDirectory, identity.id), {
         session_id: identity.id,
@@ -56037,9 +56443,23 @@ async function serveEnvoyOff(serverInfo, refusal) {
   }
 }
 
+// src/installed-build.ts
+import { sep } from "path";
+function pluginCacheSegments(bundlePath) {
+  const parts = bundlePath.split(sep);
+  for (let index = 0;index + 1 < parts.length; index++) {
+    if (parts[index] === "plugins" && parts[index + 1] === "cache")
+      return parts.slice(index + 2);
+  }
+  return;
+}
+function installedPluginVersion(bundlePath) {
+  return pluginCacheSegments(bundlePath)?.[2];
+}
+
 // src/legion-claim.ts
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join8 } from "path";
 import { setTimeout as delay } from "timers/promises";
 
 // ../pi-shared/src/legion-claim-core.ts
@@ -56125,12 +56545,12 @@ function stopPane(why) {
   endPane();
 }
 async function waitForTranscript(configDir, sessionID, signal, pollMs = 100) {
-  const projects = join9(configDir, "projects");
+  const projects = join8(configDir, "projects");
   const name = `${sessionID}.jsonl`;
   for (;; ) {
     signal.throwIfAborted();
     for (const directory of await readdir2(projects).catch(() => [])) {
-      const file = join9(projects, directory, name);
+      const file = join8(projects, directory, name);
       if (await isFile(file))
         return file;
     }
@@ -56278,10 +56698,14 @@ function createInboxNotifier(socketPath) {
   };
   return {
     notification(notification) {
-      const id = notification.params.meta["event_id"] ?? randomUUID2();
+      const id = notification.eventId ?? randomUUID2();
       const settle = Promise.withResolvers();
       waiting.push({ id, settle });
-      connected().write(`${JSON.stringify({ id, content: notification.params.content })}
+      connected().write(`${JSON.stringify({
+        id,
+        content: notification.content,
+        ...notification.blocks === undefined ? {} : { blocks: notification.blocks }
+      })}
 `);
       return settle.promise;
     }
@@ -56290,8 +56714,8 @@ function createInboxNotifier(socketPath) {
 
 // src/legion-phase-hook.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { readFileSync as readFileSync7, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, join as join9 } from "path";
 
 // ../pi-shared/src/phase-reminder.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -56756,7 +57180,7 @@ function phaseHookToolDefinition() {
   };
 }
 function phaseStallFile(configDir, sessionID) {
-  return join10(configDir, `legion-phase-stall-${sessionID}.json`);
+  return join9(configDir, `legion-phase-stall-${sessionID}.json`);
 }
 function paneReminderLog(write) {
   const line = (level, message, context) => {
@@ -56771,7 +57195,7 @@ var NO_RECORD = { entry: undefined, recreatedNoticeSent: false };
 function readPhaseStallRecord(file, log) {
   let raw;
   try {
-    raw = readFileSync8(file, "utf8");
+    raw = readFileSync7(file, "utf8");
   } catch (error) {
     const missing = typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
     if (!missing) {
@@ -56809,7 +57233,7 @@ function readPhaseStallRecord(file, log) {
   };
 }
 function writePhaseStallRecord(file, entry, recreatedNoticeSent, log) {
-  const temporary = join10(dirname3(file), `.legion-phase-stall-${randomUUID4()}`);
+  const temporary = join9(dirname3(file), `.legion-phase-stall-${randomUUID4()}`);
   try {
     writeFileSync4(temporary, JSON.stringify({ ...entry, ...recreatedNoticeSent ? { recreatedNoticeSent } : {} }), { mode: 384 });
     renameSync3(temporary, file);
@@ -57204,84 +57628,699 @@ async function completeHandoff(runtime, args) {
       if (args.ready === true) {
         throw new Error("handoff_complete on a production check is no READY: leave ready out");
       }
-      if (claim.role !== check.role) {
-        throw new Error(`${claim.issue}'s production check is the ${check.role}'s, and this session is the ${claim.role}'s: only the role the check records reports on it`);
+      if (claim.role !== check.role) {
+        throw new Error(`${claim.issue}'s production check is the ${check.role}'s, and this session is the ${claim.role}'s: only the role the check records reports on it`);
+      }
+      if (args.verdict === "pending" && args.wake_at === undefined && !check.last) {
+        throw new Error(`handoff_complete's pending report names wake_at, when the next look of ${claim.issue}'s production check is due`);
+      }
+      if (args.wake_at !== undefined && (args.verdict !== "pending" || check.last)) {
+        const why = args.verdict === "pending" ? `look ${check.looks} is the check's last, after which the check closes as not run` : `a ${args.verdict} report closes the check`;
+        throw new Error(`handoff_complete names wake_at and no look follows it: ${why}; send it again without a time`);
+      }
+    }
+    return daemon.handoffComplete({
+      grantId: await mintClaimGrant(daemon, claim),
+      summary: args.summary,
+      verdict: args.verdict ?? "",
+      ready: false,
+      ...args.wake_at === undefined ? {} : { wakeAt: args.wake_at }
+    });
+  }
+  if (args.verdict === "pending") {
+    throw new Error("handoff_complete's verdict is pass or fail on a phase completion; pending is a production check's");
+  }
+  if (args.wake_at !== undefined) {
+    throw new Error("handoff_complete's wake_at is a production check's pending report alone; a phase completion carries none");
+  }
+  const report = await runtime.handoffReport(record.phase, claim.role);
+  return daemon.handoffComplete({
+    grantId: await mintClaimGrant(daemon, claim),
+    summary: args.summary,
+    verdict: args.verdict ?? "",
+    ready: args.ready ?? false,
+    ...report
+  });
+}
+
+// src/legion-tool.ts
+var LEGION_TOOL_NAME = "legion";
+function legionToolDefinition() {
+  return {
+    name: LEGION_TOOL_NAME,
+    description: legionToolDescription({
+      envoyPublish: "mcp__legion__envoy_publish",
+      before: PHASE_OP_SENTENCES.readRecord + PHASE_OP_SENTENCES.readReleaseRecords,
+      after: PHASE_OP_SENTENCES.requestBackwardMove
+    }),
+    inputSchema: toJSONSchema(object({ op: _enum2(PHASE_OPS), ...phaseOpParameters(exports_external) }))
+  };
+}
+async function executeLegionTool(runtime, input, signal) {
+  const claim = runtime.claim();
+  if (claim === undefined) {
+    throw new Error("this session has no Legion claim yet: the pane registers with the daemon once its first turn starts");
+  }
+  return executePhaseOp({
+    daemon: runtime.daemon,
+    claim,
+    handoffReport: runtime.handoffReport,
+    branchHead: runtime.branchHead,
+    ...signal === undefined ? {} : { restart: { signal } }
+  }, input);
+}
+
+// src/mod-link.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { chmod, lstat as lstat2, mkdir as mkdir2, stat as stat3, unlink } from "fs/promises";
+import {
+  createServer,
+  request as httpRequest
+} from "http";
+import { dirname as dirname4 } from "path";
+
+// hooks/mod-protocol.ts
+var MOD_HEALTH_MARKER = "claude-envoy-mod";
+var MOD_POLL_HOLD_MS = 5000;
+var MOD_URL_BASE = "http://claude-envoy";
+var MOD_ROUTE_HEALTH = "/healthz";
+var MOD_ROUTE_EVENTS = "/events";
+var MOD_ROUTE_RESULTS = "/results";
+var MOD_ROUTE_REQUESTS = "/requests";
+var MOD_SOCKET_PATH_MAX_BYTES = 100;
+var MOD_STATUS_TAKEN = 409;
+var MOD_INSTANCE_HEADER = "x-claude-envoy-mod";
+var MOD_SOCKET_RUNTIME_VARIABLE = "XDG_RUNTIME_DIR";
+var MOD_SOCKET_CONFIG_VARIABLE = "CLAUDE_CONFIG_DIR";
+var MOD_SOCKET_HOME_VARIABLE = "HOME";
+var MOD_SOCKET_HOME_CONFIG = "/.claude";
+var MOD_PLUGIN_NAME = "claude-envoy";
+var MOD_SOCKET_DIRECTORY = MOD_PLUGIN_NAME;
+var MOD_HASH_PRIME_HIGH = 256;
+var MOD_HASH_PRIME_LOW = 403;
+function utf8Length(value) {
+  let bytes = 0;
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    bytes += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+  }
+  return bytes;
+}
+function fnv1a32(value, basis) {
+  let hash = basis;
+  for (let index = 0;index < value.length; index += 1) {
+    hash = (hash ^ value.charCodeAt(index)) >>> 0;
+    const low = hash & 65535;
+    const high = hash >>> 16;
+    const carried = high * MOD_HASH_PRIME_LOW + low * MOD_HASH_PRIME_HIGH & 65535;
+    hash = low * MOD_HASH_PRIME_LOW + (carried << 16) >>> 0;
+  }
+  return hash;
+}
+function hashedSessionId(sessionId) {
+  const first = fnv1a32(sessionId, 2166136261);
+  const second = fnv1a32(sessionId, 3421674724);
+  return `${first.toString(16).padStart(8, "0")}${second.toString(16).padStart(8, "0")}`;
+}
+function isPathSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\x00");
+}
+function withoutTrailingSlash(base) {
+  let end = base.length;
+  while (end > 1 && base[end - 1] === "/")
+    end -= 1;
+  return end === 1 ? "" : base.slice(0, end);
+}
+function absoluteBase(value) {
+  if (value === undefined || value.length === 0 || !value.startsWith("/"))
+    return;
+  return withoutTrailingSlash(value);
+}
+function socketBases(env) {
+  const bases = [];
+  const runtime = absoluteBase(env[MOD_SOCKET_RUNTIME_VARIABLE]);
+  if (runtime !== undefined)
+    bases.push(runtime);
+  const configured = absoluteBase(env[MOD_SOCKET_CONFIG_VARIABLE]);
+  const home = absoluteBase(env[MOD_SOCKET_HOME_VARIABLE]);
+  if (configured !== undefined)
+    bases.push(configured);
+  else if (home !== undefined)
+    bases.push(`${home}${MOD_SOCKET_HOME_CONFIG}`);
+  return bases;
+}
+function resolveModSocketPath(sessionId, env) {
+  if (!isPathSegment(sessionId)) {
+    return {
+      refusal: `${JSON.stringify(sessionId)} is not a plain path segment, so it names no socket of its own`
+    };
+  }
+  const file = `/${MOD_SOCKET_DIRECTORY}/ce-${hashedSessionId(sessionId)}.sock`;
+  const tried = [];
+  for (const base of socketBases(env)) {
+    const path = `${base}${file}`;
+    if (utf8Length(path) <= MOD_SOCKET_PATH_MAX_BYTES)
+      return { path };
+    tried.push(path);
+  }
+  return {
+    refusal: tried.length === 0 ? `none of ${MOD_SOCKET_RUNTIME_VARIABLE}, ${MOD_SOCKET_CONFIG_VARIABLE} and ${MOD_SOCKET_HOME_VARIABLE} names an absolute directory only this user can create in, and a session's socket never goes in a base other users share` : `every private base makes a socket path longer than ${MOD_SOCKET_PATH_MAX_BYTES} bytes (${tried.join(", ")})`
+  };
+}
+
+// src/mod-link.ts
+var MOD_REQUEST_TIMEOUT_MS = 30000;
+var MOD_PROBE_TIMEOUT_MS = 1000;
+var MOD_EVENT_BUFFER = 2048;
+var MOD_HOST = new URL(MOD_URL_BASE).host;
+function probeHealth(socketPath, timeoutMs) {
+  const { promise, resolve } = Promise.withResolvers();
+  const probe = httpRequest({
+    socketPath,
+    path: MOD_ROUTE_HEALTH,
+    method: "GET",
+    headers: { host: MOD_HOST },
+    timeout: timeoutMs
+  }, (response) => {
+    let body = "";
+    response.setEncoding("utf8");
+    response.on("data", (chunk) => {
+      body += chunk;
+    });
+    response.on("end", () => {
+      if (response.statusCode !== 200) {
+        resolve(false);
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        resolve(false);
+        return;
+      }
+      if (typeof parsed !== "object" || parsed === null || !("link" in parsed)) {
+        resolve(false);
+        return;
+      }
+      resolve(parsed.link === MOD_HEALTH_MARKER);
+    });
+  });
+  probe.on("error", () => resolve(false));
+  probe.on("timeout", () => {
+    probe.destroy();
+    resolve(false);
+  });
+  probe.end();
+  return promise;
+}
+function readEvents(body) {
+  if (typeof body !== "object" || body === null || !("events" in body))
+    return;
+  const events = body.events;
+  if (!Array.isArray(events))
+    return;
+  return events.filter((event) => typeof event === "object" && event !== null && ("kind" in event) && typeof event.kind === "string");
+}
+function readResults(body) {
+  if (typeof body !== "object" || body === null || !("results" in body))
+    return;
+  const results = body.results;
+  if (!Array.isArray(results))
+    return;
+  return results.filter((result) => typeof result === "object" && result !== null && ("id" in result) && typeof result.id === "string" && ("ok" in result) && typeof result.ok === "boolean");
+}
+function createEventStream(limit) {
+  const buffered = [];
+  let waiting;
+  let ended = false;
+  const iterator = {
+    [Symbol.asyncIterator]() {
+      return iterator;
+    },
+    next() {
+      const next = buffered.shift();
+      if (next !== undefined)
+        return Promise.resolve({ value: next, done: false });
+      if (ended)
+        return Promise.resolve({ value: undefined, done: true });
+      const { promise, resolve } = Promise.withResolvers();
+      waiting = resolve;
+      return promise;
+    }
+  };
+  return {
+    iterator,
+    push(event) {
+      if (ended)
+        return;
+      const settle = waiting;
+      if (settle !== undefined) {
+        waiting = undefined;
+        settle({ value: event, done: false });
+        return;
+      }
+      buffered.push(event);
+      if (buffered.length > limit)
+        buffered.splice(0, buffered.length - limit);
+    },
+    end() {
+      if (ended)
+        return;
+      ended = true;
+      const settle = waiting;
+      if (settle !== undefined) {
+        waiting = undefined;
+        settle({ value: undefined, done: true });
+      }
+    }
+  };
+}
+async function exists(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function privateDirectory(path) {
+  await mkdir2(path, { recursive: true, mode: 448 });
+  const directory = await lstat2(path);
+  if (!directory.isDirectory()) {
+    throw new Error(`${path} is not a directory of its own, so the socket has no private home`);
+  }
+  const user = process.getuid?.();
+  if (user !== undefined && directory.uid !== user) {
+    throw new Error(`${path} belongs to uid ${directory.uid}, not to this user (uid ${user})`);
+  }
+  if ((directory.mode & 63) !== 0) {
+    throw new Error(`${path} is mode ${(directory.mode & 511).toString(8)}, which lets another user into this session's socket; chmod 700 it`);
+  }
+}
+async function bind(server, socketPath) {
+  await privateDirectory(dirname4(socketPath));
+  if (await exists(socketPath)) {
+    if (await probeHealth(socketPath, MOD_PROBE_TIMEOUT_MS)) {
+      throw new Error(`another claude-envoy server already serves this session at ${socketPath}`);
+    }
+    await unlink(socketPath).catch(() => {
+      return;
+    });
+  }
+  const { promise, resolve, reject } = Promise.withResolvers();
+  server.once("error", reject);
+  server.listen(socketPath, () => {
+    server.removeListener("error", reject);
+    resolve();
+  });
+  await promise;
+  await chmod(socketPath, 384);
+}
+async function startModLink(options) {
+  const resolved = resolveModSocketPath(options.sessionId, options.env);
+  if (resolved.path === undefined) {
+    throw new Error(`no socket path for this session: ${resolved.refusal}`);
+  }
+  const socketPath = resolved.path;
+  const stream = createEventStream(MOD_EVENT_BUFFER);
+  const queued = [];
+  const held = new Set;
+  const pending = new Map;
+  const sessionIdListeners = [];
+  const connectedListeners = [];
+  const warn = options.warn ?? ((text) => {
+    process.stderr.write(`claude-envoy: ${text}
+`);
+  });
+  let instance;
+  let reportedSessionId;
+  let lastPollAt = 0;
+  let closed = false;
+  const isConnected = () => !closed && (held.size > 0 || Date.now() - lastPollAt < MOD_POLL_HOLD_MS * 2);
+  const heard = () => {
+    const before = isConnected();
+    lastPollAt = Date.now();
+    if (!before)
+      for (const listener of connectedListeners)
+        listener();
+  };
+  const reportSessionId = (sessionId) => {
+    if (sessionId === reportedSessionId)
+      return;
+    reportedSessionId = sessionId;
+    for (const listener of sessionIdListeners)
+      listener(sessionId);
+  };
+  const wake = () => {
+    const [poll] = held;
+    if (poll === undefined || queued.length === 0)
+      return;
+    held.delete(poll);
+    clearTimeout(poll.timer);
+    poll.answer(queued.splice(0, queued.length));
+  };
+  const answerJson = (response, status, body) => {
+    const text = JSON.stringify(body);
+    response.writeHead(status, {
+      "content-type": "application/json",
+      "content-length": Buffer.byteLength(text)
+    });
+    response.end(text);
+  };
+  const readBody = (incoming) => {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    let body = "";
+    incoming.setEncoding("utf8");
+    incoming.on("data", (chunk) => {
+      body += chunk;
+    });
+    incoming.on("end", () => resolve(body));
+    incoming.on("error", reject);
+    return promise;
+  };
+  const serve = async (incoming, response) => {
+    const route = (incoming.url ?? "").split("?")[0];
+    if (route === MOD_ROUTE_HEALTH && incoming.method === "GET") {
+      answerJson(response, 200, { link: MOD_HEALTH_MARKER });
+      return;
+    }
+    if (incoming.method !== "POST" || route !== MOD_ROUTE_EVENTS && route !== MOD_ROUTE_RESULTS && route !== MOD_ROUTE_REQUESTS) {
+      answerJson(response, 404, { error: `no route ${incoming.method ?? ""} ${route ?? ""}` });
+      return;
+    }
+    const named = incoming.headers[MOD_INSTANCE_HEADER];
+    const mod = typeof named === "string" ? named : undefined;
+    if (mod !== undefined) {
+      instance ??= mod;
+      if (instance !== mod) {
+        warn(`a second Claude Code mod (${mod}) posted to a link mod ${instance} holds, so two processes booted on one session id; it is refused and stops (${socketPath})`);
+        answerJson(response, MOD_STATUS_TAKEN, {
+          error: `this session's link belongs to mod ${instance}`
+        });
+        return;
+      }
+    }
+    const text = await readBody(incoming);
+    let body;
+    try {
+      body = text.length === 0 ? {} : JSON.parse(text);
+    } catch {
+      answerJson(response, 400, { error: "the body is not JSON" });
+      return;
+    }
+    if (route === MOD_ROUTE_EVENTS) {
+      heard();
+      const events = readEvents(body);
+      if (events === undefined) {
+        answerJson(response, 400, { error: "the body carries no events" });
+        return;
+      }
+      for (const event of events) {
+        if (event.kind === "hello" || event.kind === "session-id")
+          reportSessionId(event.sessionId);
+        stream.push(event);
+      }
+      answerJson(response, 200, { ok: true });
+      return;
+    }
+    if (route === MOD_ROUTE_RESULTS) {
+      const results = readResults(body);
+      if (results === undefined) {
+        answerJson(response, 400, { error: "the body carries no results" });
+        return;
+      }
+      for (const result of results) {
+        const waiting = pending.get(result.id);
+        if (waiting === undefined)
+          continue;
+        pending.delete(result.id);
+        clearTimeout(waiting.timer);
+        if (result.ok)
+          waiting.settle.resolve(result.value);
+        else
+          waiting.settle.reject(new Error(`the mod could not ${waiting.call}: ${result.error}`));
+      }
+      answerJson(response, 200, { ok: true });
+      return;
+    }
+    heard();
+    if (queued.length > 0 || closed) {
+      answerJson(response, 200, {
+        requests: queued.splice(0, queued.length)
+      });
+      return;
+    }
+    const poll = {
+      answer: (requests) => answerJson(response, 200, { requests }),
+      timer: setTimeout(() => {
+        held.delete(poll);
+        answerJson(response, 200, { requests: [] });
+      }, MOD_POLL_HOLD_MS)
+    };
+    poll.timer.unref();
+    held.add(poll);
+    incoming.on("close", () => {
+      if (held.delete(poll))
+        clearTimeout(poll.timer);
+    });
+  };
+  const server = createServer((incoming, response) => {
+    serve(incoming, response).catch(() => {
+      if (response.headersSent)
+        response.end();
+      else
+        answerJson(response, 500, { error: "the mod link failed" });
+    });
+  });
+  await bind(server, socketPath);
+  const close = async () => {
+    if (closed)
+      return;
+    closed = true;
+    for (const waiting of pending.values()) {
+      clearTimeout(waiting.timer);
+      waiting.settle.reject(new Error("the mod link closed before the mod answered"));
+    }
+    pending.clear();
+    queued.length = 0;
+    for (const poll of held) {
+      clearTimeout(poll.timer);
+      poll.answer([]);
+    }
+    held.clear();
+    stream.end();
+    server.closeAllConnections();
+    const { promise, resolve } = Promise.withResolvers();
+    server.close(() => resolve());
+    await promise;
+    await unlink(socketPath).catch(() => {
+      return;
+    });
+  };
+  return {
+    socketPath,
+    events: stream.iterator,
+    request(call, args, requestOptions) {
+      if (closed)
+        return Promise.reject(new Error("the mod link is closed"));
+      const timeoutMs = requestOptions?.timeoutMs ?? MOD_REQUEST_TIMEOUT_MS;
+      const id = randomUUID5();
+      const settle = Promise.withResolvers();
+      const request = { id, call, args };
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        const waiting = queued.indexOf(request);
+        if (waiting !== -1)
+          queued.splice(waiting, 1);
+        settle.reject(new Error(`the mod did not answer ${call} within ${timeoutMs} ms`));
+      }, timeoutMs);
+      timer.unref();
+      pending.set(id, { call, settle, timer });
+      queued.push(request);
+      wake();
+      return settle.promise;
+    },
+    sessionId: () => reportedSessionId,
+    onSessionId(listener) {
+      sessionIdListeners.push(listener);
+    },
+    connected: isConnected,
+    onConnected(listener) {
+      connectedListeners.push(listener);
+    },
+    close
+  };
+}
+
+// src/mod-session.ts
+var SHOW_TIMEOUT_MS = 30000;
+var COMMAND_TIMEOUT_MS2 = 24 * 60 * 60 * 1000;
+var FORK_TIMEOUT_MS = 10 * 60 * 1000;
+var COMMAND_OUTPUT_MS = 2000;
+var COMMAND_ECHO_MS = 1000;
+var CLAIMED_ROWS_MAX = 64;
+var MODEL_CONFIG_KEY = "model";
+function resultOutput(result) {
+  if (result.text !== undefined && result.text.trim() !== "")
+    return result.text;
+  const context = result.context?.join(`
+
+`);
+  return context !== undefined && context.trim() !== "" ? context : undefined;
+}
+function modSession(options) {
+  const { link, warn } = options;
+  const commandRuns = [];
+  const claimedEchoes = new Set;
+  const claimedUnreadPrompts = new Set;
+  const claimedAppends = new Set;
+  let behindEcho;
+  const outputMs = options.commandOutputMs ?? COMMAND_OUTPUT_MS;
+  const echoMs = options.commandEchoMs ?? COMMAND_ECHO_MS;
+  const showMs = options.showMs ?? SHOW_TIMEOUT_MS;
+  const runsCommandRow = (row) => claimedEchoes.has(row);
+  const runsUnreadPrompt = (row) => claimedUnreadPrompts.has(row);
+  const appendedRow = (row) => claimedAppends.has(row);
+  const commandRow = (uuid, content) => {
+    if (claudeEchoedCommandLine(content) !== undefined) {
+      const claiming = commandRuns.find((waiting) => waiting.claiming);
+      behindEcho = claiming;
+      if (claiming === undefined)
+        return;
+      claiming.claiming = false;
+      claiming.echo = uuid;
+      rememberBounded(claimedEchoes, uuid, CLAIMED_ROWS_MAX);
+      claiming.claimed?.();
+      return;
+    }
+    const run = behindEcho;
+    behindEcho = undefined;
+    const output = claudeCommandOutput(content);
+    if (output === undefined || run === undefined)
+      return;
+    run.output = output;
+    run.arrived?.();
+  };
+  const endRun = (run) => {
+    const at = commandRuns.indexOf(run);
+    if (at !== -1)
+      commandRuns.splice(at, 1);
+  };
+  const commandRowsOf = async (run) => {
+    try {
+      const echoed = Promise.withResolvers();
+      const echoTimer = setTimeout(echoed.resolve, echoMs);
+      echoTimer.unref();
+      run.claimed = () => {
+        clearTimeout(echoTimer);
+        echoed.resolve();
+      };
+      run.claiming = true;
+      await echoed.promise;
+      run.claiming = false;
+      if (run.echo === undefined)
+        return "";
+      if (run.output === undefined) {
+        const waited = Promise.withResolvers();
+        const timer = setTimeout(waited.resolve, outputMs);
+        timer.unref();
+        run.arrived = () => {
+          clearTimeout(timer);
+          waited.resolve();
+        };
+        await waited.promise;
+      }
+      return run.output ?? "";
+    } finally {
+      endRun(run);
+    }
+  };
+  const written = async (message, content, eventId) => await link.request("session.message", { content, message, ...eventId === undefined ? {} : { eventId } }, { timeoutMs: showMs });
+  return {
+    connected: () => link.connected(),
+    observe(event) {
+      if (event.kind !== "append")
+        return;
+      if (event.door === "command")
+        commandRow(event.uuid, event.message.content);
+      if (event.wrote === "message")
+        rememberBounded(claimedAppends, event.uuid, CLAIMED_ROWS_MAX);
+      if (event.wrote === "pointer") {
+        rememberBounded(claimedUnreadPrompts, event.uuid, CLAIMED_ROWS_MAX);
+      }
+    },
+    async show({ text, content, eventId }) {
+      const answer = await written({ kind: "card", text }, content, eventId);
+      if (answer.deny !== undefined)
+        throw new Error(`the session refused the card: ${answer.deny}`);
+    },
+    async deliver({ text, messageId, content, eventId, failed }) {
+      let answer;
+      try {
+        answer = await written({ kind: "person", messageId, text }, content, eventId);
+      } catch (error) {
+        warn(`a message from Dispatch did not enter this session \u2014 ${messageFor(error)}`);
+        throw error;
+      }
+      if (answer.deny !== undefined) {
+        const refusal = new Error(`the session dropped the prompt: ${answer.deny}`);
+        if (answer.as !== "prompt" || failed === undefined)
+          throw refusal;
+        warn(`a message from Dispatch did not enter this session \u2014 ${messageFor(refusal)}`);
+        failed(refusal);
+        return;
       }
-      if (args.verdict === "pending" && args.wake_at === undefined && !check.last) {
-        throw new Error(`handoff_complete's pending report names wake_at, when the next look of ${claim.issue}'s production check is due`);
+      return answer.as === "row" ? answer.uuid : undefined;
+    },
+    appendedRow,
+    runsCommandRow,
+    runsUnreadPrompt,
+    async runCommand(command, args) {
+      const run = { claiming: false };
+      commandRuns.push(run);
+      let result;
+      try {
+        result = await link.request("command.run", { command, ...args === "" ? {} : { args } }, { timeoutMs: COMMAND_TIMEOUT_MS2 });
+      } catch (error) {
+        endRun(run);
+        throw error;
       }
-      if (args.wake_at !== undefined && (args.verdict !== "pending" || check.last)) {
-        const why = args.verdict === "pending" ? `look ${check.looks} is the check's last, after which the check closes as not run` : `a ${args.verdict} report closes the check`;
-        throw new Error(`handoff_complete names wake_at and no look follows it: ${why}; send it again without a time`);
+      const rows = commandRowsOf(run);
+      return resultOutput(result) ?? await rows;
+    },
+    async fork(prompt) {
+      const result = await link.request("model.fork", { prompt }, { timeoutMs: FORK_TIMEOUT_MS });
+      if (!result.isAnswered)
+        throw new Error(result.reason);
+      return result.text;
+    },
+    async setModel(model) {
+      const result = await link.request("config.set", { key: MODEL_CONFIG_KEY, value: model });
+      if (result.deny !== undefined) {
+        throw new Error(`the session refused the model: ${result.deny}`);
       }
+      return result.value;
+    },
+    async setEffort(effort) {
+      const result = await link.request("set-effort", { effort });
+      return result.effort;
     }
-    return daemon.handoffComplete({
-      grantId: await mintClaimGrant(daemon, claim),
-      summary: args.summary,
-      verdict: args.verdict ?? "",
-      ready: false,
-      ...args.wake_at === undefined ? {} : { wakeAt: args.wake_at }
-    });
-  }
-  if (args.verdict === "pending") {
-    throw new Error("handoff_complete's verdict is pass or fail on a phase completion; pending is a production check's");
-  }
-  if (args.wake_at !== undefined) {
-    throw new Error("handoff_complete's wake_at is a production check's pending report alone; a phase completion carries none");
-  }
-  const report = await runtime.handoffReport(record.phase, claim.role);
-  return daemon.handoffComplete({
-    grantId: await mintClaimGrant(daemon, claim),
-    summary: args.summary,
-    verdict: args.verdict ?? "",
-    ready: args.ready ?? false,
-    ...report
-  });
-}
-
-// src/legion-tool.ts
-var LEGION_TOOL_NAME = "legion";
-function legionToolDefinition() {
-  return {
-    name: LEGION_TOOL_NAME,
-    description: legionToolDescription({
-      envoyPublish: "mcp__legion__envoy_publish",
-      before: PHASE_OP_SENTENCES.readRecord + PHASE_OP_SENTENCES.readReleaseRecords,
-      after: PHASE_OP_SENTENCES.requestBackwardMove
-    }),
-    inputSchema: toJSONSchema(object({ op: _enum2(PHASE_OPS), ...phaseOpParameters(exports_external) }))
   };
 }
-async function executeLegionTool(runtime, input, signal) {
-  const claim = runtime.claim();
-  if (claim === undefined) {
-    throw new Error("this session has no Legion claim yet: the pane registers with the daemon once its first turn starts");
-  }
-  return executePhaseOp({
-    daemon: runtime.daemon,
-    claim,
-    handoffReport: runtime.handoffReport,
-    branchHead: runtime.branchHead,
-    ...signal === undefined ? {} : { restart: { signal } }
-  }, input);
-}
 
 // src/replay-state.ts
+import { join as join10 } from "path";
+
+// src/state-file.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join11 } from "path";
-var ReplayStateFileSchema = ReplaySnapshotSchema.extend({
-  consumer: ConsumerDeliverySnapshotSchema.optional()
-});
-function replayStateFile(stateDirectory, sessionId) {
-  return join11(stateDirectory, `replay-${encodeURIComponent(sessionId)}.json`);
-}
-async function readReplayState(file) {
+async function readStateFile(file, schema, empty, refusal) {
   let text;
   try {
     text = await readFile3(file, "utf8");
   } catch (error) {
     if (hasErrnoCode(error, "ENOENT"))
-      return { ledger: [] };
+      return empty;
     throw error;
   }
   let parsed;
@@ -57290,10 +58329,21 @@ async function readReplayState(file) {
   } catch {
     throw new Error(`${file} is not JSON`);
   }
-  const snapshot = ReplayStateFileSchema.safeParse(parsed);
-  if (!snapshot.success)
-    throw new Error(`${file} holds no replay state`);
-  return snapshot.data;
+  const state = schema.safeParse(parsed);
+  if (!state.success)
+    throw new Error(`${file} ${refusal}`);
+  return state.data;
+}
+
+// src/replay-state.ts
+var ReplayStateFileSchema = ReplaySnapshotSchema.extend({
+  consumer: ConsumerDeliverySnapshotSchema.optional()
+});
+function replayStateFile(stateDirectory, sessionId) {
+  return join10(stateDirectory, `replay-${encodeURIComponent(sessionId)}.json`);
+}
+async function readReplayState(file) {
+  return await readStateFile(file, ReplayStateFileSchema, { ledger: [] }, "holds no replay state");
 }
 async function writeReplayState(file, state) {
   await writeAtomicStateFile(file, `${JSON.stringify(state)}
@@ -57318,16 +58368,16 @@ function replayStateWriter(file, restored) {
 }
 
 // src/session-title.ts
-import { basename as basename4 } from "path";
+import { basename as basename3 } from "path";
 
 // ../envoy-client/src/process-ancestry.ts
 import { execFileSync } from "child_process";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 var MAX_ANCESTORS = 64;
 var PARENT_LOOKUP_MS = 1000;
 function procParentPid(pid) {
   try {
-    const stat = readFileSync9(`/proc/${pid}/stat`, "utf8");
+    const stat = readFileSync8(`/proc/${pid}/stat`, "utf8");
     const parent = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
     return Number.isInteger(parent) ? parent : undefined;
   } catch {
@@ -57457,7 +58507,7 @@ async function sessionTitle(environment, directory, sources = {}) {
     return () => explicit;
   const { serverPid, socket } = tmuxServer(configuredValue(environment.TMUX));
   const pane = configuredValue(environment.TMUX_PANE)?.trim();
-  const directoryName = oneLine(basename4(directory) || directory);
+  const directoryName = oneLine(basename3(directory) || directory);
   const name = (socket === "" || serverPid === "" || pane === undefined ? undefined : await tmuxPaneTitle(socket, serverPid, pane, ownPane, query)) ?? (visible(directoryName) ? directoryName : "session");
   return (sessionId) => {
     const own = oneLine(chosen(sessionId) ?? "");
@@ -57465,13 +58515,382 @@ async function sessionTitle(environment, directory, sources = {}) {
   };
 }
 
+// ../pi-shared/src/dispatch-user-turn.ts
+function handledAttemptKey(messageId, attempt) {
+  return `${messageId}#${attempt}`;
+}
+function typedInputReply(text, outcome) {
+  const typed = /^\/\S+/.exec(text)?.[0];
+  const command = typed ?? "This message";
+  if ("error" in outcome)
+    return `${command} was not run: ${outcome.error}`;
+  if ("hostVersion" in outcome) {
+    return typed === undefined ? undefined : `${typed} was not run: this session's agent, version ${outcome.hostVersion}, cannot run commands sent from Dispatch; nothing was sent.`;
+  }
+  if (outcome.handled === "terminal-only") {
+    return `${command} runs only in the session's own terminal; nothing was sent.`;
+  }
+  if (outcome.handled === "unavailable") {
+    return `${command} was not run: this session's host cannot run typed input from Dispatch; nothing was sent.`;
+  }
+  return outcome.output?.trim() ? outcome.output : undefined;
+}
+
+// ../pi-shared/src/accept-user-turn.ts
+function isUserTurnCandidate(rendered) {
+  const { delivery } = rendered;
+  return rendered.envelope?.source === "dispatch" && delivery?.resource === "message" && delivery.issueKey === null && delivery.broadcastId === undefined && rendered.dispatchActor?.kind === "user" && (delivery.mode === "aside" || delivery.mode === "steer");
+}
+var AcceptedDeliverySchema = object({
+  message_id: string2(),
+  body: string2(),
+  delivery: _enum2(["aside", "steer"])
+});
+function turnFromAccept(accepted) {
+  const parsed = AcceptedDeliverySchema.safeParse(accepted);
+  if (!parsed.success)
+    return;
+  return { body: parsed.data.body, messageId: parsed.data.message_id, mode: parsed.data.delivery };
+}
+async function acceptUserTurn(options) {
+  const { rendered } = options;
+  if (!isUserTurnCandidate(rendered))
+    return;
+  const { delivery } = rendered;
+  const key = handledAttemptKey(delivery.id, delivery.attempt);
+  if (options.handled(key)) {
+    options.warn({ delivery, reason: "handled" });
+    return;
+  }
+  await options.handle(key, delivery);
+  try {
+    const dispatch = options.dispatch();
+    if (dispatch === undefined)
+      return;
+    const accepted = await dispatch.acceptMessageDelivery(delivery.id, delivery.attempt, {
+      actor: { id: options.actorId, kind: "session" }
+    });
+    const turn = turnFromAccept(accepted);
+    if (turn === undefined) {
+      options.warn({ delivery, reason: "no-body" });
+      return;
+    }
+    return { delivery, turn };
+  } catch (error) {
+    options.warn({ delivery, error, reason: "failed" });
+    return;
+  }
+}
+
+// ../pi-shared/src/delivery-pictures.ts
+async function withDeliveredPictures(text, addresses, client, named, shown) {
+  const textAlone = { content: text, shown: [] };
+  if (addresses.length === 0)
+    return textAlone;
+  let dispatch;
+  try {
+    dispatch = client();
+  } catch {
+    return textAlone;
+  }
+  if (dispatch === undefined)
+    return textAlone;
+  const unique = [...new Set(addresses)];
+  const shownEarlier = unique.some((address) => shown.has(address));
+  const pictures = await readPictures(dispatch, unique, shown);
+  const content = named ? `${text}
+
+${pictures.lines.join(`
+`)}` : text;
+  if (pictures.images.length === 0)
+    return shownEarlier ? { content, shown: [] } : textAlone;
+  return {
+    content: [{ type: "text", text: content }, ...imageBlocks(pictures.images)],
+    shown: pictures.shown
+  };
+}
+
+// src/user-turn-router.ts
+var ACCEPT_TIMEOUT_MS = 1e4;
+var PICTURES_TIMEOUT_MS = 20000;
+var COMMAND_WAITING_MS = 1e4;
+var AWAITED_ROWS_MAX = 16;
+var ANSWERED_DELIVERIES_MAX = 64;
+function commandStillRunning(command) {
+  return `${command} is still running: it waits for the turn this session is in, or for an answer at the session's own terminal. Its output follows in another reply.`;
+}
+function commandPrintedNothing(command) {
+  return `${command} ran in this session and printed nothing.`;
+}
+function modelPicked(model) {
+  return `The session's model is now ${model}.`;
+}
+function thinkingPicked(effort) {
+  return `The session's thinking level is now ${effort}.`;
+}
+function rowText(content) {
+  const pieces = [];
+  for (const block of content) {
+    const text = block["text"];
+    if (block.type === "text" && typeof text === "string")
+      pieces.push(text);
+  }
+  return pieces.join(`
+`);
+}
+function claudeContentBlocks(content) {
+  if (typeof content === "string")
+    return [{ type: "text", text: content }];
+  return content.map((block) => block.type === "text" ? { type: "text", text: block.text } : {
+    type: "image",
+    source: { type: "base64", media_type: block.mimeType, data: block.data }
+  });
+}
+function pickedEffort(value) {
+  const named = CLAUDE_EFFORT_LEVELS.find((level) => level === value);
+  if (named !== undefined)
+    return named;
+  const number = Number(value);
+  return value !== "" && Number.isFinite(number) ? number : undefined;
+}
+function createUserTurnRouter(options) {
+  const { reply, session, state, warn } = options;
+  const inPane = options.inbox !== undefined;
+  const waitingMs = options.commandWaitingMs ?? COMMAND_WAITING_MS;
+  const shownPictures = new Set;
+  const awaited = [];
+  const answered = new Set;
+  const expectRow = (body, messageId) => {
+    awaited.push({ body, messageId });
+    while (awaited.length > AWAITED_ROWS_MAX)
+      awaited.shift();
+  };
+  const record = (row, messageId) => {
+    state.delivered(row, messageId).catch((error) => {
+      warn(`could not record which Dispatch message a row of this session is \u2014 ${messageFor(error)}`);
+    });
+  };
+  const accepted = (rendered) => acceptUserTurn({
+    actorId: options.sessionId(),
+    dispatch: () => options.dispatch(ACCEPT_TIMEOUT_MS),
+    handle: state.handle,
+    handled: state.handled,
+    rendered,
+    warn: (refusal) => {
+      const { delivery } = refusal;
+      if (refusal.reason === "handled") {
+        warn(`a frame names the Dispatch attempt ${delivery.attempt} of message ${delivery.id}, which this session has already delivered; it arrives as a card`);
+        return;
+      }
+      if (refusal.reason === "no-body") {
+        warn(`Dispatch accepted message ${delivery.id} without the stored body to inject; it arrives as a card`);
+        return;
+      }
+      warn(`Dispatch did not accept message ${delivery.id} as this session's turn (${messageFor(refusal.error)}); it arrives as a card`);
+    }
+  });
+  const inject = async (delivery, turn, eventId) => {
+    const pictures = await withDeliveredPictures(turn.body, pictureAddresses(turn.body), () => options.dispatch(PICTURES_TIMEOUT_MS), false, shownPictures);
+    const blocks = claudeContentBlocks(pictures.content);
+    expectRow(turn.body, turn.messageId);
+    if (!inPane) {
+      const row = await session.deliver({
+        content: blocks,
+        ...eventId === undefined ? {} : { eventId },
+        messageId: turn.messageId,
+        text: turn.body,
+        failed: (error) => {
+          answer(delivery, typedInputReply(turn.body, { error: messageFor(error) }));
+        }
+      });
+      if (row !== undefined)
+        record(row, turn.messageId);
+    } else {
+      await options.inbox({
+        content: turn.body,
+        eventId: turn.messageId,
+        ...blocks.length > 1 ? { blocks } : {}
+      });
+    }
+    for (const address of pictures.shown)
+      shownPictures.add(address);
+  };
+  const post = async (delivery, result) => {
+    const key = handledAttemptKey(delivery.id, delivery.attempt);
+    const followUp = answered.has(key);
+    if (!followUp) {
+      rememberBounded(answered, key, ANSWERED_DELIVERIES_MAX);
+    }
+    await reply(delivery, { ...result, followUp });
+  };
+  const answer = async (delivery, body) => {
+    if (body === undefined)
+      return;
+    await post(delivery, { body }).catch((error) => {
+      warn(`a reply to message ${delivery.id} did not reach Dispatch \u2014 ${messageFor(error)}`);
+    });
+  };
+  const pickModel = async (value) => {
+    const model = value.startsWith(`${CLAUDE_PROVIDER}/`) ? value.slice(CLAUDE_PROVIDER.length + 1) : value;
+    if (inPane) {
+      await session.runCommand("model", model);
+      return modelPicked(`${CLAUDE_PROVIDER}/${model}`);
+    }
+    const stored = await session.setModel(model);
+    return modelPicked(`${CLAUDE_PROVIDER}/${String(stored)}`);
+  };
+  const runTyped = async (delivery, body) => {
+    const typed = /^\/(\S+)/.exec(body);
+    const name = typed?.[1] ?? "";
+    const value = body.slice(typed?.[0].length ?? 0).trim();
+    const effort = name === "effort" ? pickedEffort(value) : undefined;
+    if (!session.connected()) {
+      await answer(delivery, typedInputReply(body, { error: "this session has no link to Claude Code" }));
+      return;
+    }
+    let running = true;
+    const waiting = setTimeout(() => {
+      if (!running)
+        return;
+      answer(delivery, typedInputReply(body, {
+        handled: "command",
+        output: commandStillRunning(`/${name}`)
+      }));
+    }, waitingMs);
+    waiting.unref();
+    let said;
+    try {
+      if (name === "model" && value !== "")
+        said = await pickModel(value);
+      else if (effort !== undefined) {
+        const inForce = await session.setEffort(effort) ?? effort;
+        options.effortPicked(inForce);
+        said = thinkingPicked(inForce);
+      } else {
+        const output = await session.runCommand(name, value);
+        const printed = typedInputReply(body, { handled: "command", output });
+        said = printed ?? commandPrintedNothing(`/${name}`);
+      }
+    } catch (error) {
+      said = typedInputReply(body, { error: messageFor(error) });
+    } finally {
+      running = false;
+      clearTimeout(waiting);
+    }
+    options.refreshSettings();
+    await answer(delivery, said);
+  };
+  const runBtw = (delivery) => {
+    (async () => {
+      if (!session.connected()) {
+        await reply(delivery, { error: "this session has no link to Claude Code" });
+        return;
+      }
+      try {
+        await reply(delivery, { body: await session.fork(delivery.body) });
+      } catch (error) {
+        await reply(delivery, { error: messageFor(error) });
+      }
+    })().catch((error) => {
+      warn(`a BTW answer did not reach Dispatch \u2014 ${messageFor(error)}`);
+    });
+  };
+  return {
+    async route(rendered) {
+      const btw = rendered.delivery;
+      if (btw?.mode === "btw") {
+        runBtw(btw);
+        return true;
+      }
+      const accept = await accepted(rendered);
+      if (accept === undefined)
+        return false;
+      const { delivery, turn } = accept;
+      if (turn.body.startsWith("/")) {
+        runTyped(delivery, turn.body).catch((error) => {
+          warn(`a command from Dispatch failed \u2014 ${messageFor(error)}`);
+        });
+        return true;
+      }
+      await inject(delivery, turn, rendered.envelope?.event_id);
+      return true;
+    },
+    observe(event) {
+      if (event.kind !== "append" || awaited.length === 0)
+        return;
+      const { message } = event;
+      if (message.type !== "user" && message.role !== "user")
+        return;
+      const said = comparableLines(rowText(message.content)).join(`
+`);
+      const index = awaited.findIndex((row) => comparableLines(row.body).join(`
+`) === said);
+      const row = awaited[index];
+      if (row === undefined)
+        return;
+      awaited.splice(index, 1);
+      record(event.uuid, row.messageId);
+    }
+  };
+}
+
+// src/user-turn-state.ts
+import { join as join11 } from "path";
+var TURNS_DIRECTORY = "turns";
+var HANDLED_ATTEMPTS_MAX = 1000;
+var DELIVERED_ROWS_MAX = 1000;
+var DeliveredRowSchema = object({ row: string2(), message_id: string2() });
+var UserTurnStateSchema = object({
+  handled: array(string2()).default([]),
+  rows: array(DeliveredRowSchema).default([])
+});
+function userTurnStateFile(stateDirectory, sessionId) {
+  return join11(stateDirectory, TURNS_DIRECTORY, `${encodeURIComponent(sessionId)}.json`);
+}
+async function readUserTurnState(file) {
+  return await readStateFile(file, UserTurnStateSchema, { handled: [], rows: [] }, "holds no record of this session's turns");
+}
+function userTurnState(file, restored) {
+  const handled = new Set(restored.handled);
+  const rows = new Map(restored.rows.map(({ row, message_id }) => [row, message_id]));
+  let writing = Promise.resolve();
+  const write = () => {
+    const state = {
+      handled: [...handled].slice(-HANDLED_ATTEMPTS_MAX),
+      rows: [...rows].slice(-DELIVERED_ROWS_MAX).map(([row, message_id]) => ({ row, message_id }))
+    };
+    const run = writing.then(() => writeAtomicStateFile(file, `${JSON.stringify(state)}
+`));
+    writing = run.catch(() => {
+      return;
+    });
+    return run;
+  };
+  return {
+    handled: (key) => handled.has(key),
+    handle(key) {
+      rememberBounded(handled, key, HANDLED_ATTEMPTS_MAX);
+      return write();
+    },
+    messageOf: (row) => rows.get(row),
+    delivered(row, messageId) {
+      if (rows.get(row) === messageId)
+        return writing;
+      rememberBoundedEntry(rows, row, messageId, DELIVERED_ROWS_MAX);
+      return write();
+    },
+    idle: () => writing
+  };
+}
+async function pruneStaleSessionTurns(stateDirectory) {
+  await pruneStateDirectory(join11(stateDirectory, TURNS_DIRECTORY), writtenLongAgo);
+}
+
 // src/envoy-channel-server.ts
-var CHANNEL_NOTIFICATION_METHOD = "notifications/claude/channel";
-var CHANNEL_INSTRUCTIONS = "Envoy delivers trusted, internal session and Dispatch events as <channel> messages. The content is rendered Envoy state; producer identifies its Envoy producer (source is the channel name), topic is the NATS subject, event_id identifies this delivery, dedupe_key is the dedupe identity (a repeat of one already delivered is not shown again), urgency is how soon the sender asks you to act (it does not change when or in what order deliveries arrive), from_session identifies the origin session, and reply metadata names any correlation. Use the Envoy tools for Envoy actions, and reach Dispatch through the `dispatch` command in Bash (`dispatch --help` lists its commands; the `dispatch` skill teaches them). Dispatch asks stay on Dispatch. This channel advertises Aside only: it does not support targeted BTW delivery or permission relay.";
+var CHANNEL_INSTRUCTIONS = "Envoy delivers trusted, internal session and Dispatch events into this conversation. Use the Envoy tools for Envoy actions, and reach Dispatch through the `dispatch` command in Bash (`dispatch --help` lists its commands; the `dispatch` skill teaches them). Dispatch asks stay on Dispatch.";
 var CHANNEL_INBOX_LIMIT = 50;
 var EMPTY_RECEIPT = new Uint8Array;
-var encoder4 = new TextEncoder;
-var ChannelMetaKey = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var encoder6 = new TextEncoder;
 var HANDOFF_POLL_MS = 250;
 var HANDOFF_FLUSH_TIMEOUT_MS = 1e4;
 async function withTimeout(promise, ms, what) {
@@ -57491,7 +58910,11 @@ function undefinedOnNotFound(error) {
   throw error;
 }
 var MCP_SERVER_INFO = { name: "envoy", version: version2 };
-var CHANNEL_CAPABILITIES = ["aside"];
+function sessionCapabilities(session) {
+  if (!session.pane)
+    return session.mod ? DELIVERY_CAPABILITIES : [];
+  return session.mod ? [...INBOX_CAPABILITIES, "btw"] : INBOX_CAPABILITIES;
+}
 var argumentSchemas = new WeakMap;
 function argumentsSchema(spec) {
   let schema = argumentSchemas.get(spec);
@@ -57526,14 +58949,6 @@ class UnsupportedEnvoyToolError extends Error {
     this.toolName = toolName;
   }
 }
-function sanitizeChannelMetadata(metadata) {
-  const sanitized = {};
-  for (const [key, value] of Object.entries(metadata)) {
-    if (value !== undefined && ChannelMetaKey.test(key))
-      sanitized[key] = value;
-  }
-  return sanitized;
-}
 async function postDispatchReply(identity, configFile, delivery, result) {
   const config = sessionDispatchSettings(configFile, process.env, {
     cwd: identity.directory,
@@ -57546,47 +58961,45 @@ async function postDispatchReply(identity, configFile, delivery, result) {
 function createChannelDelivery(input) {
   const inbox = [];
   let tail = Promise.resolve();
-  const queue = (notification) => {
-    const queued = tail.then(() => input.notifier.notification(notification));
-    tail = queued.catch((error) => {
-      process.stderr.write(`envoy-channel: channel notification failed \u2014 ${messageFor(error)}
+  const queued = (work) => {
+    const run = tail.then(work);
+    tail = run.then(() => {
+      return;
+    }, (error) => {
+      process.stderr.write(`envoy-channel: a delivery failed \u2014 ${messageFor(error)}
 `);
     });
-    return queued;
+    return run;
   };
-  const show = (rendered, subject, content) => {
+  const write = (notification) => queued(() => input.notifier.notification(notification));
+  const list = (rendered) => {
     const envelope = rendered.envelope;
-    if (envelope !== undefined) {
-      inbox.unshift({
-        event_id: envelope.event_id ?? "unknown",
-        at: inboundTimestamp(envelope.issued_at),
-        from: envelope.source_session ?? envelope.source,
-        summary: envelope.payload_summary ?? "unknown"
-      });
-      if (inbox.length > CHANNEL_INBOX_LIMIT)
-        inbox.pop();
-    }
-    return queue({
-      method: CHANNEL_NOTIFICATION_METHOD,
-      params: {
-        content,
-        meta: sanitizeChannelMetadata({
-          producer: envelope?.source ?? "unknown",
-          topic: envelope?.topic || subject,
-          event_id: envelope?.event_id,
-          dedupe_key: envelope?.dedupe_key,
-          urgency: envelope?.urgency,
-          from_session: envelope?.source_session,
-          expects_reply: envelope?.expects_reply?.toString(),
-          in_reply_to: envelope?.in_reply_to
-        })
-      }
+    if (envelope === undefined)
+      return;
+    const eventId = envelope.event_id;
+    if (eventId !== undefined && inbox.some((entry) => entry.event_id === eventId))
+      return;
+    inbox.unshift({
+      event_id: eventId ?? "unknown",
+      at: inboundTimestamp(envelope.issued_at),
+      from: envelope.source_session ?? envelope.source,
+      summary: envelope.payload_summary ?? "unknown"
     });
+    if (inbox.length > CHANNEL_INBOX_LIMIT)
+      inbox.pop();
+  };
+  const notification = (rendered, content) => ({
+    content,
+    ...rendered.envelope?.event_id === undefined ? {} : { eventId: rendered.envelope.event_id }
+  });
+  const show = (rendered, content) => {
+    list(rendered);
+    return write(notification(rendered, content));
   };
   const passOverBtw = (rendered, how) => {
     if (rendered.delivery?.mode !== "btw")
       return false;
-    process.stderr.write(`envoy-channel: passing over ${how} BTW ${rendered.envelope?.event_id ?? "unknown"}: a BTW never starts a turn
+    process.stderr.write(`envoy-channel: passing over ${how} BTW ${rendered.envelope?.event_id ?? "unknown"}: it was asked while this session was not taking messages
 `);
     return true;
   };
@@ -57614,7 +59027,16 @@ function createChannelDelivery(input) {
       }
       if (late === true && passOverBtw(rendered, "late"))
         return tail.then(() => false);
-      return show(rendered, subject, rendered.content).then(() => true);
+      return queued(async () => {
+        const routed = await input.router?.()?.route(rendered);
+        if (routed === true) {
+          list(rendered);
+          return true;
+        }
+        await input.notifier.notification(notification(rendered, rendered.content));
+        list(rendered);
+        return true;
+      });
     },
     async replay(frame) {
       const rendered = renderInbound(frame.data, input.identity.id, frame.subject);
@@ -57622,14 +59044,11 @@ function createChannelDelivery(input) {
         return "suppressed";
       if (passOverBtw(rendered, "replayed"))
         return "suppressed";
-      await show(rendered, frame.subject, replayedText(rendered.content, frame.time));
+      await show(rendered, replayedText(rendered.content, frame.time));
       return "shown";
     },
     notice(content) {
-      return queue({
-        method: CHANNEL_NOTIFICATION_METHOD,
-        params: { content, meta: { producer: "envoy" } }
-      });
+      return write({ content });
     },
     inbox() {
       return [...inbox];
@@ -57651,10 +59070,13 @@ async function enqueueChannelMessage(delivery, connection, directSubject, messag
 async function startChannelSession(options) {
   const { identity } = options;
   let directSubject = agentSubject(identity.id);
+  let router;
+  let turns;
   const delivery = createChannelDelivery({
     identity,
     notifier: options.notifier,
-    configFile: options.configFile
+    configFile: options.configFile,
+    router: () => router
   });
   const userTopics = new Set;
   let heldRole;
@@ -57764,6 +59186,22 @@ async function startChannelSession(options) {
     replayBound = sessionId;
     return rememberedTopics(snapshot.state);
   };
+  const restoreTurns = async () => {
+    router = undefined;
+    turns = undefined;
+    if (options.router === undefined)
+      return;
+    const file = userTurnStateFile(options.stateDirectory, identity.id);
+    const restored = await readUserTurnState(file).catch((error) => {
+      process.stderr.write(`envoy-channel: could not read this session's record of the messages it took (${messageFor(error)}); its messages arrive as cards
+`);
+      return;
+    });
+    if (restored === undefined)
+      return;
+    turns = userTurnState(file, restored);
+    router = options.router(turns);
+  };
   const triggerReplay = () => {
     if (!shuttingDown)
       replay.sweep();
@@ -57823,7 +59261,7 @@ async function startChannelSession(options) {
 `);
         }
       },
-      publish: (reply, body) => options.connection.publish(reply, encoder4.encode(body)),
+      publish: (reply, body) => options.connection.publish(reply, encoder6.encode(body)),
       persist: (snapshot) => {
         if (relay !== owner)
           return false;
@@ -57952,7 +59390,7 @@ async function startChannelSession(options) {
       topics,
       port: 0,
       title,
-      capabilities: options.capabilities,
+      capabilities: options.capabilities(),
       driving: false,
       selfSubscribed: true,
       clientInstanceID: options.clientInstanceID,
@@ -58097,6 +59535,7 @@ async function startChannelSession(options) {
     directSubject = nextSubject;
     forwarder.unfollow([previousSubject]);
     await restoreReplay();
+    await restoreTurns();
     roleTransferFrom ??= previous;
     await withTimeout(options.connection.flush(), options.handoffFlushTimeoutMs ?? HANDOFF_FLUSH_TIMEOUT_MS, "flushing NATS").catch((error) => {
       process.stderr.write(`envoy-channel: could not confirm the relay subscription of ${next} \u2014 ${messageFor(error)}
@@ -58211,6 +59650,7 @@ async function startChannelSession(options) {
       heartbeat();
   };
   const remembered = await restoreReplay();
+  await restoreTurns();
   forwarder.follow(directSubject);
   for (const topic of remembered) {
     userTopics.add(topic);
@@ -58241,6 +59681,7 @@ async function startChannelSession(options) {
   for (const prune of [
     () => pruneStaleSessionHandoffs(options.stateDirectory),
     () => pruneStaleSessionTitles(options.stateDirectory),
+    () => pruneStaleSessionTurns(options.stateDirectory),
     () => pruneStaleSessionRoles(options.stateDirectory, identity.id)
   ]) {
     await prune().catch((error) => {
@@ -58308,6 +59749,20 @@ async function startChannelSession(options) {
     onRoleRegained(hook) {
       regained = hook;
     },
+    capabilitiesChanged() {
+      if (shuttingDown)
+        return;
+      serialized(register).catch((error) => {
+        process.stderr.write(`envoy-channel: could not advertise this session's delivery modes (${messageFor(error)}); the next heartbeat retries
+`);
+      });
+    },
+    observe(event) {
+      router?.observe(event);
+    },
+    messageOf(row) {
+      return turns?.messageOf(row);
+    },
     async rememberRole(role) {
       heldRole = role;
       await writeRoleRecord(roleStateFile(options.stateDirectory, identity.id), role);
@@ -58329,6 +59784,7 @@ async function startChannelSession(options) {
 `);
       });
       await stateWriter?.idle();
+      await turns?.idle();
     }
   };
 }
@@ -58502,18 +59958,9 @@ async function runEnvoyChannelServer() {
   const inboxSocket = configuredValue(process.env[INBOX_VARIABLE]);
   const bundlePath = process.argv[1] ?? "";
   const inbox = inboxSocket === undefined ? undefined : createInboxNotifier(inboxSocket);
-  const channel = inboxSocket === undefined ? detectClaudeChannel({
-    claudePid: process.ppid,
-    bundlePath,
-    environment: process.env
-  }) : { loaded: true };
-  if (!channel.loaded) {
-    process.stderr.write(`envoy-channel: Claude Code did not load this server as a channel: ${channel.why}; the session advertises no delivery mode, so Dispatch refuses messages to it instead of losing them
-`);
-  }
   const server = new Server(MCP_SERVER_INFO, {
-    capabilities: { tools: {}, experimental: { "claude/channel": {} } },
-    instructions: channel.loaded ? CHANNEL_INSTRUCTIONS : `${CHANNEL_INSTRUCTIONS} Claude Code did not load this channel for this session (${channel.why}), so no Envoy event or Dispatch message reaches you as a <channel> message, and the session advertises no delivery mode; envoy_inbox still lists what arrived.`
+    capabilities: { tools: {} },
+    instructions: CHANNEL_INSTRUCTIONS
   });
   const client = createEnvoyClient({
     baseUrl: envoy.url,
@@ -58532,10 +59979,7 @@ async function runEnvoyChannelServer() {
     booted: claimBooted.promise,
     readState: (signal) => daemon.state({ signal }),
     reportActivity: (input) => daemon.activity(input),
-    inbox: inbox === undefined ? undefined : (text) => inbox.notification({
-      method: CHANNEL_NOTIFICATION_METHOD,
-      params: { content: text, meta: {} }
-    }),
+    inbox: inbox === undefined ? undefined : (text) => inbox.notification({ content: text }),
     publish: client.publish,
     env: process.env,
     log: phaseLog
@@ -58568,13 +60012,39 @@ async function runEnvoyChannelServer() {
       throw new Error("Envoy channel server is still starting");
     return mcpResult(await executeEnvoyTool(runtime, request.params.name, request.params.arguments));
   });
-  const notifier = inbox === undefined ? server : phaseHook === undefined ? inbox : {
+  let modLink;
+  const linked = Promise.withResolvers();
+  let agentStream;
+  const claude = modSession({
+    link: {
+      request: (call, args, requestOptions) => {
+        const link = modLink;
+        if (link === undefined) {
+          return Promise.reject(new Error("this session has no link to Claude Code"));
+        }
+        return link.request(call, args, requestOptions);
+      },
+      connected: () => modLink?.connected() === true
+    },
+    warn: (text) => process.stderr.write(`envoy-channel: ${text}
+`)
+  });
+  const writer = inbox ?? {
+    notification: async ({ content, blocks, eventId }) => {
+      await claude.show({
+        content: blocks ?? [{ type: "text", text: content }],
+        text: content,
+        ...eventId === undefined ? {} : { eventId }
+      });
+    }
+  };
+  const notifier = phaseHook === undefined ? writer : {
     notification: async (notification) => {
-      phaseHook.deliveryWritten(notification.params.content);
-      await inbox.notification(notification);
+      phaseHook.deliveryWritten(notification.content);
+      await writer.notification(notification);
     }
   };
-  const capabilities = inboxSocket !== undefined ? INBOX_CAPABILITIES : channel.loaded ? CHANNEL_CAPABILITIES : [];
+  const capabilities = () => sessionCapabilities({ pane: inboxSocket !== undefined, mod: modLink?.connected() === true });
   const booting = new AbortController;
   const stopped = Promise.withResolvers();
   let stopping = false;
@@ -58585,6 +60055,10 @@ async function runEnvoyChannelServer() {
     stopping = true;
     booting.abort();
     phaseHook?.stop();
+    modLink?.close().catch(() => {
+      return;
+    });
+    agentStream?.stop();
     if (session === undefined) {
       stopped.resolve();
       return;
@@ -58596,6 +60070,41 @@ async function runEnvoyChannelServer() {
   process.once("SIGINT", stop);
   process.once("SIGHUP", stop);
   await server.connect(new StdioServerTransport);
+  startModLink({
+    sessionId: claudeSessionId({ CLAUDE_CODE_SESSION_ID: process.env["CLAUDE_CODE_SESSION_ID"] }),
+    env: process.env,
+    warn: (text) => process.stderr.write(`envoy-channel: ${text}
+`)
+  }).then((link) => {
+    modLink = link;
+    if (stopping)
+      link.close().catch(() => {
+        return;
+      });
+    else
+      linked.resolve(link);
+  }, (error) => {
+    process.stderr.write(`envoy-channel: no link to this session's Claude Code mod \u2014 ${messageFor(error)}; the session runs on without one
+`);
+  });
+  const router = (state) => {
+    const options = {
+      dispatch: (ms) => {
+        const active = activeDispatchSettings(sessionDispatchSettings(configFile, process.env, { cwd: directory }).dispatch);
+        return active === null ? undefined : new DispatchClient(active.url, active.credential, fetch, AbortSignal.timeout(ms));
+      },
+      effortPicked: (effort) => agentStream?.pickedEffort(effort),
+      refreshSettings: () => agentStream?.refresh(),
+      reply: (delivery, result) => postDispatchReply(identity, configFile, delivery, result),
+      session: claude,
+      sessionId: () => identity.id,
+      state,
+      warn: (text) => process.stderr.write(`envoy-channel: ${text}
+`),
+      ...inboxSocket === undefined ? {} : { inbox: (input) => notifier.notification(input) }
+    };
+    return createUserTurnRouter(options);
+  };
   let connection;
   try {
     const { inbound } = envoy;
@@ -58616,6 +60125,7 @@ async function runEnvoyChannelServer() {
         connection,
         notifier,
         capabilities,
+        router,
         client,
         heartbeatMs: envoy.heartbeatMs,
         configFile,
@@ -58626,6 +60136,31 @@ async function runEnvoyChannelServer() {
         ...stamping ? { stampTitle } : {},
         ...configuredValue(overrideSessionId) === undefined ? { handoffPid: process.ppid } : {}
       });
+      const bus = connection;
+      const live = session;
+      linked.promise.then((link) => {
+        if (stopping)
+          return;
+        agentStream = startAgentStream({
+          connection: bus,
+          followsSessionId: configuredValue(overrideSessionId) === undefined,
+          isPane: inbox !== undefined,
+          link,
+          sessionId: identity.id,
+          observe: (event) => {
+            claude.observe(event);
+            live.observe(event);
+          },
+          appendedRow: (row) => claude.appendedRow(row),
+          runsCommandRow: (row) => claude.runsCommandRow(row),
+          runsUnreadPrompt: (row) => claude.runsUnreadPrompt(row),
+          tagFor: (row) => live.messageOf(row)
+        });
+        link.onSessionId(() => live.capabilitiesChanged());
+        link.onConnected(() => live.capabilitiesChanged());
+        if (link.connected())
+          live.capabilitiesChanged();
+      });
     }
     runtime = { identity, client, session, clientInstanceID };
     if (pane !== undefined && daemon !== undefined && !stopping) {
@@ -58646,6 +60181,9 @@ async function runEnvoyChannelServer() {
       await session.shutdown();
     await stopped.promise;
   } finally {
+    await modLink?.close().catch(() => {
+      return;
+    });
     if (session === undefined && connection !== undefined) {
       await connection.drain().catch(() => {
         return;