claude-use 9.16.0 → 9.18.0

package/dist/index.cjs

@@ -2693,7 +2693,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>",
@@ -4817,22 +4817,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)
@@ -4854,11 +4857,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;
@@ -6687,7 +6692,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = import_node_path34.default.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = import_node_path35.default.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -6731,11 +6736,11 @@ function buildEnv(params) {
   }
   return env;
 }
-var import_node_path34, LOOPBACK_HOSTS;
+var import_node_path35, LOOPBACK_HOSTS;
 var init_flags = __esm({
   "src/launcher/flags.ts"() {
     "use strict";
-    import_node_path34 = __toESM(require("node:path"), 1);
+    import_node_path35 = __toESM(require("node:path"), 1);
     init_envBool();
     init_credential();
     init_headers();
@@ -6809,12 +6814,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);
@@ -7063,7 +7073,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path35.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path36.default.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.`
     );
@@ -7175,7 +7185,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 : import_node_path35.default.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : import_node_path36.default.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -7216,7 +7226,7 @@ function prepareLaunch(params) {
   );
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: import_node_path35.default.join(paths.root, "update.check"),
+    checkPath: import_node_path36.default.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
@@ -7347,12 +7357,12 @@ function runLaunchPlan(plan, spawn3) {
 function runLauncher(params) {
   params.proc.exit(runLaunchPlan(prepareLaunch(params), params.spawn));
 }
-var import_node_crypto10, import_node_path35;
+var import_node_crypto10, import_node_path36;
 var init_launcher = __esm({
   "src/launcher.ts"() {
     "use strict";
     import_node_crypto10 = require("node:crypto");
-    import_node_path35 = __toESM(require("node:path"), 1);
+    import_node_path36 = __toESM(require("node:path"), 1);
     init_package();
     init_envBool();
     init_argv();
@@ -7383,13 +7393,13 @@ function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string"
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return import_node_path36.default.join(distDir, OWN_CLI_FILE_NAME);
+  return import_node_path37.default.join(distDir, OWN_CLI_FILE_NAME);
 }
-var import_node_path36, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
+var import_node_path37, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
   "src/ownCli.ts"() {
     "use strict";
-    import_node_path36 = __toESM(require("node:path"), 1);
+    import_node_path37 = __toESM(require("node:path"), 1);
     init_cliError();
     OWN_CLI_FILE_NAME = "cli.cjs";
     OwnCliPathUnknownError = class extends CliError {
@@ -7474,7 +7484,7 @@ request.on("error", (error) => finish(failed, (error.code ? error.code + ": " :
 // src/frontdoor/trust.ts
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, variable, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || import_node_path37.default.resolve(inherited) === import_node_path37.default.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || import_node_path38.default.resolve(inherited) === import_node_path38.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7492,19 +7502,19 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path37.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = import_node_path38.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
   }
   return { path: bundle };
 }
-var import_node_crypto11, import_node_path37, BUNDLE_NAME_HEX_DIGITS;
+var import_node_crypto11, import_node_path38, BUNDLE_NAME_HEX_DIGITS;
 var init_trust = __esm({
   "src/frontdoor/trust.ts"() {
     "use strict";
     import_node_crypto11 = require("node:crypto");
-    import_node_path37 = __toESM(require("node:path"), 1);
+    import_node_path38 = __toESM(require("node:path"), 1);
     BUNDLE_NAME_HEX_DIGITS = 16;
   }
 });
@@ -7522,7 +7532,7 @@ function realEnsurePorts(paths, spawnDaemon) {
       process.kill(pid, "SIGTERM");
     },
     // Read fresh for each probe: a replacement supervisor may have regenerated an unparseable CA, and the probe must trust exactly what the serving door's leaf chains to.
-    verifyListener: (port) => probeFrontDoorSync(port, import_node_fs10.default.readFileSync(paths.frontdoorCaCertFile, "utf8"))
+    verifyListener: (port) => probeFrontDoorSync(port, import_node_fs11.default.readFileSync(paths.frontdoorCaCertFile, "utf8"))
   };
 }
 function realFrontDoorPort(paths, spawnDaemon) {
@@ -7543,21 +7553,21 @@ function realFrontDoorPort(paths, spawnDaemon) {
     }
   };
 }
-var import_node_fs10, realTrustBundleFs;
+var import_node_fs11, realTrustBundleFs;
 var init_realFrontDoorPort = __esm({
   "src/frontdoor/realFrontDoorPort.ts"() {
     "use strict";
-    import_node_fs10 = __toESM(require("node:fs"), 1);
+    import_node_fs11 = __toESM(require("node:fs"), 1);
     init_realPorts();
     init_ensure2();
     init_state();
     init_probe();
     init_trust();
     realTrustBundleFs = {
-      readFileUtf8: (file) => import_node_fs10.default.readFileSync(file, "utf8"),
-      exists: (file) => import_node_fs10.default.existsSync(file),
+      readFileUtf8: (file) => import_node_fs11.default.readFileSync(file, "utf8"),
+      exists: (file) => import_node_fs11.default.existsSync(file),
       mkdirp: (dir) => {
-        import_node_fs10.default.mkdirSync(dir, { recursive: true });
+        import_node_fs11.default.mkdirSync(dir, { recursive: true });
       },
       writeFileAtomic: (file, contents) => {
         realFarmFs.writeFilePrivate(file, contents);
@@ -7894,11 +7904,11 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-var import_zod27, 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 import_zod28, 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"() {
     "use strict";
-    import_zod27 = require("zod");
+    import_zod28 = require("zod");
     init_schema2();
     MS_PER_SECOND7 = 1e3;
     SECONDS_PER_HOUR = 3600;
@@ -7912,35 +7922,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 = import_zod27.z.object({
-      type: import_zod27.z.string(),
-      unit: import_zod27.z.number().int(),
-      number: import_zod27.z.number().int().positive(),
-      percentage: import_zod27.z.number().nonnegative(),
-      nextResetTime: import_zod27.z.number().positive().optional(),
-      usage: import_zod27.z.number().nonnegative().optional(),
-      currentValue: import_zod27.z.number().nonnegative().optional(),
-      remaining: import_zod27.z.number().nonnegative().optional()
+    ZaiLimitSchema = import_zod28.z.object({
+      type: import_zod28.z.string(),
+      unit: import_zod28.z.number().int(),
+      number: import_zod28.z.number().int().positive(),
+      percentage: import_zod28.z.number().nonnegative(),
+      nextResetTime: import_zod28.z.number().positive().optional(),
+      usage: import_zod28.z.number().nonnegative().optional(),
+      currentValue: import_zod28.z.number().nonnegative().optional(),
+      remaining: import_zod28.z.number().nonnegative().optional()
     });
-    ZaiResponseSchema = import_zod27.z.object({
-      success: import_zod27.z.boolean(),
-      msg: import_zod27.z.string().optional(),
-      data: import_zod27.z.object({ level: import_zod27.z.string().optional(), limits: import_zod27.z.array(ZaiLimitSchema) })
+    ZaiResponseSchema = import_zod28.z.object({
+      success: import_zod28.z.boolean(),
+      msg: import_zod28.z.string().optional(),
+      data: import_zod28.z.object({ level: import_zod28.z.string().optional(), limits: import_zod28.z.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 = import_zod27.z.object({
-      data: import_zod27.z.object({
-        limit: import_zod27.z.number().nonnegative().nullable(),
-        limit_remaining: import_zod27.z.number().nullable(),
-        limit_reset: import_zod27.z.string().nullable(),
-        is_free_tier: import_zod27.z.boolean().optional(),
-        free_model_daily_requests: import_zod27.z.object({ used: import_zod27.z.number().nonnegative(), limit: import_zod27.z.number().nonnegative(), remaining: import_zod27.z.number() }).optional()
+    OpenRouterKeySchema = import_zod28.z.object({
+      data: import_zod28.z.object({
+        limit: import_zod28.z.number().nonnegative().nullable(),
+        limit_remaining: import_zod28.z.number().nullable(),
+        limit_reset: import_zod28.z.string().nullable(),
+        is_free_tier: import_zod28.z.boolean().optional(),
+        free_model_daily_requests: import_zod28.z.object({ used: import_zod28.z.number().nonnegative(), limit: import_zod28.z.number().nonnegative(), remaining: import_zod28.z.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = import_zod27.z.object({ data: import_zod27.z.object({ total_credits: import_zod27.z.number().nonnegative(), total_usage: import_zod27.z.number().nonnegative() }) });
+    OpenRouterCreditsSchema = import_zod28.z.object({ data: import_zod28.z.object({ total_credits: import_zod28.z.number().nonnegative(), total_usage: import_zod28.z.number().nonnegative() }) });
   }
 });
 
@@ -8029,6 +8039,10 @@ __export(index_exports, {
   AgentKindSchema: () => AgentKindSchema,
   AgentMetaSchema: () => AgentMetaSchema,
   AgentNodeSchema: () => AgentNodeSchema,
+  AgentTreesListInputSchema: () => AgentTreesListInputSchema,
+  AgentTreesListOutputSchema: () => AgentTreesListOutputSchema,
+  AgentTreesShowInputSchema: () => AgentTreesShowInputSchema,
+  AgentTreesShowOutputSchema: () => AgentTreesShowOutputSchema,
   CHECK_CREDENTIAL_APPLIES: () => CHECK_CREDENTIAL_APPLIES,
   CODEX_APP_SERVER_GENERATED_AGAINST: () => CODEX_APP_SERVER_GENERATED_AGAINST,
   CODEX_APP_SERVER_TIMEOUT_MS: () => CODEX_APP_SERVER_TIMEOUT_MS,
@@ -8176,6 +8190,8 @@ __export(index_exports, {
   ResetRowSchema: () => ResetRowSchema,
   ResetScheduleSchema: () => ResetScheduleSchema,
   SessionAgentTreeSchema: () => SessionAgentTreeSchema,
+  SessionLookupError: () => SessionLookupError,
+  SessionSummarySchema: () => SessionSummarySchema,
   TaskItemSchema: () => TaskItemSchema,
   USAGE_EVENT_SOURCE: () => USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema: () => UpdateCheckOutputSchema,
@@ -8223,6 +8239,8 @@ __export(index_exports, {
   collectFrontDoorStatus: () => collectFrontDoorStatus,
   collectPoolPick: () => collectPoolPick,
   collectResets: () => collectResets,
+  collectSessionList: () => collectSessionList,
+  createAgentTreesApiRouter: () => createAgentTreesApiRouter,
   createCodexApiRouter: () => createCodexApiRouter,
   createConfigApiRouter: () => createConfigApiRouter,
   createControlApiRouter: () => createControlApiRouter,
@@ -8291,6 +8309,7 @@ __export(index_exports, {
   listProviders: () => listProviders,
   listSessions: () => listSessions2,
   listUsageSnapshots: () => listUsageSnapshots,
+  locateSession: () => locateSession,
   matchBranch: () => matchBranch,
   mintLeaf: () => mintLeaf,
   mintRcSelfHostCredential: () => mintRcSelfHostCredential,
@@ -8333,6 +8352,7 @@ __export(index_exports, {
   realRcEventDial: () => realRcEventDial,
   realRcStreamDial: () => realRcStreamDial,
   realRcWebFetch: () => realRcWebFetch,
+  realSessionFs: () => realSessionFs,
   reconnectRcSessionMcpServer: () => reconnectRcSessionMcpServer,
   recoverFarm: () => recoverFarm,
   recoveryDiagnostics: () => recoveryDiagnostics,
@@ -8374,11 +8394,13 @@ __export(index_exports, {
   setProfileMetadata: () => setProfileMetadata,
   setRcSessionModel: () => setRcSessionModel,
   setRcSessionPermissionMode: () => setRcSessionPermissionMode,
+  showSession: () => showSession,
   snapshotPath: () => snapshotPath,
   spawnClaude: () => spawnClaude,
   startConnectServer: () => startConnectServer,
   submitRcSessionMcpOAuthCallbackUrl: () => submitRcSessionMcpOAuthCallbackUrl,
   suggestRcSessionFiles: () => suggestRcSessionFiles,
+  summariseSession: () => summariseSession,
   teleportRcSession: () => teleportRcSession,
   topLevelNames: () => topLevelNames,
   updateDirectoryRule: () => updateDirectoryRule,
@@ -8918,8 +8940,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",
@@ -9454,11 +9476,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"),
@@ -9840,8 +9862,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 });
@@ -9943,15 +9965,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) {
@@ -10120,11 +10142,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 } }) };
       }
     },
     {
@@ -10434,9 +10456,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 });
     }
@@ -10508,10 +10530,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)}` };
     }
