claude-use 9.16.0 → 9.18.0

package/dist/index.mjs

@@ -2669,7 +2669,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.16.0",
+      version: "9.18.0",
       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>",
@@ -4791,22 +4791,25 @@ function rankPool(input) {
       return { ...candidate, feasible: true };
     }
     const drySpots = [];
+    const dryAfterMs = [];
     if (fiveHour !== void 0 && pace !== void 0) {
       const runsDryInMs = fiveHour.remaining / pace;
       if (runsDryInMs < fiveHour.untilResetMs) {
+        dryAfterMs.push(runsDryInMs);
         drySpots.push(`5h window would run dry in ${formatAge(runsDryInMs)}, before it resets in ${formatAge(fiveHour.untilResetMs)}`);
       }
     }
     if (sevenDay !== void 0 && sevenDayBurn !== void 0) {
       const runsDryInMs = sevenDay.remaining / sevenDayBurn;
       if (runsDryInMs < sevenDay.untilResetMs) {
+        dryAfterMs.push(runsDryInMs);
         drySpots.push(`7d window would run dry in ${formatAge(runsDryInMs)}, before it resets in ${formatAge(sevenDay.untilResetMs)}`);
       }
     }
     if (drySpots.length === 0) {
       return { ...candidate, feasible: true };
     }
