claude-use 9.15.0 → 9.16.0

package/dist/index.cjs

@@ -2693,7 +2693,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.15.0",
+      version: "9.16.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>",
@@ -6687,7 +6687,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_path33.default.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = import_node_path34.default.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -6731,11 +6731,11 @@ function buildEnv(params) {
   }
   return env;
 }
-var import_node_path33, LOOPBACK_HOSTS;
+var import_node_path34, LOOPBACK_HOSTS;
 var init_flags = __esm({
   "src/launcher/flags.ts"() {
     "use strict";
-    import_node_path33 = __toESM(require("node:path"), 1);
+    import_node_path34 = __toESM(require("node:path"), 1);
     init_envBool();
     init_credential();
     init_headers();
@@ -7063,7 +7063,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path34.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path35.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 +7175,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_path34.default.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : import_node_path35.default.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -7216,7 +7216,7 @@ function prepareLaunch(params) {
   );
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: import_node_path34.default.join(paths.root, "update.check"),
+    checkPath: import_node_path35.default.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
@@ -7347,12 +7347,12 @@ function runLaunchPlan(plan, spawn3) {
 function runLauncher(params) {
   params.proc.exit(runLaunchPlan(prepareLaunch(params), params.spawn));
 }
-var import_node_crypto10, import_node_path34;
+var import_node_crypto10, import_node_path35;
 var init_launcher = __esm({
   "src/launcher.ts"() {
     "use strict";
     import_node_crypto10 = require("node:crypto");
-    import_node_path34 = __toESM(require("node:path"), 1);
+    import_node_path35 = __toESM(require("node:path"), 1);
     init_package();
     init_envBool();
     init_argv();
@@ -7383,13 +7383,13 @@ function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string"
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return import_node_path35.default.join(distDir, OWN_CLI_FILE_NAME);
+  return import_node_path36.default.join(distDir, OWN_CLI_FILE_NAME);
 }
-var import_node_path35, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
+var import_node_path36, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
   "src/ownCli.ts"() {
     "use strict";
-    import_node_path35 = __toESM(require("node:path"), 1);
+    import_node_path36 = __toESM(require("node:path"), 1);
     init_cliError();
     OWN_CLI_FILE_NAME = "cli.cjs";
     OwnCliPathUnknownError = class extends CliError {
@@ -7474,7 +7474,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_path36.default.resolve(inherited) === import_node_path36.default.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || import_node_path37.default.resolve(inherited) === import_node_path37.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7492,19 +7492,19 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path36.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  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`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
   }
   return { path: bundle };
 }
-var import_node_crypto11, import_node_path36, BUNDLE_NAME_HEX_DIGITS;
+var import_node_crypto11, import_node_path37, BUNDLE_NAME_HEX_DIGITS;
 var init_trust = __esm({
   "src/frontdoor/trust.ts"() {
     "use strict";
     import_node_crypto11 = require("node:crypto");
-    import_node_path36 = __toESM(require("node:path"), 1);
+    import_node_path37 = __toESM(require("node:path"), 1);
     BUNDLE_NAME_HEX_DIGITS = 16;
   }
 });
@@ -7894,11 +7894,11 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-var import_zod25, 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_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 init_providerQuota = __esm({
   "src/usage/providerQuota.ts"() {
     "use strict";
-    import_zod25 = require("zod");
+    import_zod27 = require("zod");
     init_schema2();
     MS_PER_SECOND7 = 1e3;
     SECONDS_PER_HOUR = 3600;
@@ -7912,35 +7912,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_zod25.z.object({
-      type: import_zod25.z.string(),
-      unit: import_zod25.z.number().int(),
-      number: import_zod25.z.number().int().positive(),
-      percentage: import_zod25.z.number().nonnegative(),
-      nextResetTime: import_zod25.z.number().positive().optional(),
-      usage: import_zod25.z.number().nonnegative().optional(),
-      currentValue: import_zod25.z.number().nonnegative().optional(),
-      remaining: import_zod25.z.number().nonnegative().optional()
+    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()
     });
-    ZaiResponseSchema = import_zod25.z.object({
-      success: import_zod25.z.boolean(),
-      msg: import_zod25.z.string().optional(),
-      data: import_zod25.z.object({ level: import_zod25.z.string().optional(), limits: import_zod25.z.array(ZaiLimitSchema) })
+    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) })
     });
     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_zod25.z.object({
-      data: import_zod25.z.object({
-        limit: import_zod25.z.number().nonnegative().nullable(),
-        limit_remaining: import_zod25.z.number().nullable(),
-        limit_reset: import_zod25.z.string().nullable(),
-        is_free_tier: import_zod25.z.boolean().optional(),
-        free_model_daily_requests: import_zod25.z.object({ used: import_zod25.z.number().nonnegative(), limit: import_zod25.z.number().nonnegative(), remaining: import_zod25.z.number() }).optional()
+    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()
       })
     });
-    OpenRouterCreditsSchema = import_zod25.z.object({ data: import_zod25.z.object({ total_credits: import_zod25.z.number().nonnegative(), total_usage: import_zod25.z.number().nonnegative() }) });
+    OpenRouterCreditsSchema = import_zod27.z.object({ data: import_zod27.z.object({ total_credits: import_zod27.z.number().nonnegative(), total_usage: import_zod27.z.number().nonnegative() }) });
   }
 });
 
@@ -8026,6 +8026,9 @@ var init_realAnthropicUsageProbe = __esm({
 var index_exports = {};
 __export(index_exports, {
   AMBIENT_CREDENTIAL_VARS: () => AMBIENT_CREDENTIAL_VARS,
+  AgentKindSchema: () => AgentKindSchema,
+  AgentMetaSchema: () => AgentMetaSchema,
+  AgentNodeSchema: () => AgentNodeSchema,
   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,
@@ -8172,6 +8175,8 @@ __export(index_exports, {
   RcStreamEventSchema: () => RcStreamEventSchema,
   ResetRowSchema: () => ResetRowSchema,
   ResetScheduleSchema: () => ResetScheduleSchema,
+  SessionAgentTreeSchema: () => SessionAgentTreeSchema,
+  TaskItemSchema: () => TaskItemSchema,
   USAGE_EVENT_SOURCE: () => USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema: () => UpdateCheckOutputSchema,
   UsageError: () => UsageError,
@@ -8182,6 +8187,7 @@ __export(index_exports, {
   UsageWindowsInputSchema: () => UsageWindowsInputSchema,
   UsageWindowsOutputSchema: () => UsageWindowsOutputSchema,
   WhenSchema: () => WhenSchema,
+  WorkflowRunSchema: () => WorkflowRunSchema,
   addDirectoryRule: () => addDirectoryRule,
   addIdentity: () => addIdentity,
   addPool: () => addPool,
@@ -8283,6 +8289,7 @@ __export(index_exports, {
   listIdentities: () => listIdentities,
   listProfiles: () => listProfiles,
   listProviders: () => listProviders,
+  listSessions: () => listSessions2,
   listUsageSnapshots: () => listUsageSnapshots,
   matchBranch: () => matchBranch,
   mintLeaf: () => mintLeaf,
@@ -8317,6 +8324,7 @@ __export(index_exports, {
   readProvider: () => readProvider,
   readRcSelfHostRecord: () => readRcSelfHostRecord,
   readRcSessionFile: () => readRcSessionFile,
+  readSessionAgentTree: () => readSessionAgentTree,
   readUsageSnapshot: () => readUsageSnapshot,
   realCodexAppServerPort: () => realCodexAppServerPort,
   realConnectCertStore: () => realConnectCertStore,
@@ -8910,8 +8918,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path37) {
-  return path37?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path38) {
+  return path38?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -9446,11 +9454,11 @@ function createRcSessionTracker(deps) {
   };
   const observeExchange = (request4) => {
     const method = (request4.method ?? "").toUpperCase();
-    const path37 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
-    if (!path37.startsWith(RC_SESSIONS_PATH_PREFIX)) {
+    const path38 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
+    if (!path38.startsWith(RC_SESSIONS_PATH_PREFIX)) {
       return void 0;
     }
-    const tail = path37.slice(RC_SESSIONS_PATH_PREFIX.length);
+    const tail = path38.slice(RC_SESSIONS_PATH_PREFIX.length);
     const facts = {
       oauthAuthorization: oauthAuthorizationOf(request4.headers),
       anthropicVersion: singleHeader(request4.headers, "anthropic-version"),
@@ -9832,8 +9840,8 @@ var RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
 function isRcReadFileEncoding(value) {
   return RC_READ_FILE_ENCODINGS.some((encoding) => encoding === value);
 }
-function buildRcReadFilePayload(requestId, path37, options) {
-  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path37, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
+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 buildRcFileSuggestionsPayload(requestId, query) {
   return buildRcControlRequestPayload(requestId, { subtype: "file_suggestions", query });
@@ -9935,15 +9943,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, path37, options) {
-  if (path37 === "") {
+async function readRcSessionFile(deps, sessionId, path38, options) {
+  if (path38 === "") {
     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, path37, options), `read ${path37} from session ${sessionId}`);
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path38, options), `read ${path38} from session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
 async function suggestRcSessionFiles(deps, sessionId, query) {
@@ -10112,11 +10120,11 @@ function createRcControlHandler(deps) {
       path: "read-file",
       read: (body) => {
         const session = bodyString(body, "session");
-        const path37 = bodyString(body, "path");
+        const path38 = 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 || path37 === 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, path37, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
+        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 } }) };
       }
     },
     {
@@ -10426,9 +10434,9 @@ function requestIdOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
-  const listAnswerOf = async (path37, what) => {
+  const listAnswerOf = async (path38, what) => {
     try {
-      return await transport.request({ method: "GET", path: path37, headers });
+      return await transport.request({ method: "GET", path: path38, 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 });
     }
@@ -10500,10 +10508,10 @@ function frontDoorRcControl(transport, token) {
     }
     return pending;
   };
-  const writeOf = async (path37, body, describeFailure) => {
+  const writeOf = async (path38, body, describeFailure2) => {
     let answer;
     try {
-      answer = await transport.request({ method: "POST", path: path37, headers: { ...headers, "content-type": "application/json" }, body });
+      answer = await transport.request({ method: "POST", path: path38, 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)}` };
     }
@@ -10515,7 +10523,7 @@ function frontDoorRcControl(transport, token) {
       const requestId = requestIdOfBody(answer.body);
       return requestId === void 0 ? { ok: true, sequenceNums } : { ok: true, sequenceNums, requestId };
     }
-    return { ok: false, message: describeFailure(answer.status, controlErrorOf(answer.body) ?? answer.body) };
+    return { ok: false, message: describeFailure2(answer.status, controlErrorOf(answer.body) ?? answer.body) };
   };
   const sessionQuery = (sessionId) => sessionId === void 0 ? "" : `?session=${encodeURIComponent(sessionId)}`;
   return {
@@ -10534,10 +10542,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, path37, options) => await writeOf(
+    readFile: async (sessionId, path38, options) => await writeOf(
       `${CONTROL_PATH_PREFIX}/read-file`,
-      JSON.stringify({ session: sessionId, path: path37, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
-      (status, message) => `reading ${path37} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
+      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}`
     ),
     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}`),
@@ -10696,12 +10704,12 @@ function tlsFacts(options) {
 }
 function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const post = async (path37, headers, body) => await new Promise((resolve, reject) => {
+  const post = async (path38, headers, body) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method: "POST",
-      path: path37,
+      path: path38,
       // 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
@@ -10766,12 +10774,12 @@ function lateRcStreamDial(resolve) {
 }
 function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const request4 = async (method, path37, headers, body, signal) => await new Promise((resolve, reject) => {
+  const request4 = async (method, path38, headers, body, signal) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method,
-      path: path37,
+      path: path38,
       // 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,
@@ -10813,9 +10821,9 @@ function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_P
       return { status, body: await readAll(response) };
     },
     openStream: async (sessionId, headers, resume, signal) => {
-      const path37 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
+      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 streamHeaders = resume === void 0 ? headers : { ...headers, "last-event-id": String(resume.fromSequenceNum) };
-      const { status, response } = await request4("GET", path37, streamHeaders, void 0, signal);
+      const { status, response } = await request4("GET", path38, streamHeaders, void 0, signal);
       if (!isSuccessful2(status)) {
         await readAll(response);
         return { status, chunks: NO_CHUNKS };
@@ -11966,19 +11974,19 @@ function writePools(paths, pools) {
   applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
 }
 function poolCycleOf(pools, name) {
-  const walk = (current, path37) => {
+  const walk = (current, path38) => {
     for (const entry of pools[current]?.identities ?? []) {
       const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
         continue;
       }
       if (nested === name) {
-        return [...path37, nested];
+        return [...path38, nested];
       }
-      if (path37.includes(nested)) {
+      if (path38.includes(nested)) {
         continue;
       }
-      const found = walk(nested, [...path37, nested]);
+      const found = walk(nested, [...path38, nested]);
       if (found !== void 0) {
         return found;
       }
@@ -14112,7 +14120,7 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path37, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path37, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path38, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path38, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
@@ -16687,6 +16695,376 @@ init_preflight();
 init_pick();
 init_plan2();
 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 PROJECTS_DIR = "projects";
+var TASKS_DIR = "tasks";
+var SUBAGENTS_DIR = "subagents";
+var WORKFLOWS_DIR = "workflows";
+var AGENT_FILE_PREFIX = "agent-";
+var META_SUFFIX = ".meta.json";
+var TRANSCRIPT_SUFFIX = ".jsonl";
+var SHORT_SESSION_ID_LENGTH = 8;
+var SHORT_SESSION_LIST_PREFIX = "session-";
+var JSON_SUFFIX = ".json";
+var WORKFLOW_RUN_PREFIX = "wf_";
+var ARCHIVED_RE = /^(.+)\.(?:superseded|orphaned)-.+$/;
+var FORK_AGENT_TYPE = "fork";
+var WORKFLOW_AGENT_TYPE = "workflow-subagent";
+var TEAMMATE_TASK_KIND = "in_process_teammate";
+var BACKGROUND_REQUEST_SHAPE = "background";
+var SESSION_SPAWN_DEPTH = 1;
+function parseEntry2(project, entry) {
+  const match = ARCHIVED_RE.exec(entry);
+  const base = match?.[1];
+  return base === void 0 ? { project, sessionId: entry, superseded: false, entry } : { project, sessionId: base, superseded: true, entry };
+}
+function listSessions2(fs12, configDir) {
+  const found = [];
+  for (const project of fs12.readdir(import_node_path33.default.join(configDir, PROJECTS_DIR))) {
+    const projectDir = import_node_path33.default.join(configDir, PROJECTS_DIR, project);
+    const entries = /* @__PURE__ */ new Set();
+    for (const name of fs12.readdir(projectDir)) {
+      if (name.endsWith(TRANSCRIPT_SUFFIX)) {
+        entries.add(name.slice(0, -TRANSCRIPT_SUFFIX.length));
+        continue;
+      }
+      const children = fs12.readdir(import_node_path33.default.join(projectDir, name));
+      if (children.includes(SUBAGENTS_DIR) || children.includes(WORKFLOWS_DIR)) {
+        entries.add(name);
+      }
+    }
+    for (const entry of entries) {
+      found.push(parseEntry2(project, entry));
+    }
+  }
+  return found.sort((left, right) => left.project.localeCompare(right.project) || left.entry.localeCompare(right.entry));
+}
+function locateAgents(fs12, configDir, relativeDir, workflowRunId, report) {
+  const located = [];
+  for (const name of listDirOrReport(fs12, configDir, relativeDir, report)) {
+    if (!name.startsWith(AGENT_FILE_PREFIX) || !name.endsWith(META_SUFFIX)) {
+      continue;
+    }
+    const id = name.slice(AGENT_FILE_PREFIX.length, -META_SUFFIX.length);
+    located.push({
+      id,
+      metaPath: import_node_path33.default.join(relativeDir, name),
+      transcriptPath: import_node_path33.default.join(relativeDir, `${AGENT_FILE_PREFIX}${id}${TRANSCRIPT_SUFFIX}`),
+      workflowRunId
+    });
+  }
+  return located;
+}
+function kindOf(meta, workflowRunId) {
+  if (meta.isFork === true || meta.agentType === FORK_AGENT_TYPE) {
+    return "fork";
+  }
+  if (workflowRunId !== void 0 || meta.agentType === WORKFLOW_AGENT_TYPE) {
+    return "workflow-agent";
+  }
+  if (meta.taskKind === TEAMMATE_TASK_KIND || meta.teamName !== void 0) {
+    return "teammate";
+  }
+  return "subagent";
+}
+function toNode(read, children) {
+  const { located, meta } = read;
+  return {
+    id: located.id,
+    kind: kindOf(meta, located.workflowRunId),
+    agentType: meta.agentType,
+    ...meta.description === void 0 ? {} : { description: meta.description },
+    ...meta.name === void 0 ? {} : { name: meta.name },
+    ...meta.toolUseId === void 0 ? {} : { toolUseId: meta.toolUseId },
+    ...meta.spawnDepth === void 0 ? {} : { spawnDepth: meta.spawnDepth },
+    ...meta.model === void 0 ? {} : { model: meta.model },
+    ...meta.requestShape === void 0 ? {} : { background: meta.requestShape === BACKGROUND_REQUEST_SHAPE },
+    ...located.workflowRunId === void 0 ? {} : { workflowRunId: located.workflowRunId },
+    ...meta.workflowPhase === void 0 ? {} : { workflowPhase: meta.workflowPhase },
+    ...meta.teamName === void 0 ? {} : { teamName: meta.teamName },
+    ...meta.stoppedByUser === void 0 ? {} : { stoppedByUser: meta.stoppedByUser },
+    transcript: located.transcriptPath,
+    children
+  };
+}
+function describeFailure(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function readFileOrReport(fs12, configDir, relative, report) {
+  try {
+    return fs12.readFileUtf8(import_node_path33.default.join(configDir, relative));
+  } catch (error) {
+    report({ path: relative, reason: `could not be read: ${describeFailure(error)}` });
+    return void 0;
+  }
+}
+function listDirOrReport(fs12, configDir, relative, report) {
+  try {
+    return fs12.readdir(import_node_path33.default.join(configDir, relative));
+  } catch (error) {
+    report({ path: relative, reason: `could not be listed: ${describeFailure(error)}` });
+    return [];
+  }
+}
+function parseJson2(text) {
+  try {
+    const value = JSON.parse(text);
+    return value;
+  } catch {
+    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()
+});
+function readSessionAgentTree(fs12, configDir, ref, options = {}) {
+  const problems = [];
+  const report = (problem) => {
+    problems.push(problem);
+  };
+  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 located = locateAgents(fs12, configDir, subagentsRelative, void 0, report);
+  for (const runDir of listDirOrReport(fs12, configDir, workflowsUnderSubagents, report)) {
+    if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
+      located.push(...locateAgents(fs12, configDir, import_node_path33.default.join(workflowsUnderSubagents, runDir), runDir, report));
+    }
+  }
+  const agents = /* @__PURE__ */ new Map();
+  for (const candidate of located) {
+    const text = readFileOrReport(fs12, configDir, candidate.metaPath, report);
+    if (text === void 0) {
+      continue;
+    }
+    const parsed = AgentMetaSchema.safeParse(parseJson2(text));
+    if (!parsed.success) {
+      report({ path: candidate.metaPath, reason: "meta file is not a JSON object with an agentType" });
+      continue;
+    }
+    agents.set(candidate.id, { located: candidate, meta: parsed.data });
+  }
+  const teamNames = [...new Set([...agents.values()].flatMap((agent) => agent.meta.teamName === void 0 ? [] : [agent.meta.teamName]))].sort();
+  const parentOf3 = resolveParents(fs12, configDir, agents, report);
+  const childrenOf = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const id of agents.keys()) {
+    const parent = parentOf3.get(id);
+    if (parent === void 0) {
+      roots.push(id);
+    } else {
+      childrenOf.set(parent, [...childrenOf.get(parent) ?? [], id]);
+    }
+  }
+  const build = (id) => {
+    const read = agents.get(id);
+    if (read === void 0) {
+      throw new Error(`agent ${id} is in the tree but was never read`);
+    }
+    return toNode(read, (childrenOf.get(id) ?? []).sort().map(build));
+  };
+  return {
+    project: ref.project,
+    sessionId: ref.sessionId,
+    superseded: ref.superseded,
+    agents: roots.sort().map(build),
+    tasks: readTasks(fs12, configDir, ownTaskLists(ref.sessionId), [.../* @__PURE__ */ new Set([...teamNames, ...options.taskListIds ?? []])].filter((id) => !ownTaskLists(ref.sessionId).includes(id)), report),
+    workflowRuns: readWorkflowRuns(fs12, configDir, import_node_path33.default.join(sessionRelative, WORKFLOWS_DIR), report),
+    problems
+  };
+}
+function resolveParents(fs12, configDir, agents, report) {
+  const parentOf3 = /* @__PURE__ */ new Map();
+  const transcriptCache = /* @__PURE__ */ new Map();
+  const transcriptOf = (agent) => {
+    const cached = transcriptCache.get(agent.located.id);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const text = readFileOrReport(fs12, configDir, agent.located.transcriptPath, report) ?? "";
+    transcriptCache.set(agent.located.id, text);
+    return text;
+  };
+  const wouldCycle = (child, parent) => {
+    for (let cursor = parent; cursor !== void 0; cursor = parentOf3.get(cursor)) {
+      if (cursor === child) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const attach = (child, parent) => {
+    if (wouldCycle(child.located.id, parent)) {
+      report({ path: child.located.metaPath, reason: `parent ${parent} would make a cycle` });
+      return;
+    }
+    parentOf3.set(child.located.id, parent);
+  };
+  for (const agent of agents.values()) {
+    const { meta, located } = agent;
+    if (meta.parentAgentId !== void 0 && agents.has(meta.parentAgentId)) {
+      attach(agent, meta.parentAgentId);
+      continue;
+    }
+    const depth = meta.spawnDepth;
+    if (depth !== void 0 && depth <= SESSION_SPAWN_DEPTH || meta.toolUseId === void 0) {
+      if (meta.parentAgentId !== void 0) {
+        report({ path: located.metaPath, reason: `parentAgentId ${meta.parentAgentId} names no agent in this session` });
+      }
+      continue;
+    }
+    const toolUseId = meta.toolUseId;
+    const owners = [...agents.values()].filter(
+      (candidate) => candidate.located.id !== located.id && (depth === void 0 || candidate.meta.spawnDepth === void 0 || candidate.meta.spawnDepth === depth - 1) && candidate.located.workflowRunId === located.workflowRunId && transcriptOf(candidate).includes(toolUseId)
+    );
+    const owner = owners[0];
+    if (owners.length === 1 && owner !== void 0) {
+      attach(agent, owner.located.id);
+    } else if (owners.length > 1) {
+      report({ path: located.metaPath, reason: "more than one agent transcript records the call that spawned it" });
+    } else if (depth !== void 0) {
+      report({ path: located.metaPath, reason: "no agent transcript records the call that spawned it" });
+    }
+  }
+  return parentOf3;
+}
+function ownTaskLists(sessionId) {
+  return [sessionId, `${SHORT_SESSION_LIST_PREFIX}${sessionId.slice(0, SHORT_SESSION_ID_LENGTH)}`];
+}
+function readTasks(fs12, configDir, ownLists, sharedLists, report) {
+  const tasks = [];
+  [...ownLists, ...sharedLists].forEach((scope, index) => {
+    const relativeDir = import_node_path33.default.join(TASKS_DIR, scope);
+    for (const name of [...listDirOrReport(fs12, configDir, relativeDir, report)].sort()) {
+      if (name.startsWith(".") || !name.endsWith(JSON_SUFFIX)) {
+        continue;
+      }
+      const relative = import_node_path33.default.join(relativeDir, name);
+      const text = readFileOrReport(fs12, configDir, relative, report);
+      const parsed = TaskFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
+      if (parsed.success) {
+        tasks.push(index < ownLists.length ? parsed.data : { ...parsed.data, taskList: scope });
+      } else if (text !== void 0) {
+        report({ path: relative, reason: "task file is not a task" });
+      }
+    }
+  });
+  return tasks;
+}
+function readWorkflowRuns(fs12, configDir, relativeDir, report) {
+  const runs = [];
+  for (const name of [...listDirOrReport(fs12, configDir, relativeDir, report)].sort()) {
+    if (!name.startsWith(WORKFLOW_RUN_PREFIX) || !name.endsWith(JSON_SUFFIX)) {
+      continue;
+    }
+    const relative = import_node_path33.default.join(relativeDir, name);
+    const text = readFileOrReport(fs12, configDir, relative, report);
+    const parsed = WorkflowRunFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
+    if (!parsed.success) {
+      if (text !== void 0) {
+        report({ path: relative, reason: "workflow run file is not a run record" });
+      }
+      continue;
+    }
+    const { phases, ...rest } = parsed.data;
+    runs.push({ ...rest, phases: phases.map((phase) => phase.title) });
+  }
+  return runs;
+}
+
+// src/index.ts
 init_conditions();
 init_ensure();
 init_supervisor();
@@ -16795,6 +17173,9 @@ init_ownCli();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AMBIENT_CREDENTIAL_VARS,
+  AgentKindSchema,
+  AgentMetaSchema,
+  AgentNodeSchema,
   CHECK_CREDENTIAL_APPLIES,
   CODEX_APP_SERVER_GENERATED_AGAINST,
   CODEX_APP_SERVER_TIMEOUT_MS,
@@ -16941,6 +17322,8 @@ init_ownCli();
   RcStreamEventSchema,
   ResetRowSchema,
   ResetScheduleSchema,
+  SessionAgentTreeSchema,
+  TaskItemSchema,
   USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema,
   UsageError,
@@ -16951,6 +17334,7 @@ init_ownCli();
   UsageWindowsInputSchema,
   UsageWindowsOutputSchema,
   WhenSchema,
+  WorkflowRunSchema,
   addDirectoryRule,
   addIdentity,
   addPool,
@@ -17052,6 +17436,7 @@ init_ownCli();
   listIdentities,
   listProfiles,
   listProviders,
+  listSessions,
   listUsageSnapshots,
   matchBranch,
   mintLeaf,
@@ -17086,6 +17471,7 @@ init_ownCli();
   readProvider,
   readRcSelfHostRecord,
   readRcSessionFile,
+  readSessionAgentTree,
   readUsageSnapshot,
   realCodexAppServerPort,
   realConnectCertStore,