@@ -10542,10 +10564,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}`),
@@ -10704,12 +10726,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
@@ -10774,12 +10796,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,
@@ -10821,9 +10843,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 };
@@ -11290,6 +11312,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;
@@ -11704,8 +11727,8 @@ init_cliError();
 init_realPorts();
 
 // src/frontdoor/controlApi.ts
-var import_client6 = require("@orpc/client");
-var import_openapi7 = require("@orpc/openapi");
+var import_client7 = require("@orpc/client");
+var import_openapi8 = require("@orpc/openapi");
 
 // src/checkReport.ts
 var import_node_os5 = __toESM(require("node:os"), 1);
@@ -11974,19 +11997,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;
       }
@@ -14120,7 +14143,7 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path38, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path38, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path39, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path39, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
@@ -14562,6 +14585,166 @@ function createLaunchApiRouter(deps) {
   };
 }
 
+// src/frontdoor/agentTreesApi.ts
+var import_client6 = require("@orpc/client");
+var import_openapi7 = require("@orpc/openapi");
+var import_zod26 = require("zod");
+
+// src/agents/schema.ts
+var import_zod25 = require("zod");
+var AgentMetaSchema = import_zod25.z.looseObject({
+  agentType: import_zod25.z.string(),
+  isFork: import_zod25.z.boolean().optional(),
+  description: import_zod25.z.string().optional(),
+  name: import_zod25.z.string().optional(),
+  toolUseId: import_zod25.z.string().optional(),
+  spawnDepth: import_zod25.z.number().int().nonnegative().optional(),
+  parentAgentId: import_zod25.z.string().optional(),
+  model: import_zod25.z.string().optional(),
+  requestShape: import_zod25.z.string().optional(),
+  requestNonInteractive: import_zod25.z.boolean().optional(),
+  workflowPhase: import_zod25.z.string().optional(),
+  taskKind: import_zod25.z.string().optional(),
+  teamName: import_zod25.z.string().optional(),
+  worktreePath: import_zod25.z.string().optional(),
+  worktreeBranch: import_zod25.z.string().optional(),
+  stoppedByUser: import_zod25.z.boolean().optional()
+});
+var AgentKindSchema = import_zod25.z.enum(["subagent", "fork", "workflow-agent", "teammate"]);
+var AgentNodeSchema = import_zod25.z.lazy(
+  () => import_zod25.z.strictObject({
+    id: import_zod25.z.string(),
+    kind: AgentKindSchema,
+    agentType: import_zod25.z.string(),
+    description: import_zod25.z.string().optional(),
+    name: import_zod25.z.string().optional(),
+    toolUseId: import_zod25.z.string().optional(),
+    spawnDepth: import_zod25.z.number().int().nonnegative().optional(),
+    model: import_zod25.z.string().optional(),
+    background: import_zod25.z.boolean().optional(),
+    workflowRunId: import_zod25.z.string().optional(),
+    workflowPhase: import_zod25.z.string().optional(),
+    teamName: import_zod25.z.string().optional(),
+    stoppedByUser: import_zod25.z.boolean().optional(),
+    transcript: import_zod25.z.string(),
+    children: import_zod25.z.array(AgentNodeSchema)
+  })
+);
+var TaskItemSchema = import_zod25.z.strictObject({
+  id: import_zod25.z.string(),
+  subject: import_zod25.z.string(),
+  description: import_zod25.z.string().optional(),
+  status: import_zod25.z.string(),
+  /** What a spinner shows while the task runs. */
+  activeForm: import_zod25.z.string().optional(),
+  /** The teammate or agent name the task is assigned to, as Agent Teams writes it. */
+  owner: import_zod25.z.string().optional(),
+  /** Free-form data the harness attaches to a task, kept as written. */
+  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.unknown()).optional(),
+  blocks: import_zod25.z.array(import_zod25.z.string()),
+  blockedBy: import_zod25.z.array(import_zod25.z.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: import_zod25.z.string().optional()
+});
+var WorkflowRunSchema = import_zod25.z.strictObject({
+  runId: import_zod25.z.string(),
+  workflowName: import_zod25.z.string().optional(),
+  status: import_zod25.z.string().optional(),
+  startTime: import_zod25.z.number().optional(),
+  phases: import_zod25.z.array(import_zod25.z.string()),
+  summary: import_zod25.z.string().optional()
+});
+var AgentTreeProblemSchema = import_zod25.z.strictObject({
+  /** Relative to the identity's configuration directory. */
+  path: import_zod25.z.string(),
+  reason: import_zod25.z.string()
+});
+var SessionSummarySchema = import_zod25.z.strictObject({
+  project: import_zod25.z.string(),
+  sessionId: import_zod25.z.string(),
+  superseded: import_zod25.z.boolean(),
+  /** The directory and transcript stem exactly as on disk, which differs from `sessionId` for a superseded session. */
+  entry: import_zod25.z.string(),
+  agentCount: import_zod25.z.number().int().nonnegative(),
+  workflowRunCount: import_zod25.z.number().int().nonnegative(),
+  /** When the transcript was last written, as an ISO instant; absent when there is no transcript file. */
+  updatedAt: import_zod25.z.iso.datetime().optional(),
+  identities: import_zod25.z.array(import_zod25.z.string())
+});
+var SessionAgentTreeSchema = import_zod25.z.strictObject({
+  project: import_zod25.z.string(),
+  sessionId: import_zod25.z.string(),
+  /** True for a session directory a resume superseded (`<session-id>.superseded-<epoch-ms>`). */
+  superseded: import_zod25.z.boolean(),
+  /** The agents the session itself spawned, each with its descendants. */
+  agents: import_zod25.z.array(AgentNodeSchema),
+  tasks: import_zod25.z.array(TaskItemSchema),
+  workflowRuns: import_zod25.z.array(WorkflowRunSchema),
+  problems: import_zod25.z.array(AgentTreeProblemSchema)
+});
+
+// src/frontdoor/agentTreesApi.ts
+init_cliError();
+var AgentTreesListInputSchema = import_zod26.z.strictObject({
+  /** Only this identity's sessions. */
+  identity: import_zod26.z.string().optional(),
+  /** Include sessions that spawned no agent and ran no workflow. */
+  all: import_zod26.z.boolean().optional()
+});
+var AgentTreesListOutputSchema = import_zod26.z.array(SessionSummarySchema);
+var AgentTreesShowInputSchema = import_zod26.z.strictObject({
+  /** A session id, or an unambiguous prefix of one. */
+  session: import_zod26.z.string().min(1),
+  /** Look only in this identity. */
+  identity: import_zod26.z.string().optional()
+});
+var AgentTreesShowOutputSchema = import_zod26.z.strictObject({ identities: import_zod26.z.array(import_zod26.z.string()), ...SessionAgentTreeSchema.shape });
+function asBadRequest(error) {
+  if (error instanceof CliError) {
+    throw new import_client6.ORPCError("BAD_REQUEST", { message: error.message });
+  }
+  throw error;
+}
+function createAgentTreesApiRouter(deps) {
+  const authed = doorApiAuth(deps.expectedToken);
+  return {
+    agentTrees: {
+      list: authed.meta(
+        (0, import_openapi7.openapi)({
+          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(
+        (0, import_openapi7.openapi)({
+          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";
@@ -14572,12 +14755,12 @@ function createControlApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     usage: {
-      list: authed.meta((0, import_openapi7.openapi)({ 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((0, import_openapi7.openapi)({ 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((0, import_openapi7.openapi)({ 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((0, import_openapi8.openapi)({ 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((0, import_openapi8.openapi)({ 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((0, import_openapi8.openapi)({ 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 import_client6.ORPCError("NOT_FOUND", { message: `identity ${input.identity} has no usage snapshot yet, so no quota window has been observed for it` });
+          throw new import_client7.ORPCError("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;
@@ -14591,34 +14774,34 @@ function createControlApiRouter(deps) {
           ...unified?.sevenDay === void 0 ? {} : { sevenDay: effectiveWindow(unified.sevenDay, now) }
         };
       }),
-      live: authed.meta((0, import_openapi7.openapi)({ 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((0, import_openapi8.openapi)({ 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 import_client6.ORPCError("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 import_client7.ORPCError("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 import_client6.ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
+          throw new import_client7.ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
         }
         return { latest: deps.latestRateLimit(), sessions };
       })
     },
     frontdoor: {
-      status: authed.meta((0, import_openapi7.openapi)({ 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((0, import_openapi7.openapi)({ 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((0, import_openapi8.openapi)({ 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((0, import_openapi8.openapi)({ 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((0, import_openapi7.openapi)({ 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((0, import_openapi8.openapi)({ 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((0, import_openapi7.openapi)({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] })).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+      run: authed.meta((0, import_openapi8.openapi)({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] })).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
     },
     pool: {
-      pick: authed.meta((0, import_openapi7.openapi)({ 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((0, import_openapi8.openapi)({ 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 import_client6.ORPCError("NOT_FOUND", {
+          throw new import_client7.ORPCError("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(", ")}`
           });
         }