-    return { ...candidate, feasible: false, reasons: [...drySpots, ...candidate.reasons] };
+    return { ...candidate, feasible: false, runsDryAtMs: nowMs + Math.min(...dryAfterMs), reasons: [...drySpots, ...candidate.reasons] };
   });
   const ordered = input.preference === "listed" ? [...candidates] : [...candidates].sort(
     (left, right) => CLASS_ORDER[left.class] - CLASS_ORDER[right.class] || Number(left.policyDemoted ?? false) - Number(right.policyDemoted ?? false) || Number(right.feasible) - Number(left.feasible) || (right.headroom ?? 1) - (left.headroom ?? 1) || (right.score ?? 0) - (left.score ?? 0) || left.identity.localeCompare(right.identity)
@@ -4828,11 +4831,13 @@ function rankPool(input) {
   const pick = ordered.find((candidate) => candidate.class !== "ineligible");
   const returns = ordered.flatMap((candidate) => candidate.blockedUntilMs === void 0 ? [] : [{ identity: candidate.identity, atMs: candidate.blockedUntilMs }]);
   const earliestReturn = returns.length === 0 ? void 0 : returns.reduce((soonest, entry) => entry.atMs < soonest.atMs ? entry : soonest);
+  const holdForReturn = pick?.runsDryAtMs === void 0 ? void 0 : returns.filter((entry) => entry.atMs < (pick.runsDryAtMs ?? 0)).reduce((soonest, entry) => soonest === void 0 || entry.atMs < soonest.atMs ? entry : soonest, void 0);
   return {
     candidates: ordered,
     ...pick === void 0 ? { ...earliestReturn === void 0 ? {} : { earliestReturn } } : { pick },
     ...movedOff === void 0 || pick === void 0 ? {} : { movedOff },
-    ...pick?.planReturnsAtMs === void 0 ? {} : { planReturn: { identity: pick.identity, atMs: pick.planReturnsAtMs } }
+    ...pick?.planReturnsAtMs === void 0 ? {} : { planReturn: { identity: pick.identity, atMs: pick.planReturnsAtMs } },
+    ...holdForReturn === void 0 ? {} : { holdForReturn }
   };
 }
 var MS_PER_SECOND4, MS_PER_HOUR2, HOURS_PER_DAY2, FIVE_HOURS, PROMPT_CACHE_TTL_HOURS, PERCENT, SEVEN_DAYS, FIVE_HOUR_WINDOW_MS, SEVEN_DAY_WINDOW_MS, PROMPT_CACHE_TTL_MS, CLASS_ORDER;
@@ -6630,7 +6635,7 @@ var init_headers = __esm({
 });
 
 // src/launcher/flags.ts
-import path34 from "node:path";
+import path35 from "node:path";
 function resolveLaunchFlags(params) {
   return {
     skipPermissions: params.flags?.skipPermissions ?? parseEnvBool("AGENT_SHIM_SKIP_PERMISSIONS", params.env.AGENT_SHIM_SKIP_PERMISSIONS) ?? params.cascade?.skipPermissions ?? false,
@@ -6661,7 +6666,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = path34.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = path35.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -6782,12 +6787,17 @@ function resolvePoolLaunch(params) {
     if (graph.ranking.candidates.length === 0) {
       return { ok: false, message: `agent-shim: no member of pool "${poolName}" is an existing identity.` };
     }
-    const { pick, earliestReturn, movedOff, planReturn } = graph.ranking;
+    const { pick, earliestReturn, movedOff, planReturn, holdForReturn } = graph.ranking;
     if (pick !== void 0 && params.wait && planReturn !== void 0) {
       log.info(`agent-shim: pool "${poolName}" would continue ${planReturn.identity} on extra usage; waiting until ${new Date(planReturn.atMs).toISOString()} for its plan window`);
       params.sleep(Math.max(planReturn.atMs - nowMs, 0));
       continue;
     }
+    if (pick !== void 0 && params.wait && holdForReturn !== void 0) {
+      log.info(`agent-shim: pool "${poolName}" pick ${pick.identity} would run dry before its window resets; waiting until ${new Date(holdForReturn.atMs).toISOString()} for ${holdForReturn.identity}`);
+      params.sleep(Math.max(holdForReturn.atMs - nowMs, 0));
+      continue;
+    }
     if (pick !== void 0) {
       if (params.recordPick) {
         recordStickyPick(params.usageFs, params.paths.usagePicksFile, params.cwd, pick.identity, nowMs);
@@ -6928,7 +6938,7 @@ var init_launchHook = __esm({
 
 // src/launcher.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import path35 from "node:path";
+import path36 from "node:path";
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
     return { ok: false, status: 1, message: `agent-shim: identity ${identity} needs its credential resolved, but this launcher has no credential port wired` };
@@ -7038,7 +7048,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path35.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path36.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -7150,7 +7160,7 @@ function decideLaunch(params, readOnly) {
     extraFlags: splitExtraFlags(env.CLAUDE_EXTRA_FLAGS),
     passthrough: parsedArgv.rest
   });
-  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : path35.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : path36.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -7191,7 +7201,7 @@ function prepareLaunch(params) {
   );
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: path35.join(paths.root, "update.check"),
+    checkPath: path36.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
@@ -7351,12 +7361,12 @@ var init_launcher = __esm({
 });
 
 // src/ownCli.ts
-import path36 from "node:path";
+import path37 from "node:path";
 function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string" ? __AGENT_SHIM_DIST_DIR__ : void 0) {
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return path36.join(distDir, OWN_CLI_FILE_NAME);
+  return path37.join(distDir, OWN_CLI_FILE_NAME);
 }
 var OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
@@ -7445,10 +7455,10 @@ request.on("error", (error) => finish(failed, (error.code ? error.code + ": " :
 
 // src/frontdoor/trust.ts
 import { createHash as createHash6 } from "node:crypto";
-import path37 from "node:path";
+import path38 from "node:path";
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, variable, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || path37.resolve(inherited) === path37.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || path38.resolve(inherited) === path38.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7466,7 +7476,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = path37.join(bundlesDir, `${createHash6("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = path38.join(bundlesDir, `${createHash6("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
@@ -7866,7 +7876,7 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY4, DAYS_PER_MONTH, ZAI_HOST, ZAI_QUOTA_URL, ZAI_UNIT_HOURS, ZAI_UNIT_MONTHS, ZAI_UNIT_MS, ZaiLimitSchema, ZaiResponseSchema, OPENROUTER_HOST, OPENROUTER_KEY_URL, OPENROUTER_CREDITS_URL, MS_PER_DAY3, OpenRouterKeySchema, OpenRouterCreditsSchema;
 var init_providerQuota = __esm({
   "src/usage/providerQuota.ts"() {
@@ -7884,35 +7894,35 @@ var init_providerQuota = __esm({
       [ZAI_UNIT_HOURS, SECONDS_PER_HOUR * MS_PER_SECOND7],
       [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY4 * SECONDS_PER_HOUR * MS_PER_SECOND7]
     ]);
-    ZaiLimitSchema = z27.object({
-      type: z27.string(),
-      unit: z27.number().int(),
-      number: z27.number().int().positive(),
-      percentage: z27.number().nonnegative(),
-      nextResetTime: z27.number().positive().optional(),
-      usage: z27.number().nonnegative().optional(),
-      currentValue: z27.number().nonnegative().optional(),
-      remaining: z27.number().nonnegative().optional()
+    ZaiLimitSchema = z28.object({
+      type: z28.string(),
+      unit: z28.number().int(),
+      number: z28.number().int().positive(),
+      percentage: z28.number().nonnegative(),
+      nextResetTime: z28.number().positive().optional(),
+      usage: z28.number().nonnegative().optional(),
+      currentValue: z28.number().nonnegative().optional(),
+      remaining: z28.number().nonnegative().optional()
     });
-    ZaiResponseSchema = z27.object({
-      success: z27.boolean(),
-      msg: z27.string().optional(),
-      data: z27.object({ level: z27.string().optional(), limits: z27.array(ZaiLimitSchema) })
+    ZaiResponseSchema = z28.object({
+      success: z28.boolean(),
+      msg: z28.string().optional(),
+      data: z28.object({ level: z28.string().optional(), limits: z28.array(ZaiLimitSchema) })
     });
     OPENROUTER_HOST = "openrouter.ai";
     OPENROUTER_KEY_URL = `https://${OPENROUTER_HOST}/api/v1/key`;
     OPENROUTER_CREDITS_URL = `https://${OPENROUTER_HOST}/api/v1/credits`;
     MS_PER_DAY3 = HOURS_PER_DAY4 * SECONDS_PER_HOUR * MS_PER_SECOND7;
-    OpenRouterKeySchema = z27.object({
-      data: z27.object({
-        limit: z27.number().nonnegative().nullable(),
-        limit_remaining: z27.number().nullable(),
-        limit_reset: z27.string().nullable(),
-        is_free_tier: z27.boolean().optional(),
-        free_model_daily_requests: z27.object({ used: z27.number().nonnegative(), limit: z27.number().nonnegative(), remaining: z27.number() }).optional()
+    OpenRouterKeySchema = z28.object({
+      data: z28.object({
+        limit: z28.number().nonnegative().nullable(),
+        limit_remaining: z28.number().nullable(),
+        limit_reset: z28.string().nullable(),
+        is_free_tier: z28.boolean().optional(),
+        free_model_daily_requests: z28.object({ used: z28.number().nonnegative(), limit: z28.number().nonnegative(), remaining: z28.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = z27.object({ data: z27.object({ total_credits: z27.number().nonnegative(), total_usage: z27.number().nonnegative() }) });
+    OpenRouterCreditsSchema = z28.object({ data: z28.object({ total_credits: z28.number().nonnegative(), total_usage: z28.number().nonnegative() }) });
   }
 });
 
@@ -8525,8 +8535,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path38) {
-  return path38?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path39) {
+  return path39?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -9061,11 +9071,11 @@ function createRcSessionTracker(deps) {
   };
   const observeExchange = (request4) => {
     const method = (request4.method ?? "").toUpperCase();
-    const path38 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
-    if (!path38.startsWith(RC_SESSIONS_PATH_PREFIX)) {
+    const path39 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
+    if (!path39.startsWith(RC_SESSIONS_PATH_PREFIX)) {
       return void 0;
     }
-    const tail = path38.slice(RC_SESSIONS_PATH_PREFIX.length);
+    const tail = path39.slice(RC_SESSIONS_PATH_PREFIX.length);
     const facts = {
       oauthAuthorization: oauthAuthorizationOf(request4.headers),
       anthropicVersion: singleHeader(request4.headers, "anthropic-version"),
@@ -9447,8 +9457,8 @@ var RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
 function isRcReadFileEncoding(value) {
   return RC_READ_FILE_ENCODINGS.some((encoding) => encoding === value);
 }
-function buildRcReadFilePayload(requestId, path38, options) {
-  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path38, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
+function buildRcReadFilePayload(requestId, path39, options) {
+  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path39, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
 }
 function buildRcFileSuggestionsPayload(requestId, query) {
   return buildRcControlRequestPayload(requestId, { subtype: "file_suggestions", query });
@@ -9550,15 +9560,15 @@ async function getRcSessionContextUsage(deps, sessionId, detail) {
   const result = await deliverRcClientPayload(deps, sessionId, buildRcGetContextUsagePayload(requestId, detail), `request the context usage of session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
-async function readRcSessionFile(deps, sessionId, path38, options) {
-  if (path38 === "") {
+async function readRcSessionFile(deps, sessionId, path39, options) {
+  if (path39 === "") {
     return { ok: false, message: "a read-file write needs a non-empty path: the SDK's own field names the file the worker resolves against the session's cwd, and an empty string names none" };
   }
   if (options?.maxBytes !== void 0 && (!Number.isInteger(options.maxBytes) || options.maxBytes <= 0)) {
     return { ok: false, message: "a read-file write's max-bytes is a positive whole number of bytes: the SDK's own field caps the read, and a zero or negative cap reads nothing" };
   }
   const requestId = deps.newUuid();
-  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path38, options), `read ${path38} from session ${sessionId}`);
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path39, options), `read ${path39} from session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
 async function suggestRcSessionFiles(deps, sessionId, query) {
@@ -9727,11 +9737,11 @@ function createRcControlHandler(deps) {
       path: "read-file",
       read: (body) => {
         const session = bodyString(body, "session");
-        const path38 = bodyString(body, "path");
+        const path39 = bodyString(body, "path");
         const maxBytes = "maxBytes" in body ? bodyPositiveInteger(body, "maxBytes") : void 0;
         const encoding = "encoding" in body && isRcReadFileEncoding(body.encoding) ? body.encoding : void 0;
-        const refused2 = session === void 0 || path38 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
-        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path38, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
+        const refused2 = session === void 0 || path39 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
+        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path39, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
       }
     },
     {
@@ -10041,9 +10051,9 @@ function requestIdOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
-  const listAnswerOf = async (path38, what) => {
+  const listAnswerOf = async (path39, what) => {
     try {
-      return await transport.request({ method: "GET", path: path38, headers });
+      return await transport.request({ method: "GET", path: path39, headers });
     } catch (error) {
       throw new Error(`${what}: could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -10115,10 +10125,10 @@ function frontDoorRcControl(transport, token) {
     }
     return pending;
   };
-  const writeOf = async (path38, body, describeFailure2) => {
+  const writeOf = async (path39, body, describeFailure2) => {
     let answer;
     try {
-      answer = await transport.request({ method: "POST", path: path38, headers: { ...headers, "content-type": "application/json" }, body });
+      answer = await transport.request({ method: "POST", path: path39, headers: { ...headers, "content-type": "application/json" }, body });
     } catch (error) {
       return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
     }
@@ -10149,10 +10159,10 @@ function frontDoorRcControl(transport, token) {
     endSession: async (sessionId, reason) => await writeOf(`${CONTROL_PATH_PREFIX}/end-session`, JSON.stringify({ session: sessionId, ...reason === void 0 ? {} : { reason } }), (status, message) => `ending ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getUsage: async (sessionId, skipBehaviors) => await writeOf(`${CONTROL_PATH_PREFIX}/get-usage`, JSON.stringify({ session: sessionId, ...skipBehaviors === void 0 ? {} : { skipBehaviors } }), (status, message) => `requesting the usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getContextUsage: async (sessionId, detail) => await writeOf(`${CONTROL_PATH_PREFIX}/get-context-usage`, JSON.stringify({ session: sessionId, ...detail === void 0 ? {} : { detail } }), (status, message) => `requesting the context usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    readFile: async (sessionId, path38, options) => await writeOf(
+    readFile: async (sessionId, path39, options) => await writeOf(
       `${CONTROL_PATH_PREFIX}/read-file`,
-      JSON.stringify({ session: sessionId, path: path38, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
-      (status, message) => `reading ${path38} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
+      JSON.stringify({ session: sessionId, path: path39, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
+      (status, message) => `reading ${path39} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
     ),
     fileSuggestions: async (sessionId, query) => await writeOf(`${CONTROL_PATH_PREFIX}/file-suggestions`, JSON.stringify({ session: sessionId, query }), (status, message) => `requesting file suggestions from ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     keepAlive: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/keep-alive`, JSON.stringify({ session: sessionId }), (status, message) => `keeping ${sessionId} alive failed (HTTP ${String(status)}): ${message}`),
@@ -10311,12 +10321,12 @@ function tlsFacts(options) {
 }
 function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const post = async (path38, headers, body) => await new Promise((resolve, reject) => {
+  const post = async (path39, headers, body) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method: "POST",
-      path: path38,
+      path: path39,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, "content-length": String(Buffer.byteLength(body, "utf8")) },
       agent
@@ -10381,12 +10391,12 @@ function lateRcStreamDial(resolve) {
 }
 function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const request4 = async (method, path38, headers, body, signal) => await new Promise((resolve, reject) => {
+  const request4 = async (method, path39, headers, body, signal) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method,
-      path: path38,
+      path: path39,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, ...body === void 0 ? {} : { "content-length": String(Buffer.byteLength(body, "utf8")) } },
       agent,
@@ -10428,9 +10438,9 @@ function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_P
       return { status, body: await readAll(response) };
     },
     openStream: async (sessionId, headers, resume, signal) => {
-      const path38 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
+      const path39 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
       const streamHeaders = resume === void 0 ? headers : { ...headers, "last-event-id": String(resume.fromSequenceNum) };
-      const { status, response } = await request4("GET", path38, streamHeaders, void 0, signal);
+      const { status, response } = await request4("GET", path39, streamHeaders, void 0, signal);
       if (!isSuccessful2(status)) {
         await readAll(response);
         return { status, chunks: NO_CHUNKS };
@@ -10897,6 +10907,7 @@ var RC_ORPC_PATH_PREFIX = "/__agent-shim/orpc";
 var RC_OPENAPI_DOC_PATH = "/openapi.json";
 var RC_SUBSCRIBER_BUFFER_EVENTS = 100;
 var READ_ONLY_OPERATION_EXTENSION = "x-agent-shim-read-only";
+var SESSION_HISTORY_TAG = "agent-trees";
 function doorApiBearer(headers) {
   const presented = headers.authorization;
   const bearerPrefix = "bearer ".length;
@@ -11311,8 +11322,8 @@ init_cliError();
 init_realPorts();
 
 // src/frontdoor/controlApi.ts
-import { createORPCClient as createORPCClient2, ORPCError as ORPCError6 } from "@orpc/client";
-import { openapi as openapi7 } from "@orpc/openapi";
+import { createORPCClient as createORPCClient2, ORPCError as ORPCError7 } from "@orpc/client";
+import { openapi as openapi8 } from "@orpc/openapi";
 
 // src/checkReport.ts
 init_classify();
@@ -11581,19 +11592,19 @@ function writePools(paths, pools) {
   applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
 }
 function poolCycleOf(pools, name) {
-  const walk = (current, path38) => {
+  const walk = (current, path39) => {
     for (const entry of pools[current]?.identities ?? []) {
       const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
         continue;
       }
       if (nested === name) {
-        return [...path38, nested];
+        return [...path39, nested];
       }
-      if (path38.includes(nested)) {
+      if (path39.includes(nested)) {
         continue;
       }
-      const found = walk(nested, [...path38, nested]);
+      const found = walk(nested, [...path39, nested]);
       if (found !== void 0) {
         return found;
       }
@@ -13727,7 +13738,7 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path38, summary) => authed.meta(openapi3({ method: "POST", path: path38, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path39, summary) => authed.meta(openapi3({ method: "POST", path: path39, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
@@ -14169,6 +14180,166 @@ function createLaunchApiRouter(deps) {
   };
 }
 
+// src/frontdoor/agentTreesApi.ts
+import { ORPCError as ORPCError6 } from "@orpc/client";
+import { openapi as openapi7 } from "@orpc/openapi";
+import { z as z26 } from "zod";
+
+// src/agents/schema.ts
+import { z as z25 } from "zod";
+var AgentMetaSchema = z25.looseObject({
+  agentType: z25.string(),
+  isFork: z25.boolean().optional(),
+  description: z25.string().optional(),
+  name: z25.string().optional(),
+  toolUseId: z25.string().optional(),
+  spawnDepth: z25.number().int().nonnegative().optional(),
+  parentAgentId: z25.string().optional(),
+  model: z25.string().optional(),
+  requestShape: z25.string().optional(),
+  requestNonInteractive: z25.boolean().optional(),
+  workflowPhase: z25.string().optional(),
+  taskKind: z25.string().optional(),
+  teamName: z25.string().optional(),
+  worktreePath: z25.string().optional(),
+  worktreeBranch: z25.string().optional(),
+  stoppedByUser: z25.boolean().optional()
+});
+var AgentKindSchema = z25.enum(["subagent", "fork", "workflow-agent", "teammate"]);
+var AgentNodeSchema = z25.lazy(
+  () => z25.strictObject({
+    id: z25.string(),
+    kind: AgentKindSchema,
+    agentType: z25.string(),
+    description: z25.string().optional(),
+    name: z25.string().optional(),
+    toolUseId: z25.string().optional(),
+    spawnDepth: z25.number().int().nonnegative().optional(),
+    model: z25.string().optional(),
+    background: z25.boolean().optional(),
+    workflowRunId: z25.string().optional(),
+    workflowPhase: z25.string().optional(),
+    teamName: z25.string().optional(),
+    stoppedByUser: z25.boolean().optional(),
+    transcript: z25.string(),
+    children: z25.array(AgentNodeSchema)
+  })
+);
+var TaskItemSchema = z25.strictObject({
+  id: z25.string(),
+  subject: z25.string(),
+  description: z25.string().optional(),
+  status: z25.string(),
+  /** What a spinner shows while the task runs. */
+  activeForm: z25.string().optional(),
+  /** The teammate or agent name the task is assigned to, as Agent Teams writes it. */
+  owner: z25.string().optional(),
+  /** Free-form data the harness attaches to a task, kept as written. */
+  metadata: z25.record(z25.string(), z25.unknown()).optional(),
+  blocks: z25.array(z25.string()),
+  blockedBy: z25.array(z25.string()),
+  /** The id of the shared task list this task belongs to (a team's name, or a custom list id), absent for the session's own list. */
+  taskList: z25.string().optional()
+});
+var WorkflowRunSchema = z25.strictObject({
+  runId: z25.string(),
+  workflowName: z25.string().optional(),
+  status: z25.string().optional(),
+  startTime: z25.number().optional(),
+  phases: z25.array(z25.string()),
+  summary: z25.string().optional()
+});
+var AgentTreeProblemSchema = z25.strictObject({
+  /** Relative to the identity's configuration directory. */
+  path: z25.string(),
+  reason: z25.string()
+});
+var SessionSummarySchema = z25.strictObject({
+  project: z25.string(),
+  sessionId: z25.string(),
+  superseded: z25.boolean(),
+  /** The directory and transcript stem exactly as on disk, which differs from `sessionId` for a superseded session. */
+  entry: z25.string(),
+  agentCount: z25.number().int().nonnegative(),
+  workflowRunCount: z25.number().int().nonnegative(),
+  /** When the transcript was last written, as an ISO instant; absent when there is no transcript file. */
+  updatedAt: z25.iso.datetime().optional(),
+  identities: z25.array(z25.string())
+});
+var SessionAgentTreeSchema = z25.strictObject({
+  project: z25.string(),
+  sessionId: z25.string(),
+  /** True for a session directory a resume superseded (`<session-id>.superseded-<epoch-ms>`). */
+  superseded: z25.boolean(),
+  /** The agents the session itself spawned, each with its descendants. */
+  agents: z25.array(AgentNodeSchema),
+  tasks: z25.array(TaskItemSchema),
+  workflowRuns: z25.array(WorkflowRunSchema),
+  problems: z25.array(AgentTreeProblemSchema)
+});
+
+// src/frontdoor/agentTreesApi.ts
+init_cliError();
+var AgentTreesListInputSchema = z26.strictObject({
+  /** Only this identity's sessions. */
+  identity: z26.string().optional(),
+  /** Include sessions that spawned no agent and ran no workflow. */
+  all: z26.boolean().optional()
+});
+var AgentTreesListOutputSchema = z26.array(SessionSummarySchema);
+var AgentTreesShowInputSchema = z26.strictObject({
+  /** A session id, or an unambiguous prefix of one. */
+  session: z26.string().min(1),
+  /** Look only in this identity. */
+  identity: z26.string().optional()
+});
+var AgentTreesShowOutputSchema = z26.strictObject({ identities: z26.array(z26.string()), ...SessionAgentTreeSchema.shape });
+function asBadRequest(error) {
+  if (error instanceof CliError) {
+    throw new ORPCError6("BAD_REQUEST", { message: error.message });
+  }
+  throw error;
+}
+function createAgentTreesApiRouter(deps) {
+  const authed = doorApiAuth(deps.expectedToken);
+  return {
+    agentTrees: {
+      list: authed.meta(
+        openapi7({
+          method: "POST",
+          path: "/rest/agent-trees/list",
+          summary: "List the sessions that spawned agents or ran workflows, newest transcript first",
+          tags: [SESSION_HISTORY_TAG],
+          // A POST because the filters are a body, but the answer changes nothing.
+          spec: (current) => ({ ...current, [READ_ONLY_OPERATION_EXTENSION]: true })
+        })
+      ).input(AgentTreesListInputSchema).output(AgentTreesListOutputSchema).handler(({ input }) => {
+        try {
+          return deps.sessionList(input).map((session) => ({ ...session, identities: [...session.identities] }));
+        } catch (error) {
+          return asBadRequest(error);
+        }
+      }),
+      show: authed.meta(
+        openapi7({
+          method: "POST",
+          path: "/rest/agent-trees/show",
+          summary: "Show one session's agent tree, task list and workflow runs",
+          tags: [SESSION_HISTORY_TAG],
+          spec: (current) => ({ ...current, [READ_ONLY_OPERATION_EXTENSION]: true })
+        })
+      ).input(AgentTreesShowInputSchema).output(AgentTreesShowOutputSchema).handler(({ input }) => {
+        try {
+          const view = deps.sessionShow(input.session, input.identity);
+          return { identities: [...view.identities], ...view.tree };
+        } catch (error) {
+          return asBadRequest(error);
+        }
+      })
+    }
+  };
+}
+
 // src/frontdoor/controlApi.ts
 var USAGE_API_TAG = "usage";
 var FRONTDOOR_API_TAG2 = "frontdoor";
@@ -14179,12 +14350,12 @@ function createControlApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     usage: {
-      list: authed.meta(openapi7({ method: "GET", path: "/rest/usage/snapshots", summary: "List every identity's usage snapshot", tags: [USAGE_API_TAG] })).output(UsageListOutputSchema).handler(() => ({ snapshots: deps.usageSnapshots() })),
-      resets: authed.meta(openapi7({ method: "GET", path: "/rest/usage/resets", summary: "List every recorded quota window with when it resets", tags: [USAGE_API_TAG] })).output(ResetScheduleSchema).handler(() => collectResets(deps.usageSnapshots(), deps.now())),
-      effectiveWindow: authed.meta(openapi7({ method: "GET", path: "/rest/usage/windows", summary: "Read one identity's effective quota windows", tags: [USAGE_API_TAG] })).input(UsageWindowsInputSchema).output(UsageWindowsOutputSchema).handler(({ input }) => {
+      list: authed.meta(openapi8({ method: "GET", path: "/rest/usage/snapshots", summary: "List every identity's usage snapshot", tags: [USAGE_API_TAG] })).output(UsageListOutputSchema).handler(() => ({ snapshots: deps.usageSnapshots() })),
+      resets: authed.meta(openapi8({ method: "GET", path: "/rest/usage/resets", summary: "List every recorded quota window with when it resets", tags: [USAGE_API_TAG] })).output(ResetScheduleSchema).handler(() => collectResets(deps.usageSnapshots(), deps.now())),
+      effectiveWindow: authed.meta(openapi8({ method: "GET", path: "/rest/usage/windows", summary: "Read one identity's effective quota windows", tags: [USAGE_API_TAG] })).input(UsageWindowsInputSchema).output(UsageWindowsOutputSchema).handler(({ input }) => {
         const snapshot = deps.usageSnapshotOf(input.identity);
         if (snapshot === void 0) {
-          throw new ORPCError6("NOT_FOUND", { message: `identity ${input.identity} has no usage snapshot yet, so no quota window has been observed for it` });
+          throw new ORPCError7("NOT_FOUND", { message: `identity ${input.identity} has no usage snapshot yet, so no quota window has been observed for it` });
         }
         const provider = input.provider ?? ANTHROPIC_PROVIDER;
         const rateLimit = snapshot.providers[provider]?.rateLimit;
@@ -14198,34 +14369,34 @@ function createControlApiRouter(deps) {
           ...unified?.sevenDay === void 0 ? {} : { sevenDay: effectiveWindow(unified.sevenDay, now) }
         };
       }),
-      live: authed.meta(openapi7({ method: "GET", path: "/rest/usage/live", summary: "Read the live rate-limit observations the event backbone files", tags: [USAGE_API_TAG] })).input(RcSessionQuerySchema).output(UsageLiveOutputSchema).handler(({ input }) => {
+      live: authed.meta(openapi8({ method: "GET", path: "/rest/usage/live", summary: "Read the live rate-limit observations the event backbone files", tags: [USAGE_API_TAG] })).input(RcSessionQuerySchema).output(UsageLiveOutputSchema).handler(({ input }) => {
         const sessions = deps.liveRateLimits(input.session);
         if (input.session !== void 0 && sessions.length === 0) {
           if (deps.list().some((session) => session.id === input.session)) {
-            throw new ORPCError6("NOT_FOUND", { message: `session ${input.session} has filed no rate_limit_event on its stream yet: the worker emits one only once a turn has completed, so retry after this session's next turn` });
+            throw new ORPCError7("NOT_FOUND", { message: `session ${input.session} has filed no rate_limit_event on its stream yet: the worker emits one only once a turn has completed, so retry after this session's next turn` });
           }
-          throw new ORPCError6("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
+          throw new ORPCError7("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
         }
         return { latest: deps.latestRateLimit(), sessions };
       })
     },
     frontdoor: {
-      status: authed.meta(openapi7({ method: "GET", path: "/rest/frontdoor/status", summary: "Read the front door's status", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorStatusOutputSchema).handler(() => deps.frontDoorStatus()),
-      sessions: authed.meta(openapi7({ method: "GET", path: "/rest/frontdoor/sessions", summary: "Read the front door's session registry", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorSessionsOutputSchema).handler(() => ({ sessions: deps.frontDoorStatus().sessions }))
+      status: authed.meta(openapi8({ method: "GET", path: "/rest/frontdoor/status", summary: "Read the front door's status", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorStatusOutputSchema).handler(() => deps.frontDoorStatus()),
+      sessions: authed.meta(openapi8({ method: "GET", path: "/rest/frontdoor/sessions", summary: "Read the front door's session registry", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorSessionsOutputSchema).handler(() => ({ sessions: deps.frontDoorStatus().sessions }))
     },
     check: {
       // The report's own JSON shape is the contract (the same one `check --json` prints and `checkReportSchema.ts` defines), so the procedure returns exactly that conversion.
-      run: authed.meta(openapi7({ method: "GET", path: "/rest/check", summary: "Run the check report for one directory", tags: [CHECK_API_TAG] })).input(CheckRunInputSchema).output(CheckReportJsonSchema).handler(({ input }) => checkReportToJson(deps.checkReport(input.path, input.identity)))
+      run: authed.meta(openapi8({ method: "GET", path: "/rest/check", summary: "Run the check report for one directory", tags: [CHECK_API_TAG] })).input(CheckRunInputSchema).output(CheckReportJsonSchema).handler(({ input }) => checkReportToJson(deps.checkReport(input.path, input.identity)))
     },
     doctor: {
-      run: authed.meta(openapi7({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] })).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+      run: authed.meta(openapi8({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] })).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
     },
     pool: {
-      pick: authed.meta(openapi7({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] })).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input }) => {
+      pick: authed.meta(openapi8({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] })).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input }) => {
         const report = deps.poolPick(input.pool, input.path);
         if (report === void 0) {
           const live = deps.poolNames();
-          throw new ORPCError6("NOT_FOUND", {
+          throw new ORPCError7("NOT_FOUND", {
             message: live.length === 0 ? `no pools are configured, so none is named ${input.pool}` : `no pool is named ${input.pool}; the live pools are ${live.map((name) => `"${name}"`).join(", ")}`
           });
         }
@@ -14237,7 +14408,7 @@ function createControlApiRouter(deps) {
 function createDoorApiRouter(deps) {
   const control = createControlApiRouter(deps);
   const lifecycle = createLifecycleApiRouter(deps);
-  return { ...createRcApiRouter(deps), ...control, ...lifecycle, ...createConfigApiRouter(deps), ...createCodexApiRouter(deps), ...createLaunchApiRouter(deps), ...createEventsApiRouter(deps), frontdoor: { ...control.frontdoor, ...lifecycle.frontdoor } };
+  return { ...createRcApiRouter(deps), ...control, ...lifecycle, ...createConfigApiRouter(deps), ...createCodexApiRouter(deps), ...createLaunchApiRouter(deps), ...createAgentTreesApiRouter(deps), ...createEventsApiRouter(deps), frontdoor: { ...control.frontdoor, ...lifecycle.frontdoor } };
 }
 function createDoorApiNodeHandler(deps) {
   return doorApiNodeHandlerOf(createDoorApiRouter(deps), deps.expectedToken);
@@ -16305,90 +16476,7 @@ init_poolPick();
 
 // src/agents/read.ts
 import path33 from "node:path";
-import { z as z26 } from "zod";
-
-// src/agents/schema.ts
-import { z as z25 } from "zod";
-var AgentMetaSchema = z25.looseObject({
-  agentType: z25.string(),
-  isFork: z25.boolean().optional(),
-  description: z25.string().optional(),
-  name: z25.string().optional(),
-  toolUseId: z25.string().optional(),
-  spawnDepth: z25.number().int().nonnegative().optional(),
-  parentAgentId: z25.string().optional(),
-  model: z25.string().optional(),
-  requestShape: z25.string().optional(),
-  requestNonInteractive: z25.boolean().optional(),
-  workflowPhase: z25.string().optional(),
-  taskKind: z25.string().optional(),
-  teamName: z25.string().optional(),
-  worktreePath: z25.string().optional(),
-  worktreeBranch: z25.string().optional(),
-  stoppedByUser: z25.boolean().optional()
-});
-var AgentKindSchema = z25.enum(["subagent", "fork", "workflow-agent", "teammate"]);
-var AgentNodeSchema = z25.lazy(
-  () => z25.strictObject({
-    id: z25.string(),
-    kind: AgentKindSchema,
-    agentType: z25.string(),
-    description: z25.string().optional(),
-    name: z25.string().optional(),
-    toolUseId: z25.string().optional(),
-    spawnDepth: z25.number().int().nonnegative().optional(),
-    model: z25.string().optional(),
-    background: z25.boolean().optional(),
-    workflowRunId: z25.string().optional(),
-    workflowPhase: z25.string().optional(),
-    teamName: z25.string().optional(),
-    stoppedByUser: z25.boolean().optional(),
-    transcript: z25.string(),
-    children: z25.array(AgentNodeSchema)
-  })
-);
-var TaskItemSchema = z25.strictObject({
-  id: z25.string(),
-  subject: z25.string(),
-  description: z25.string().optional(),
-  status: z25.string(),
-  /** What a spinner shows while the task runs. */
-  activeForm: z25.string().optional(),
-  /** The teammate or agent name the task is assigned to, as Agent Teams writes it. */
-  owner: z25.string().optional(),
-  /** Free-form data the harness attaches to a task, kept as written. */
-  metadata: z25.record(z25.string(), z25.unknown()).optional(),
-  blocks: z25.array(z25.string()),
-  blockedBy: z25.array(z25.string()),
-  /** The id of the shared task list this task belongs to (a team's name, or a custom list id), absent for the session's own list. */
-  taskList: z25.string().optional()
-});
-var WorkflowRunSchema = z25.strictObject({
-  runId: z25.string(),
-  workflowName: z25.string().optional(),
-  status: z25.string().optional(),
-  startTime: z25.number().optional(),
-  phases: z25.array(z25.string()),
-  summary: z25.string().optional()
-});
-var AgentTreeProblemSchema = z25.strictObject({
-  /** Relative to the identity's configuration directory. */
-  path: z25.string(),
-  reason: z25.string()
-});
-var SessionAgentTreeSchema = z25.strictObject({
-  project: z25.string(),
-  sessionId: z25.string(),
-  /** True for a session directory a resume superseded (`<session-id>.superseded-<epoch-ms>`). */
-  superseded: z25.boolean(),
-  /** The agents the session itself spawned, each with its descendants. */
-  agents: z25.array(AgentNodeSchema),
-  tasks: z25.array(TaskItemSchema),
-  workflowRuns: z25.array(WorkflowRunSchema),
-  problems: z25.array(AgentTreeProblemSchema)
-});
-
-// src/agents/read.ts
+import { z as z27 } from "zod";
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
 var SUBAGENTS_DIR = "subagents";
@@ -16507,15 +16595,30 @@ function parseJson2(text) {
     return void 0;
   }
 }
-var TaskFileSchema = z26.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z26.array(z26.string()).default([]), blockedBy: z26.array(z26.string()).default([]) });
-var WorkflowRunFileSchema = z26.object({
-  runId: z26.string(),
-  workflowName: z26.string().optional(),
-  status: z26.string().optional(),
-  startTime: z26.number().optional(),
-  phases: z26.array(z26.object({ title: z26.string() })).default([]),
-  summary: z26.string().optional()
+var TaskFileSchema = z27.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z27.array(z27.string()).default([]), blockedBy: z27.array(z27.string()).default([]) });
+var WorkflowRunFileSchema = z27.object({
+  runId: z27.string(),
+  workflowName: z27.string().optional(),
+  status: z27.string().optional(),
+  startTime: z27.number().optional(),
+  phases: z27.array(z27.object({ title: z27.string() })).default([]),
+  summary: z27.string().optional()
 });
+function summariseSession(fs12, configDir, ref) {
+  const sessionRelative = path33.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = path33.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = path33.join(subagentsRelative, WORKFLOWS_DIR);
+  const isMeta = (name) => name.startsWith(AGENT_FILE_PREFIX) && name.endsWith(META_SUFFIX);
+  let agentCount = fs12.readdir(path33.join(configDir, subagentsRelative)).filter(isMeta).length;
+  for (const runDir of fs12.readdir(path33.join(configDir, workflowsUnderSubagents))) {
+    if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
+      agentCount += fs12.readdir(path33.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
+    }
+  }
+  const workflowRunCount = fs12.readdir(path33.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
+  const transcript = fs12.lstat(path33.join(configDir, PROJECTS_DIR, ref.project, `${ref.entry}${TRANSCRIPT_SUFFIX}`));
+  return { ...ref, agentCount, workflowRunCount, ...transcript === void 0 ? {} : { updatedAt: new Date(transcript.mtimeMs).toISOString() } };
+}
 function readSessionAgentTree(fs12, configDir, ref, options = {}) {
   const problems = [];
   const report = (problem) => {
@@ -16671,6 +16774,94 @@ function readWorkflowRuns(fs12, configDir, relativeDir, report) {
   return runs;
 }
 
+// src/agents/sessions.ts
+init_cliError();
+import path34 from "node:path";
+var SessionLookupError = class extends CliError {
+  constructor(message) {
+    super(message);
+    this.name = "SessionLookupError";
+  }
+};
+function identityConfigDir(identitiesDir, identity) {
+  return path34.join(identitiesDir, identity);
+}
+function historyStores(fs12, identitiesDir, identities) {
+  const byRealPath = /* @__PURE__ */ new Map();
+  for (const identity of identities) {
+    const configDir = identityConfigDir(identitiesDir, identity);
+    const real = fs12.realpath(path34.join(configDir, "projects"));
+    if (real === void 0) {
+      continue;
+    }
+    const store = byRealPath.get(real);
+    if (store === void 0) {
+      byRealPath.set(real, { configDir, identities: [identity] });
+    } else {
+      store.identities.push(identity);
+    }
+  }
+  return [...byRealPath.values()];
+}
+function collectSessionList(fs12, identitiesDir, identities, filters) {
+  const names = filters.identity === void 0 ? identities : identities.filter((name) => name === filters.identity);
+  if (filters.identity !== void 0 && names.length === 0) {
+    throw new SessionLookupError(`no identity named "${filters.identity}"`);
+  }
+  const sessions = [];
+  for (const store of historyStores(fs12, identitiesDir, names)) {
+    for (const ref of listSessions2(fs12, store.configDir)) {
+      const summary = summariseSession(fs12, store.configDir, ref);
+      if (filters.all === true || summary.agentCount > 0 || summary.workflowRunCount > 0) {
+        sessions.push({ ...summary, identities: store.identities });
+      }
+    }
+  }
+  return sessions.sort((left, right) => (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "") || left.sessionId.localeCompare(right.sessionId));
+}
+function locateSession(fs12, identitiesDir, identities, query, onlyIdentity) {
+  const names = onlyIdentity === void 0 ? identities : identities.filter((name) => name === onlyIdentity);
+  if (onlyIdentity !== void 0 && names.length === 0) {
+    throw new SessionLookupError(`no identity named "${onlyIdentity}"`);
+  }
+  const matches = [];
+  for (const store of historyStores(fs12, identitiesDir, names)) {
+    for (const ref of listSessions2(fs12, store.configDir)) {
+      if (ref.sessionId.startsWith(query)) {
+        matches.push({ identities: store.identities, configDir: store.configDir, ref });
+      }
+    }
+  }
+  const exact = matches.filter((match) => match.ref.sessionId === query);
+  const candidates = exact.length > 0 ? exact : matches;
+  const only = candidates[0];
+  if (candidates.length === 1 && only !== void 0) {
+    return only;
+  }
+  if (candidates.length === 0) {
+    throw new SessionLookupError(`no session matches "${query}"`);
+  }
+  throw new SessionLookupError(`"${query}" matches ${String(candidates.length)} sessions: ${candidates.map((match) => `${match.ref.sessionId} (${match.identities.join(", ")})`).join("; ")}; give more of the id or pass --identity`);
+}
+function showSession(fs12, identitiesDir, identities, query, onlyIdentity) {
+  const located = locateSession(fs12, identitiesDir, identities, query, onlyIdentity);
+  return { identities: located.identities, tree: readSessionAgentTree(fs12, located.configDir, located.ref) };
+}
+
+// src/agents/realFs.ts
+init_realPorts();
+import nodeFs from "node:fs";
+var realSessionFs = {
+  ...realFarmFs,
+  realpath: (candidate) => {
+    try {
+      return nodeFs.realpathSync(candidate);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
 // src/index.ts
 init_conditions();
 init_ensure();
@@ -16782,6 +16973,10 @@ export {
   AgentKindSchema,
   AgentMetaSchema,
   AgentNodeSchema,
+  AgentTreesListInputSchema,
+  AgentTreesListOutputSchema,
+  AgentTreesShowInputSchema,
+  AgentTreesShowOutputSchema,
   CHECK_CREDENTIAL_APPLIES,
   CODEX_APP_SERVER_GENERATED_AGAINST,
   CODEX_APP_SERVER_TIMEOUT_MS,
@@ -16929,6 +17124,8 @@ export {
   ResetRowSchema,
   ResetScheduleSchema,
   SessionAgentTreeSchema,
+  SessionLookupError,
+  SessionSummarySchema,
   TaskItemSchema,
   USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema,
@@ -16976,6 +17173,8 @@ export {
   collectFrontDoorStatus,
   collectPoolPick,
   collectResets,
+  collectSessionList,
+  createAgentTreesApiRouter,
   createCodexApiRouter,
   createConfigApiRouter,
   createControlApiRouter,
@@ -17044,6 +17243,7 @@ export {
   listProviders,
   listSessions2 as listSessions,
   listUsageSnapshots,
+  locateSession,
   matchBranch,
   mintLeaf,
   mintRcSelfHostCredential,
@@ -17086,6 +17286,7 @@ export {
   realRcEventDial,
   realRcStreamDial,
   realRcWebFetch,
+  realSessionFs,
   reconnectRcSessionMcpServer,
   recoverFarm,
   recoveryDiagnostics,
@@ -17127,11 +17328,13 @@ export {
   setProfileMetadata,
   setRcSessionModel,
   setRcSessionPermissionMode,
+  showSession,
   snapshotPath,
   spawnClaude,
   startConnectServer,
   submitRcSessionMcpOAuthCallbackUrl,
   suggestRcSessionFiles,
+  summariseSession,
   teleportRcSession,
   topLevelNames,
   updateDirectoryRule,