agent-shim 8.3.0 → 8.4.1

package/dist/cli.cjs

@@ -61040,7 +61040,7 @@ function registerIdentityCommand(program2, deps) {
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.3.0",
+  version: "8.4.1",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -64064,19 +64064,19 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
           if (budget <= 0) {
             return;
           }
-          const excerpt = chunk.subarray(0, Math.min(CHUNK_LOG_CAP_BYTES, budget));
-          stored[direction] += excerpt.length;
-          const text2 = excerpt.toString("utf8");
-          const faithful = Buffer.from(text2, "utf8").equals(excerpt);
+          const excerpt2 = chunk.subarray(0, Math.min(CHUNK_LOG_CAP_BYTES, budget));
+          stored[direction] += excerpt2.length;
+          const text2 = excerpt2.toString("utf8");
+          const faithful = Buffer.from(text2, "utf8").equals(excerpt2);
           append({
             kind: "stream-chunk",
             id,
             dir: direction,
             seq: sequences[direction],
             bytes: chunk.length,
-            stored: excerpt.length,
-            truncated: excerpt.length < chunk.length,
-            ...faithful ? { body: redactText(text2) } : { b64: excerpt.toString("base64") }
+            stored: excerpt2.length,
+            truncated: excerpt2.length < chunk.length,
+            ...faithful ? { body: redactText(text2) } : { b64: excerpt2.toString("base64") }
           });
         },
         onEnd: () => {
@@ -64096,16 +64096,16 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
         if (budget <= 0) {
           return;
         }
-        const excerpt = incoming.subarray(0, Math.min(CHUNK_LOG_CAP_BYTES, budget));
-        logged[direction] += excerpt.length;
+        const excerpt2 = incoming.subarray(0, Math.min(CHUNK_LOG_CAP_BYTES, budget));
+        logged[direction] += excerpt2.length;
         append({
           kind: `${direction}-chunk`,
           id,
           seq: sequences[direction],
           bytes: incoming.length,
-          stored: excerpt.length,
-          truncated: excerpt.length < incoming.length,
-          body: redactBody(excerpt)
+          stored: excerpt2.length,
+          truncated: excerpt2.length < incoming.length,
+          body: redactBody(excerpt2)
         });
       };
       return {
@@ -65202,6 +65202,11 @@ function realConnectEffects() {
         request7.on("data", (chunk) => {
           observer.onRequestChunk(chunk);
         });
+        if (observer.onRequestEnd !== void 0) {
+          request7.on("end", () => {
+            observer.onRequestEnd?.();
+          });
+        }
         response.on("close", () => {
           observer.onEnd();
         });
@@ -65254,7 +65259,10 @@ async function readBody(request7) {
 }
 function createRcControlHandler(deps) {
   const sessionsPath = `${CONTROL_PATH_PREFIX}/sessions`;
+  const statusPath = `${CONTROL_PATH_PREFIX}/status`;
+  const pendingPath = `${CONTROL_PATH_PREFIX}/pending`;
   const injectPath = `${CONTROL_PATH_PREFIX}/inject`;
+  const answerPath = `${CONTROL_PATH_PREFIX}/answer`;
   return (request7, response) => {
     const presented = request7.headers.authorization;
     const bearerPrefix = "bearer ".length;
@@ -65263,9 +65271,9 @@ function createRcControlHandler(deps) {
       answerJson(response, HTTP_STATUS.unauthorized, { error: "the front door's control routes demand this generation's control token as a Bearer credential" });
       return;
     }
-    const url2 = request7.url ?? "/";
+    const url2 = new URL(request7.url ?? "/", "http://127.0.0.1");
     const handle = async () => {
-      if (url2 === sessionsPath) {
+      if (url2.pathname === sessionsPath) {
         if (request7.method !== "GET") {
           answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the session list is a GET" });
           return;
@@ -65273,7 +65281,20 @@ function createRcControlHandler(deps) {
         answerJson(response, HTTP_STATUS.ok, { sessions: deps.list() });
         return;
       }
-      if (url2 === injectPath) {
+      if (url2.pathname === statusPath || url2.pathname === pendingPath) {
+        if (request7.method !== "GET") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the status and pending reads are GETs" });
+          return;
+        }
+        const session = url2.searchParams.get("session") ?? void 0;
+        if (session !== void 0 && !deps.statusOf(session).some((entry) => entry.id === session)) {
+          answerJson(response, HTTP_STATUS.notFound, { error: `the front door has not observed Remote Control session ${session}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.ok, url2.pathname === statusPath ? { statuses: deps.statusOf(session) } : { pending: deps.pendingOf(session) });
+        return;
+      }
+      if (url2.pathname === injectPath) {
         if (request7.method !== "POST") {
           answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the inject operation is a POST" });
           return;
@@ -65297,7 +65318,36 @@ function createRcControlHandler(deps) {
         answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
         return;
       }
-      answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url2}` });
+      if (url2.pathname === answerPath) {
+        if (request7.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the answer operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request7));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("request" in parsed) || !("approve" in parsed) || typeof parsed.session !== "string" || typeof parsed.request !== "string" || typeof parsed.approve !== "boolean" || parsed.session === "" || parsed.request === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body must be JSON naming a non-empty session id, request id, and an approve boolean" });
+          return;
+        }
+        const text2 = "text" in parsed && typeof parsed.text === "string" ? parsed.text : void 0;
+        if (parsed.approve && text2 !== void 0 && text2 !== "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "an approval carries no text (the protocol's allow result has no message field); text is the denial message" });
+          return;
+        }
+        const result = await deps.answer(parsed.session, parsed.request, { approve: parsed.approve, message: parsed.approve ? void 0 : text2 });
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, request: parsed.request, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
+      }
+      answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url2.pathname}` });
     };
     handle().catch((error62) => {
       answerJson(response, HTTP_STATUS.internalServerError, { error: `the control route failed: ${error62 instanceof Error ? error62.message : String(error62)}` });
@@ -65356,6 +65406,39 @@ function isRcSessionSummary(value) {
   }
   return typeof value.id === "string" && typeof value.createdAt === "number" && typeof value.lastSeenAt === "number";
 }
+function isRcWorkerFact(value, valueIs) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("value" in value) || !("observedAt" in value)) {
+    return false;
+  }
+  return valueIs(value.value) && typeof value.observedAt === "number";
+}
+function isRcSessionStatus(value) {
+  if (!isRcSessionSummary(value)) {
+    return false;
+  }
+  if (!("pending" in value) || !Array.isArray(value.pending)) {
+    return false;
+  }
+  if ("workerState" in value && value.workerState !== void 0 && !isRcWorkerFact(value.workerState, (candidate) => typeof candidate === "string")) {
+    return false;
+  }
+  if ("workerIdleSeconds" in value && value.workerIdleSeconds !== void 0 && !isRcWorkerFact(value.workerIdleSeconds, (candidate) => typeof candidate === "number")) {
+    return false;
+  }
+  return value.pending.every((candidate) => isRcPendingRequestSummary(candidate));
+}
+function isRcPendingRequestSummary(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("sessionId" in value) || !("requestId" in value) || !("type" in value) || !("summary" in value) || !("observedAt" in value)) {
+    return false;
+  }
+  return typeof value.sessionId === "string" && typeof value.requestId === "string" && typeof value.type === "string" && typeof value.summary === "string" && typeof value.observedAt === "number";
+}
 function sequenceNumsOfBody(body) {
   let parsed;
   try {
@@ -65378,6 +65461,13 @@ function sequenceNumsOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
+  const listAnswerOf = async (path41, what) => {
+    try {
+      return await transport.request({ method: "GET", path: path41, headers });
+    } catch (error62) {
+      throw new Error(`${what}: could not reach the front door's control listener: ${error62 instanceof Error ? error62.message : String(error62)}`, { cause: error62 });
+    }
+  };
   const sessionsOf = (answer, what) => {
     if (answer.status !== HTTP_STATUS.ok) {
       throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
@@ -65401,29 +65491,77 @@ function frontDoorRcControl(transport, token) {
     }
     return sessions;
   };
-  return {
-    listSessions: async () => sessionsOf(await transport.request({ method: "GET", path: `${CONTROL_PATH_PREFIX}/sessions`, headers }), "listing the door's Remote Control sessions"),
-    sendPrompt: async (sessionId, text2) => {
-      let answer;
-      try {
-        answer = await transport.request({
-          method: "POST",
-          path: `${CONTROL_PATH_PREFIX}/inject`,
-          headers: { ...headers, "content-type": "application/json" },
-          body: JSON.stringify({ session: sessionId, text: text2 })
-        });
-      } catch (error62) {
-        return { ok: false, message: `could not reach the front door's control listener: ${error62 instanceof Error ? error62.message : String(error62)}` };
+  const statusesOf = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("statuses" in parsed) || !Array.isArray(parsed.statuses)) {
+      throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
+    }
+    const statuses = [];
+    for (const value of parsed.statuses) {
+      if (!isRcSessionStatus(value)) {
+        throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
       }
-      if (answer.status === HTTP_STATUS.ok) {
-        const sequenceNums = sequenceNumsOfBody(answer.body);
-        if (sequenceNums === void 0) {
-          return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
-        }
-        return { ok: true, sequenceNums };
+      statuses.push(value);
+    }
+    return statuses;
+  };
+  const pendingOfAnswer = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("pending" in parsed) || !Array.isArray(parsed.pending)) {
+      throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
+    }
+    const pending = [];
+    for (const value of parsed.pending) {
+      if (!isRcPendingRequestSummary(value)) {
+        throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
       }
-      return { ok: false, message: `injecting into ${sessionId} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}` };
+      pending.push(value);
     }
+    return pending;
+  };
+  const writeOf = async (path41, body, describeFailure) => {
+    let answer;
+    try {
+      answer = await transport.request({ method: "POST", path: path41, headers: { ...headers, "content-type": "application/json" }, body });
+    } catch (error62) {
+      return { ok: false, message: `could not reach the front door's control listener: ${error62 instanceof Error ? error62.message : String(error62)}` };
+    }
+    if (answer.status === HTTP_STATUS.ok) {
+      const sequenceNums = sequenceNumsOfBody(answer.body);
+      if (sequenceNums === void 0) {
+        return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
+      }
+      return { ok: true, sequenceNums };
+    }
+    return { ok: false, message: describeFailure(answer.status, controlErrorOf(answer.body) ?? answer.body) };
+  };
+  const sessionQuery = (sessionId) => sessionId === void 0 ? "" : `?session=${encodeURIComponent(sessionId)}`;
+  return {
+    listSessions: async () => sessionsOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/sessions`, "listing the door's Remote Control sessions"), "listing the door's Remote Control sessions"),
+    statusOf: async (sessionId) => statusesOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/status${sessionQuery(sessionId)}`, "reading the door's Remote Control session status"), "reading the door's Remote Control session status"),
+    pendingOf: async (sessionId) => pendingOfAnswer(await listAnswerOf(`${CONTROL_PATH_PREFIX}/pending${sessionQuery(sessionId)}`, "listing the door's pending Remote Control control requests"), "listing the door's pending Remote Control control requests"),
+    sendPrompt: async (sessionId, text2) => await writeOf(`${CONTROL_PATH_PREFIX}/inject`, JSON.stringify({ session: sessionId, text: text2 }), (status, message) => `injecting into ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    answerRequest: async (sessionId, requestId, decision) => await writeOf(
+      `${CONTROL_PATH_PREFIX}/answer`,
+      JSON.stringify({ session: sessionId, request: requestId, approve: decision.approve, ...decision.approve || decision.message === void 0 ? {} : { text: decision.message } }),
+      (status, message) => `answering control request ${requestId} on ${sessionId} failed (HTTP ${String(status)}): ${message}`
+    )
   };
 }
 
@@ -66787,6 +66925,9 @@ var RC_SESSION_ID_PREFIX = "cse_";
 var RC_IDLE_EXPIRY_MS = 45e3;
 var RC_CREATE_RESPONSE_CAP_BYTES = 8192;
 var CONFLICT_REASON_HEADER = "x-ccr-conflict-reason";
+var RC_PENDING_DEADLINE_MS = 14e3;
+var RC_REQUEST_PARSE_CAP_BYTES = 262144;
+var RC_PENDING_SUMMARY_EXCERPT_CHARS = 300;
 var SUCCESS_STATUS_MAX_EXCLUSIVE = 300;
 function isSuccessful(status) {
   return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE;
@@ -66812,20 +66953,124 @@ function sessionCreateId(body) {
   const id = session.id;
   return typeof id === "string" && id.startsWith(RC_SESSION_ID_PREFIX) ? id : void 0;
 }
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  return isRecord3(parsed) ? parsed : void 0;
+}
+function nonEmptyString(record2, field) {
+  const value = record2 === void 0 ? void 0 : record2[field];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function finiteNumber(record2, field) {
+  const value = record2 === void 0 ? void 0 : record2[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function excerpt(text2) {
+  return text2.length <= RC_PENDING_SUMMARY_EXCERPT_CHARS ? text2 : `${text2.slice(0, RC_PENDING_SUMMARY_EXCERPT_CHARS)}...`;
+}
+function payloadEventsOf(body) {
+  const parsed = parseJsonObject(body);
+  const events = parsed === void 0 ? void 0 : parsed.events;
+  if (!Array.isArray(events)) {
+    return [];
+  }
+  const payloads = [];
+  for (const event of events) {
+    if (!isRecord3(event)) {
+      continue;
+    }
+    const payload = event.payload;
+    if (!isRecord3(payload)) {
+      continue;
+    }
+    payloads.push(payload);
+  }
+  return payloads;
+}
+function pendingOfControlRequestPayload(payload) {
+  if (payload.type !== "control_request") {
+    return void 0;
+  }
+  const requestId = nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
+  if (requestId === void 0) {
+    return void 0;
+  }
+  const request7 = isRecord3(payload.request) ? payload.request : void 0;
+  const subtype = nonEmptyString(request7, "subtype");
+  const type = subtype ?? "control_request";
+  let summary = "";
+  if (subtype === "can_use_tool") {
+    const toolName = nonEmptyString(request7, "tool_name") ?? "unknown tool";
+    const input2 = request7 === void 0 ? void 0 : request7.input;
+    summary = input2 === void 0 ? toolName : `${toolName} ${excerpt(JSON.stringify(input2))}`;
+  } else if (request7 !== void 0) {
+    summary = excerpt(JSON.stringify(request7));
+  }
+  return { requestId, type, summary };
+}
+function answeredRequestIdsOfControlResponsePayload(payload) {
+  if (payload.type !== "control_response") {
+    return [];
+  }
+  const response = isRecord3(payload.response) ? payload.response : void 0;
+  const id = nonEmptyString(response, "request_id") ?? nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
+  return id === void 0 ? [] : [id];
+}
+function parseRcRequestBody(kind, body) {
+  if (kind === "heartbeat") {
+    return { controlRequests: [], answeredRequestIds: [], idleSeconds: finiteNumber(parseJsonObject(body), "idle_seconds"), workerStatus: void 0 };
+  }
+  if (kind === "worker-registration") {
+    return { controlRequests: [], answeredRequestIds: [], idleSeconds: void 0, workerStatus: nonEmptyString(parseJsonObject(body), "status") };
+  }
+  const controlRequests = [];
+  const answeredRequestIds = [];
+  for (const payload of payloadEventsOf(body)) {
+    const pending = pendingOfControlRequestPayload(payload);
+    if (pending !== void 0) {
+      controlRequests.push({ requestId: pending.requestId, type: pending.type, summary: pending.summary });
+      continue;
+    }
+    answeredRequestIds.push(...answeredRequestIdsOfControlResponsePayload(payload));
+  }
+  return { controlRequests, answeredRequestIds, idleSeconds: void 0, workerStatus: void 0 };
+}
 function createRcSessionTracker(deps) {
   const entries = /* @__PURE__ */ new Map();
   const expire = (id) => {
     entries.delete(id);
   };
+  const expirePendings = (entry, now) => {
+    for (const [requestId, pending] of entry.pending) {
+      if (now - pending.observedAt >= RC_PENDING_DEADLINE_MS) {
+        entry.pending.delete(requestId);
+      }
+    }
+  };
   const sweep = () => {
     for (const [id, entry] of entries) {
       if (deps.now() - entry.lastSeenAt >= deps.idleMs) {
         expire(id);
+        continue;
       }
+      expirePendings(entry, deps.now());
     }
   };
   const timer = setInterval(sweep, deps.idleMs);
   timer.unref();
+  const birth = (id, facts) => {
+    const record2 = { id, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts, pending: /* @__PURE__ */ new Map(), workerState: void 0, workerIdleSeconds: void 0 };
+    entries.set(id, record2);
+    return record2;
+  };
   const observeExchange = (request7) => {
     const method = (request7.method ?? "").toUpperCase();
     const path41 = new URL(request7.url ?? "/", "http://127.0.0.1").pathname;
@@ -66842,30 +67087,30 @@ function createRcSessionTracker(deps) {
       if (method !== "POST") {
         return void 0;
       }
-      let accepted = false;
-      let buffered = 0;
+      let accepted2 = false;
+      let buffered2 = 0;
       let body = "";
       return {
         onResponse: (status) => {
-          accepted = isSuccessful(status);
+          accepted2 = isSuccessful(status);
         },
         onBodyChunk: (chunk) => {
-          if (!accepted || buffered >= RC_CREATE_RESPONSE_CAP_BYTES) {
+          if (!accepted2 || buffered2 >= RC_CREATE_RESPONSE_CAP_BYTES) {
             return;
           }
           const text2 = Buffer.from(chunk).toString("utf8");
-          body = body + text2.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered);
-          buffered = body.length;
+          body = body + text2.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered2);
+          buffered2 = body.length;
         },
         onEnd: () => {
-          if (!accepted) {
+          if (!accepted2) {
             return;
           }
           const id2 = sessionCreateId(body);
           if (id2 === void 0) {
             return;
           }
-          entries.set(id2, { id: id2, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts });
+          birth(id2, facts);
         }
       };
     }
@@ -66874,21 +67119,69 @@ function createRcSessionTracker(deps) {
     if (id?.startsWith(RC_SESSION_ID_PREFIX) !== true) {
       return void 0;
     }
-    const entry = entries.get(id);
-    if (entry === void 0) {
-      entries.set(id, { id, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts });
-    } else {
-      entry.lastSeenAt = deps.now();
-      entry.authorization = facts.authorization ?? entry.authorization;
-      entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
-      entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
-    }
+    const entry = entries.get(id) ?? birth(id, facts);
+    entry.lastSeenAt = deps.now();
+    entry.authorization = facts.authorization ?? entry.authorization;
+    entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
+    entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
+    const bodyKind = method === "POST" && rest === `${id}/worker/events` ? "worker-events" : method === "POST" && rest === `${id}/events` ? "client-events" : method === "POST" && rest === `${id}/worker/heartbeat` ? "heartbeat" : method === "PUT" && rest === `${id}/worker` ? "worker-registration" : void 0;
+    let chunks = [];
+    let buffered = 0;
+    let oversized = false;
+    let requestEnded = false;
+    let accepted;
+    let filed = false;
+    const file2 = () => {
+      if (filed || accepted !== true || !requestEnded || bodyKind === void 0) {
+        return;
+      }
+      filed = true;
+      const factsOfBody = oversized ? void 0 : parseRcRequestBody(bodyKind, Buffer.concat(chunks).toString("utf8"));
+      chunks = [];
+      const entryNow = entries.get(id);
+      if (entryNow === void 0 || factsOfBody === void 0) {
+        return;
+      }
+      const now = deps.now();
+      for (const controlRequest of factsOfBody.controlRequests) {
+        entryNow.pending.set(controlRequest.requestId, { sessionId: id, ...controlRequest, observedAt: now });
+      }
+      for (const requestId of factsOfBody.answeredRequestIds) {
+        entryNow.pending.delete(requestId);
+      }
+      if (factsOfBody.idleSeconds !== void 0) {
+        entryNow.workerIdleSeconds = { value: factsOfBody.idleSeconds, observedAt: now };
+      }
+      if (factsOfBody.workerStatus !== void 0) {
+        entryNow.workerState = { value: factsOfBody.workerStatus, observedAt: now };
+      }
+    };
     const archiving = method === "POST" && rest === `${id}/archive`;
     return {
+      ...bodyKind === void 0 ? {} : {
+        onRequestChunk: (chunk) => {
+          if (oversized) {
+            return;
+          }
+          chunks.push(Buffer.from(chunk));
+          buffered += chunk.length;
+          if (buffered > RC_REQUEST_PARSE_CAP_BYTES) {
+            oversized = true;
+            chunks = [];
+          }
+        },
+        onRequestEnd: () => {
+          requestEnded = true;
+          file2();
+        }
+      },
       onResponse: (status, headers) => {
         if (singleHeader(headers, CONFLICT_REASON_HEADER) !== void 0 || archiving && isSuccessful(status)) {
           expire(id);
+          return;
         }
+        accepted = isSuccessful(status);
+        file2();
       },
       onBodyChunk: () => {
       },
@@ -66896,16 +67189,31 @@ function createRcSessionTracker(deps) {
       }
     };
   };
+  const summaryOf = ({ id, createdAt, lastSeenAt }) => ({ id, createdAt, lastSeenAt });
+  const pendingSummaryOf = ({ sessionId, requestId, type, summary, observedAt: observedAt2 }) => ({ sessionId, requestId, type, summary, observedAt: observedAt2 });
+  const sortedEntries = () => [...entries.values()].sort((left, right) => left.createdAt - right.createdAt || (left.id < right.id ? -1 : 1));
+  const pendingSorted = (entry) => [...entry.pending.values()].sort((left, right) => left.observedAt - right.observedAt || (left.requestId < right.requestId ? -1 : 1)).map(pendingSummaryOf);
   return {
     observeExchange,
     list: () => {
       sweep();
-      return [...entries.values()].sort((left, right) => left.createdAt - right.createdAt || (left.id < right.id ? -1 : 1)).map(({ id, createdAt, lastSeenAt }) => ({ id, createdAt, lastSeenAt }));
+      return sortedEntries().map(summaryOf);
+    },
+    statusOf: (sessionId) => {
+      sweep();
+      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).map((entry) => ({ ...summaryOf(entry), workerState: entry.workerState, workerIdleSeconds: entry.workerIdleSeconds, pending: pendingSorted(entry) }));
+    },
+    pendingOf: (sessionId) => {
+      sweep();
+      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).flatMap((entry) => pendingSorted(entry));
     },
     credentialOf: (sessionId) => {
       const entry = entries.get(sessionId);
       return entry === void 0 ? void 0 : { authorization: entry.authorization, anthropicVersion: entry.anthropicVersion, anthropicClientPlatform: entry.anthropicClientPlatform };
     },
+    completePending: (sessionId, requestId) => {
+      entries.get(sessionId)?.pending.delete(requestId);
+    },
     close: () => {
       clearInterval(timer);
     }
@@ -66916,6 +67224,14 @@ function observingRoutedRoute(route, tracker) {
     ...route,
     serve: async (request7, response) => {
       const observed = tracker.observeExchange({ method: request7.method, url: request7.url, headers: request7.headers });
+      if (observed?.onRequestChunk !== void 0) {
+        request7.body.on("data", (chunk) => {
+          observed.onRequestChunk?.(chunk);
+        });
+        request7.body.on("end", () => {
+          observed.onRequestEnd?.();
+        });
+      }
       await route.serve(request7, observed === void 0 ? response : teeRoutedResponse(response, observed));
     }
   };
@@ -66982,7 +67298,7 @@ function sequenceNumsOf(body) {
   }
   return sequenceNums.length === 0 ? void 0 : sequenceNums;
 }
-function rcInjectResultFromAnswer(answer) {
+function rcEventWriteResultFromAnswer(answer) {
   if (!isSuccessful(answer.status)) {
     if (answer.status === HTTP_STATUS.unauthorized) {
       return { ok: false, message: `the API refused the observed Authorization bearer for this session (HTTP 401): the bearer went stale after the door last saw the session's traffic. The session's own client refreshes it on its next call, which the door will observe, so retry once Remote Control has been active again. API answer: ${answer.body}` };
@@ -66995,11 +67311,7 @@ function rcInjectResultFromAnswer(answer) {
   }
   return { ok: true, sequenceNums };
 }
-async function injectRcUserMessage(deps, sessionId, text2) {
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
-  }
+function rcWriteHeaders(credential) {
   const headers = { "content-type": "application/json" };
   if (credential.authorization !== void 0) {
     headers.authorization = credential.authorization;
@@ -67010,14 +67322,46 @@ async function injectRcUserMessage(deps, sessionId, text2) {
   if (credential.anthropicClientPlatform !== void 0) {
     headers["anthropic-client-platform"] = credential.anthropicClientPlatform;
   }
+  return headers;
+}
+async function injectRcUserMessage(deps, sessionId, text2) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
   const body = JSON.stringify(buildRcEventWriteBody(buildRcUserMessagePayload(deps.newUuid(), sessionId, text2)));
   let answer;
   try {
-    answer = await deps.dial.writeEvents(sessionId, headers, body);
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
   } catch (error62) {
     return { ok: false, message: `the door could not reach the API host to inject into session ${sessionId}: ${error62 instanceof Error ? error62.message : String(error62)}` };
   }
-  return rcInjectResultFromAnswer(answer);
+  return rcEventWriteResultFromAnswer(answer);
+}
+function buildRcControlResponsePayload(requestId, decision) {
+  const result = decision.approve ? { behavior: "allow" } : { behavior: "deny", message: decision.message ?? "" };
+  return { type: "control_response", response: { subtype: "success", request_id: requestId, response: result } };
+}
+async function answerRcControlRequest(deps, sessionId, requestId, decision) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
+  if (!deps.pendingOf(sessionId).some((pending) => pending.requestId === requestId)) {
+    return { ok: false, message: `the front door has not observed control request ${requestId} pending on session ${sessionId}: it was answered already (by this door or by an attached client), it passed its answer deadline (the protocol's permission round-trip bound), or it never passed through this door` };
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcControlResponsePayload(requestId, decision)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error62) {
+    return { ok: false, message: `the door could not reach the API host to answer on session ${sessionId}: ${error62 instanceof Error ? error62.message : String(error62)}` };
+  }
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.completePending(sessionId, requestId);
+  }
+  return result;
 }
 
 // src/usage/providerQuota.ts
@@ -67377,7 +67721,9 @@ function realFrontDoorSupervisorPorts(paths) {
     isRunning: realIsProcessRunning,
     startProviderListener: async (preferredPort) => {
       const authority = loadCa();
-      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, dial: realRcEventDial(), newUuid: import_node_crypto11.randomUUID }, sessionId, text2);
+      const rcDial = realRcEventDial();
+      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, dial: rcDial, newUuid: import_node_crypto11.randomUUID }, sessionId, text2);
+      const rcAnswer = async (sessionId, requestId, decision) => await answerRcControlRequest({ credentialOf: rcTracker.credentialOf, pendingOf: (id) => rcTracker.pendingOf(id), completePending: rcTracker.completePending, dial: rcDial }, sessionId, requestId, decision);
       realFarmFs.mkdirp(paths.frontdoorDir);
       realFarmFs.writeFilePrivate(paths.frontdoorControlTokenFile, `${rcControlToken}
 `);
@@ -67387,7 +67733,7 @@ function realFrontDoorSupervisorPorts(paths) {
         },
         log,
         mintLeaf(authority, LOOPBACK_LEAF_NAMES, /* @__PURE__ */ new Date()),
-        createRcControlHandler({ expectedToken: rcControlToken, list: rcTracker.list, inject: rcInject })
+        createRcControlHandler({ expectedToken: rcControlToken, list: rcTracker.list, statusOf: rcTracker.statusOf, pendingOf: rcTracker.pendingOf, inject: rcInject, answer: rcAnswer })
       );
       const handle = await listenFrontDoor(server, { ...preferredPort === void 0 ? {} : { preferredPort }, ca: authority.certPem, onError: onListenerError("provider") });
       return {
@@ -67516,6 +67862,35 @@ function formatRcSessionList(sessions) {
   }
   return sessions.map((session) => `${session.id}  created ${new Date(session.createdAt).toISOString()}  last seen ${new Date(session.lastSeenAt).toISOString()}`);
 }
+function formatRcSessionStatus(statuses) {
+  if (statuses.length === 0) {
+    return ["no Remote Control sessions observed"];
+  }
+  const lines = [];
+  for (const status of statuses) {
+    lines.push(`${status.id}  created ${new Date(status.createdAt).toISOString()}  last seen ${new Date(status.lastSeenAt).toISOString()}`);
+    const worker = status.workerState === void 0 && status.workerIdleSeconds === void 0 ? "not observed" : [
+      status.workerState === void 0 ? "state unknown" : `state ${status.workerState.value} since ${new Date(status.workerState.observedAt).toISOString()}`,
+      status.workerIdleSeconds === void 0 ? "idle unknown" : `idle ${String(status.workerIdleSeconds.value)} s as of ${new Date(status.workerIdleSeconds.observedAt).toISOString()}`
+    ].join(", ");
+    lines.push(`  worker: ${worker}`);
+    if (status.pending.length === 0) {
+      lines.push("  pending: none");
+    } else {
+      lines.push("  pending:");
+      for (const pending of status.pending) {
+        lines.push(...formatRcPendingList([pending]).map((line) => `    ${line}`));
+      }
+    }
+  }
+  return lines;
+}
+function formatRcPendingList(pending) {
+  if (pending.length === 0) {
+    return ["no pending control requests observed"];
+  }
+  return pending.map((request7) => `${request7.sessionId}  ${request7.requestId}  ${request7.type}${request7.summary === "" ? "" : `  ${request7.summary}`}  observed ${new Date(request7.observedAt).toISOString()}`);
+}
 function frontDoorRcControlFromState(fsPort, paths) {
   const state = readFrontDoorState(fsPort, paths.frontdoorStateFile);
   if (state?.port === void 0) {
@@ -67549,9 +67924,10 @@ function registerFrontDoorCommand(program2, deps) {
     }),
     ["agent-shim frontdoor status", "agent-shim frontdoor status --json"]
   );
-  const rc = withExamples(frontdoor.command("rc").description("Observe the Remote Control sessions passing through the front door, and send a prompt into one."), [
-    "agent-shim frontdoor rc list"
-  ]);
+  const rc = withExamples(
+    frontdoor.command("rc").description("Observe the Remote Control sessions passing through the front door, send a prompt into one, and answer its pending control requests."),
+    ["agent-shim frontdoor rc list", "agent-shim frontdoor rc pending"]
+  );
   withExamples(
     rc.command("list").description("List the Remote Control sessions the front door has observed, with when each was created and last seen. Read-only.").option("--json", "Print the sessions as JSON.").action(async (options) => {
       const sessions = await frontDoorRcControlFromState(realFarmFs, paths).listSessions();
@@ -67565,6 +67941,32 @@ function registerFrontDoorCommand(program2, deps) {
     }),
     ["agent-shim frontdoor rc list", "agent-shim frontdoor rc list --json"]
   );
+  withExamples(
+    rc.command("status").description("Report each observed Remote Control session's worker state and idle from its latest observed heartbeat and registration, with its pending control requests. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print the statuses as JSON.").action(async (session, options) => {
+      const statuses = await frontDoorRcControlFromState(realFarmFs, paths).statusOf(session);
+      if (options.json === true) {
+        printJson({ statuses });
+        return;
+      }
+      for (const line of formatRcSessionStatus(statuses)) {
+        console.log(line);
+      }
+    }),
+    ["agent-shim frontdoor rc status", "agent-shim frontdoor rc status cse_00000000-0000-4000-8000-000000000000 --json"]
+  );
+  withExamples(
+    rc.command("pending").description("List the control requests (tool and plan approvals above all) the front door has observed and that are still awaiting an answer. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print the pending requests as JSON.").action(async (session, options) => {
+      const pending = await frontDoorRcControlFromState(realFarmFs, paths).pendingOf(session);
+      if (options.json === true) {
+        printJson({ pending });
+        return;
+      }
+      for (const line of formatRcPendingList(pending)) {
+        console.log(line);
+      }
+    }),
+    ["agent-shim frontdoor rc pending", "agent-shim frontdoor rc pending --json"]
+  );
   withExamples(
     rc.command("send").description("Send a text prompt into one observed Remote Control session, arriving as a message from an attached client would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--text <text>", "The prompt text to deliver.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
       const result = await frontDoorRcControlFromState(realFarmFs, paths).sendPrompt(options.session, options.text);
@@ -67579,6 +67981,29 @@ function registerFrontDoorCommand(program2, deps) {
     }),
     ['agent-shim frontdoor rc send --session cse_00000000-0000-4000-8000-000000000000 --text "run the tests"']
   );
+  withExamples(
+    rc.command("answer").description("Answer one pending control request on an observed session, approving or denying it as an attached client's approval would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--request <id>", "The control request's id, as `frontdoor rc pending` shows it.").option("--approve", "Approve the request.").option("--deny", "Deny the request.").option("--text <text>", "The denial message the worker sees; applies to --deny only.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      if (options.approve === options.deny) {
+        throw new UsageError("answer exactly one way: pass --approve or --deny, not both and not neither");
+      }
+      if (options.approve === true && options.text !== void 0) {
+        throw new UsageError("--text is the denial message; an approval carries no text (the protocol's allow result has no message field)");
+      }
+      const result = await frontDoorRcControlFromState(realFarmFs, paths).answerRequest(options.session, options.request, { approve: options.approve === true, message: options.deny === true ? options.text : void 0 });
+      if (!result.ok) {
+        throw new Error(result.message);
+      }
+      if (options.json === true) {
+        printJson({ session: options.session, request: options.request, sequenceNums: result.sequenceNums });
+        return;
+      }
+      console.log(`${options.approve === true ? "approved" : "denied"} ${options.request} on ${options.session}: sequence_num ${result.sequenceNums.join(", ")}`);
+    }),
+    [
+      "agent-shim frontdoor rc answer --session cse_00000000-0000-4000-8000-000000000000 --request req_00000000-0000-4000-8000-000000000000 --approve",
+      'agent-shim frontdoor rc answer --session cse_00000000-0000-4000-8000-000000000000 --request req_00000000-0000-4000-8000-000000000000 --deny --text "not today"'
+    ]
+  );
   program2.command("__frontdoor-supervisor", { hidden: true }).description("Internal: serve the front-door routing listeners. Started by the launcher; never run by hand.").allowUnknownOption().action(async () => {
     const idleShutdownMinutes = readGlobalConfig(paths)?.frontdoor?.idleShutdownMinutes ?? FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES;
     process.on("SIGTERM", () => {
@@ -69247,7 +69672,7 @@ function headroomSpawnEnv(parentEnv, allowlist, settings2, trustBundlePath) {
   };
 }
 function headroomProxyArgs(socketPath, settings2) {
-  return ["proxy", "--uds", socketPath, ...settingsArgs(settings2)];
+  return ["proxy", "--uds", socketPath, "--no-rate-limit", ...settingsArgs(settings2)];
 }
 async function readyOverSocket(socketPath) {
   return await new Promise((resolve) => {