@@ -14630,13 +14813,13 @@ 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);
 }
 function frontDoorApiClient(port, ca, token) {
-  return (0, import_client6.createORPCClient)(frontDoorApiLink(port, ca, token));
+  return (0, import_client7.createORPCClient)(frontDoorApiLink(port, ca, token));
 }
 
 // src/frontdoor/doorClient.ts
@@ -16698,90 +16881,7 @@ init_poolPick();
 
 // src/agents/read.ts
 var import_node_path33 = __toESM(require("node:path"), 1);
-var import_zod26 = require("zod");
-
-// src/agents/schema.ts
-var import_zod25 = require("zod");
-var AgentMetaSchema = import_zod25.z.looseObject({
-  agentType: import_zod25.z.string(),
-  isFork: import_zod25.z.boolean().optional(),
-  description: import_zod25.z.string().optional(),
-  name: import_zod25.z.string().optional(),
-  toolUseId: import_zod25.z.string().optional(),
-  spawnDepth: import_zod25.z.number().int().nonnegative().optional(),
-  parentAgentId: import_zod25.z.string().optional(),
-  model: import_zod25.z.string().optional(),
-  requestShape: import_zod25.z.string().optional(),
-  requestNonInteractive: import_zod25.z.boolean().optional(),
-  workflowPhase: import_zod25.z.string().optional(),
-  taskKind: import_zod25.z.string().optional(),
-  teamName: import_zod25.z.string().optional(),
-  worktreePath: import_zod25.z.string().optional(),
-  worktreeBranch: import_zod25.z.string().optional(),
-  stoppedByUser: import_zod25.z.boolean().optional()
-});
-var AgentKindSchema = import_zod25.z.enum(["subagent", "fork", "workflow-agent", "teammate"]);
-var AgentNodeSchema = import_zod25.z.lazy(
-  () => import_zod25.z.strictObject({
-    id: import_zod25.z.string(),
-    kind: AgentKindSchema,
-    agentType: import_zod25.z.string(),
-    description: import_zod25.z.string().optional(),
-    name: import_zod25.z.string().optional(),
-    toolUseId: import_zod25.z.string().optional(),
-    spawnDepth: import_zod25.z.number().int().nonnegative().optional(),
-    model: import_zod25.z.string().optional(),
-    background: import_zod25.z.boolean().optional(),
-    workflowRunId: import_zod25.z.string().optional(),
-    workflowPhase: import_zod25.z.string().optional(),
-    teamName: import_zod25.z.string().optional(),
-    stoppedByUser: import_zod25.z.boolean().optional(),
-    transcript: import_zod25.z.string(),
-    children: import_zod25.z.array(AgentNodeSchema)
-  })
-);
-var TaskItemSchema = import_zod25.z.strictObject({
-  id: import_zod25.z.string(),
-  subject: import_zod25.z.string(),
-  description: import_zod25.z.string().optional(),
-  status: import_zod25.z.string(),
-  /** What a spinner shows while the task runs. */
-  activeForm: import_zod25.z.string().optional(),
-  /** The teammate or agent name the task is assigned to, as Agent Teams writes it. */
-  owner: import_zod25.z.string().optional(),
-  /** Free-form data the harness attaches to a task, kept as written. */
-  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.unknown()).optional(),
-  blocks: import_zod25.z.array(import_zod25.z.string()),
-  blockedBy: import_zod25.z.array(import_zod25.z.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: import_zod25.z.string().optional()
-});
-var WorkflowRunSchema = import_zod25.z.strictObject({
-  runId: import_zod25.z.string(),
-  workflowName: import_zod25.z.string().optional(),
-  status: import_zod25.z.string().optional(),
-  startTime: import_zod25.z.number().optional(),
-  phases: import_zod25.z.array(import_zod25.z.string()),
-  summary: import_zod25.z.string().optional()
-});
-var AgentTreeProblemSchema = import_zod25.z.strictObject({
-  /** Relative to the identity's configuration directory. */
-  path: import_zod25.z.string(),
-  reason: import_zod25.z.string()
-});
-var SessionAgentTreeSchema = import_zod25.z.strictObject({
-  project: import_zod25.z.string(),
-  sessionId: import_zod25.z.string(),
-  /** True for a session directory a resume superseded (`<session-id>.superseded-<epoch-ms>`). */
-  superseded: import_zod25.z.boolean(),
-  /** The agents the session itself spawned, each with its descendants. */
-  agents: import_zod25.z.array(AgentNodeSchema),
-  tasks: import_zod25.z.array(TaskItemSchema),
-  workflowRuns: import_zod25.z.array(WorkflowRunSchema),
-  problems: import_zod25.z.array(AgentTreeProblemSchema)
-});
-
-// src/agents/read.ts
+var import_zod27 = require("zod");
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
 var SUBAGENTS_DIR = "subagents";
@@ -16900,15 +17000,30 @@ function parseJson2(text) {
     return void 0;
   }
 }
-var TaskFileSchema = import_zod26.z.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: import_zod26.z.array(import_zod26.z.string()).default([]), blockedBy: import_zod26.z.array(import_zod26.z.string()).default([]) });
-var WorkflowRunFileSchema = import_zod26.z.object({
-  runId: import_zod26.z.string(),
-  workflowName: import_zod26.z.string().optional(),
-  status: import_zod26.z.string().optional(),
-  startTime: import_zod26.z.number().optional(),
-  phases: import_zod26.z.array(import_zod26.z.object({ title: import_zod26.z.string() })).default([]),
-  summary: import_zod26.z.string().optional()
+var TaskFileSchema = import_zod27.z.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: import_zod27.z.array(import_zod27.z.string()).default([]), blockedBy: import_zod27.z.array(import_zod27.z.string()).default([]) });
+var WorkflowRunFileSchema = import_zod27.z.object({
+  runId: import_zod27.z.string(),
+  workflowName: import_zod27.z.string().optional(),
+  status: import_zod27.z.string().optional(),
+  startTime: import_zod27.z.number().optional(),
+  phases: import_zod27.z.array(import_zod27.z.object({ title: import_zod27.z.string() })).default([]),
+  summary: import_zod27.z.string().optional()
 });
+function summariseSession(fs12, configDir, ref) {
+  const sessionRelative = import_node_path33.default.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = import_node_path33.default.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = import_node_path33.default.join(subagentsRelative, WORKFLOWS_DIR);
+  const isMeta = (name) => name.startsWith(AGENT_FILE_PREFIX) && name.endsWith(META_SUFFIX);
+  let agentCount = fs12.readdir(import_node_path33.default.join(configDir, subagentsRelative)).filter(isMeta).length;
+  for (const runDir of fs12.readdir(import_node_path33.default.join(configDir, workflowsUnderSubagents))) {
+    if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
+      agentCount += fs12.readdir(import_node_path33.default.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
+    }
+  }
+  const workflowRunCount = fs12.readdir(import_node_path33.default.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
+  const transcript = fs12.lstat(import_node_path33.default.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) => {
@@ -17064,6 +17179,94 @@ function readWorkflowRuns(fs12, configDir, relativeDir, report) {
   return runs;
 }
 
+// src/agents/sessions.ts
+var import_node_path34 = __toESM(require("node:path"), 1);
+init_cliError();
+var SessionLookupError = class extends CliError {
+  constructor(message) {
+    super(message);
+    this.name = "SessionLookupError";
+  }
+};
+function identityConfigDir(identitiesDir, identity) {
+  return import_node_path34.default.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(import_node_path34.default.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
+var import_node_fs10 = __toESM(require("node:fs"), 1);
+init_realPorts();
+var realSessionFs = {
+  ...realFarmFs,
+  realpath: (candidate) => {
+    try {
+      return import_node_fs10.default.realpathSync(candidate);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
 // src/index.ts
 init_conditions();
 init_ensure();
@@ -17176,6 +17379,10 @@ init_ownCli();
   AgentKindSchema,
   AgentMetaSchema,
   AgentNodeSchema,
+  AgentTreesListInputSchema,
+  AgentTreesListOutputSchema,
+  AgentTreesShowInputSchema,
+  AgentTreesShowOutputSchema,
   CHECK_CREDENTIAL_APPLIES,
   CODEX_APP_SERVER_GENERATED_AGAINST,
   CODEX_APP_SERVER_TIMEOUT_MS,
@@ -17323,6 +17530,8 @@ init_ownCli();
   ResetRowSchema,
   ResetScheduleSchema,
   SessionAgentTreeSchema,
+  SessionLookupError,
+  SessionSummarySchema,
   TaskItemSchema,
   USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema,
@@ -17370,6 +17579,8 @@ init_ownCli();
   collectFrontDoorStatus,
   collectPoolPick,
   collectResets,
+  collectSessionList,
+  createAgentTreesApiRouter,
   createCodexApiRouter,
   createConfigApiRouter,
   createControlApiRouter,
@@ -17438,6 +17649,7 @@ init_ownCli();
   listProviders,
   listSessions,
   listUsageSnapshots,
+  locateSession,
   matchBranch,
   mintLeaf,
   mintRcSelfHostCredential,
@@ -17480,6 +17692,7 @@ init_ownCli();
   realRcEventDial,
   realRcStreamDial,
   realRcWebFetch,
+  realSessionFs,
   reconnectRcSessionMcpServer,
   recoverFarm,
   recoveryDiagnostics,
@@ -17521,11 +17734,13 @@ init_ownCli();
   setProfileMetadata,
   setRcSessionModel,
   setRcSessionPermissionMode,
+  showSession,
   snapshotPath,
   spawnClaude,
   startConnectServer,
   submitRcSessionMcpOAuthCallbackUrl,
   suggestRcSessionFiles,
+  summariseSession,
   teleportRcSession,
   topLevelNames,
   updateDirectoryRule,