claude-use 9.15.0 → 9.16.0

package/dist/index.mjs

@@ -2669,7 +2669,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>",
@@ -6630,7 +6630,7 @@ var init_headers = __esm({
 });
 
 // src/launcher/flags.ts
-import path33 from "node:path";
+import path34 from "node:path";
 function resolveLaunchFlags(params) {
   return {
     skipPermissions: params.flags?.skipPermissions ?? parseEnvBool("AGENT_SHIM_SKIP_PERMISSIONS", params.env.AGENT_SHIM_SKIP_PERMISSIONS) ?? params.cascade?.skipPermissions ?? false,
@@ -6661,7 +6661,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = path33.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = path34.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -6928,7 +6928,7 @@ var init_launchHook = __esm({
 
 // src/launcher.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import path34 from "node:path";
+import path35 from "node:path";
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
     return { ok: false, status: 1, message: `agent-shim: identity ${identity} needs its credential resolved, but this launcher has no credential port wired` };
@@ -7038,7 +7038,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path34.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path35.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -7150,7 +7150,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 : path34.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : path35.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -7191,7 +7191,7 @@ function prepareLaunch(params) {
   );
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: path34.join(paths.root, "update.check"),
+    checkPath: path35.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
@@ -7351,12 +7351,12 @@ var init_launcher = __esm({
 });
 
 // src/ownCli.ts
-import path35 from "node:path";
+import path36 from "node:path";
 function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string" ? __AGENT_SHIM_DIST_DIR__ : void 0) {
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return path35.join(distDir, OWN_CLI_FILE_NAME);
+  return path36.join(distDir, OWN_CLI_FILE_NAME);
 }
 var OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
@@ -7445,10 +7445,10 @@ request.on("error", (error) => finish(failed, (error.code ? error.code + ": " :
 
 // src/frontdoor/trust.ts
 import { createHash as createHash6 } from "node:crypto";
-import path36 from "node:path";
+import path37 from "node:path";
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, variable, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || path36.resolve(inherited) === path36.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || path37.resolve(inherited) === path37.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7466,7 +7466,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = path36.join(bundlesDir, `${createHash6("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = path37.join(bundlesDir, `${createHash6("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
@@ -7866,7 +7866,7 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 var MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY4, DAYS_PER_MONTH, ZAI_HOST, ZAI_QUOTA_URL, ZAI_UNIT_HOURS, ZAI_UNIT_MONTHS, ZAI_UNIT_MS, ZaiLimitSchema, ZaiResponseSchema, OPENROUTER_HOST, OPENROUTER_KEY_URL, OPENROUTER_CREDITS_URL, MS_PER_DAY3, OpenRouterKeySchema, OpenRouterCreditsSchema;
 var init_providerQuota = __esm({
   "src/usage/providerQuota.ts"() {
@@ -7884,35 +7884,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 = z25.object({
-      type: z25.string(),
-      unit: z25.number().int(),
-      number: z25.number().int().positive(),
-      percentage: z25.number().nonnegative(),
-      nextResetTime: z25.number().positive().optional(),
-      usage: z25.number().nonnegative().optional(),
-      currentValue: z25.number().nonnegative().optional(),
-      remaining: z25.number().nonnegative().optional()
+    ZaiLimitSchema = z27.object({
+      type: z27.string(),
+      unit: z27.number().int(),
+      number: z27.number().int().positive(),
+      percentage: z27.number().nonnegative(),
+      nextResetTime: z27.number().positive().optional(),
+      usage: z27.number().nonnegative().optional(),
+      currentValue: z27.number().nonnegative().optional(),
+      remaining: z27.number().nonnegative().optional()
     });
-    ZaiResponseSchema = z25.object({
-      success: z25.boolean(),
-      msg: z25.string().optional(),
-      data: z25.object({ level: z25.string().optional(), limits: z25.array(ZaiLimitSchema) })
+    ZaiResponseSchema = z27.object({
+      success: z27.boolean(),
+      msg: z27.string().optional(),
+      data: z27.object({ level: z27.string().optional(), limits: z27.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 = z25.object({
-      data: z25.object({
-        limit: z25.number().nonnegative().nullable(),
-        limit_remaining: z25.number().nullable(),
-        limit_reset: z25.string().nullable(),
-        is_free_tier: z25.boolean().optional(),
-        free_model_daily_requests: z25.object({ used: z25.number().nonnegative(), limit: z25.number().nonnegative(), remaining: z25.number() }).optional()
+    OpenRouterKeySchema = z27.object({
+      data: z27.object({
+        limit: z27.number().nonnegative().nullable(),
+        limit_remaining: z27.number().nullable(),
+        limit_reset: z27.string().nullable(),
+        is_free_tier: z27.boolean().optional(),
+        free_model_daily_requests: z27.object({ used: z27.number().nonnegative(), limit: z27.number().nonnegative(), remaining: z27.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = z25.object({ data: z25.object({ total_credits: z25.number().nonnegative(), total_usage: z25.number().nonnegative() }) });
+    OpenRouterCreditsSchema = z27.object({ data: z27.object({ total_credits: z27.number().nonnegative(), total_usage: z27.number().nonnegative() }) });
   }
 });
 
@@ -8525,8 +8525,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",
@@ -9061,11 +9061,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"),
@@ -9447,8 +9447,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 });
@@ -9550,15 +9550,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) {
@@ -9727,11 +9727,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 } }) };
       }
     },
     {
@@ -10041,9 +10041,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 });
     }
@@ -10115,10 +10115,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)}` };
     }
@@ -10130,7 +10130,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 {
@@ -10149,10 +10149,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}`),
@@ -10311,12 +10311,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
@@ -10381,12 +10381,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,
@@ -10428,9 +10428,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 };
@@ -11581,19 +11581,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;
       }
@@ -13727,7 +13727,7 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path37, summary) => authed.meta(openapi3({ method: "POST", path: path37, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path38, summary) => authed.meta(openapi3({ method: "POST", path: path38, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
@@ -16302,6 +16302,376 @@ init_preflight();
 init_pick();
 init_plan2();
 init_poolPick();
+
+// src/agents/read.ts
+import path33 from "node:path";
+import { z as z26 } from "zod";
+
+// src/agents/schema.ts
+import { z as z25 } from "zod";
+var AgentMetaSchema = z25.looseObject({
+  agentType: z25.string(),
+  isFork: z25.boolean().optional(),
+  description: z25.string().optional(),
+  name: z25.string().optional(),
+  toolUseId: z25.string().optional(),
+  spawnDepth: z25.number().int().nonnegative().optional(),
+  parentAgentId: z25.string().optional(),
+  model: z25.string().optional(),
+  requestShape: z25.string().optional(),
+  requestNonInteractive: z25.boolean().optional(),
+  workflowPhase: z25.string().optional(),
+  taskKind: z25.string().optional(),
+  teamName: z25.string().optional(),
+  worktreePath: z25.string().optional(),
+  worktreeBranch: z25.string().optional(),
+  stoppedByUser: z25.boolean().optional()
+});
+var AgentKindSchema = z25.enum(["subagent", "fork", "workflow-agent", "teammate"]);
+var AgentNodeSchema = z25.lazy(
+  () => z25.strictObject({
+    id: z25.string(),
+    kind: AgentKindSchema,
+    agentType: z25.string(),
+    description: z25.string().optional(),
+    name: z25.string().optional(),
+    toolUseId: z25.string().optional(),
+    spawnDepth: z25.number().int().nonnegative().optional(),
+    model: z25.string().optional(),
+    background: z25.boolean().optional(),
+    workflowRunId: z25.string().optional(),
+    workflowPhase: z25.string().optional(),
+    teamName: z25.string().optional(),
+    stoppedByUser: z25.boolean().optional(),
+    transcript: z25.string(),
+    children: z25.array(AgentNodeSchema)
+  })
+);
+var TaskItemSchema = z25.strictObject({
+  id: z25.string(),
+  subject: z25.string(),
+  description: z25.string().optional(),
+  status: z25.string(),
+  /** What a spinner shows while the task runs. */
+  activeForm: z25.string().optional(),
+  /** The teammate or agent name the task is assigned to, as Agent Teams writes it. */
+  owner: z25.string().optional(),
+  /** Free-form data the harness attaches to a task, kept as written. */
+  metadata: z25.record(z25.string(), z25.unknown()).optional(),
+  blocks: z25.array(z25.string()),
+  blockedBy: z25.array(z25.string()),
+  /** The id of the shared task list this task belongs to (a team's name, or a custom list id), absent for the session's own list. */
+  taskList: z25.string().optional()
+});
+var WorkflowRunSchema = z25.strictObject({
+  runId: z25.string(),
+  workflowName: z25.string().optional(),
+  status: z25.string().optional(),
+  startTime: z25.number().optional(),
+  phases: z25.array(z25.string()),
+  summary: z25.string().optional()
+});
+var AgentTreeProblemSchema = z25.strictObject({
+  /** Relative to the identity's configuration directory. */
+  path: z25.string(),
+  reason: z25.string()
+});
+var SessionAgentTreeSchema = z25.strictObject({
+  project: z25.string(),
+  sessionId: z25.string(),
+  /** True for a session directory a resume superseded (`<session-id>.superseded-<epoch-ms>`). */
+  superseded: z25.boolean(),
+  /** The agents the session itself spawned, each with its descendants. */
+  agents: z25.array(AgentNodeSchema),
+  tasks: z25.array(TaskItemSchema),
+  workflowRuns: z25.array(WorkflowRunSchema),
+  problems: z25.array(AgentTreeProblemSchema)
+});
+
+// src/agents/read.ts
+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(path33.join(configDir, PROJECTS_DIR))) {
+    const projectDir = path33.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(path33.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: path33.join(relativeDir, name),
+      transcriptPath: path33.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(path33.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(path33.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 = z26.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z26.array(z26.string()).default([]), blockedBy: z26.array(z26.string()).default([]) });
+var WorkflowRunFileSchema = z26.object({
+  runId: z26.string(),
+  workflowName: z26.string().optional(),
+  status: z26.string().optional(),
+  startTime: z26.number().optional(),
+  phases: z26.array(z26.object({ title: z26.string() })).default([]),
+  summary: z26.string().optional()
+});
+function readSessionAgentTree(fs12, configDir, ref, options = {}) {
+  const problems = [];
+  const report = (problem) => {
+    problems.push(problem);
+  };
+  const sessionRelative = path33.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = path33.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = path33.join(subagentsRelative, WORKFLOWS_DIR);
+  const 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, path33.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, path33.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 = path33.join(TASKS_DIR, scope);
+    for (const name of [...listDirOrReport(fs12, configDir, relativeDir, report)].sort()) {
+      if (name.startsWith(".") || !name.endsWith(JSON_SUFFIX)) {
+        continue;
+      }
+      const relative = path33.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 = path33.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();
@@ -16409,6 +16779,9 @@ async function runClaudeLaunch(options) {
 init_ownCli();
 export {
   AMBIENT_CREDENTIAL_VARS,
+  AgentKindSchema,
+  AgentMetaSchema,
+  AgentNodeSchema,
   CHECK_CREDENTIAL_APPLIES,
   CODEX_APP_SERVER_GENERATED_AGAINST,
   CODEX_APP_SERVER_TIMEOUT_MS,
@@ -16555,6 +16928,8 @@ export {
   RcStreamEventSchema,
   ResetRowSchema,
   ResetScheduleSchema,
+  SessionAgentTreeSchema,
+  TaskItemSchema,
   USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema,
   UsageError,
@@ -16565,6 +16940,7 @@ export {
   UsageWindowsInputSchema,
   UsageWindowsOutputSchema,
   WhenSchema,
+  WorkflowRunSchema,
   addDirectoryRule,
   addIdentity,
   addPool,
@@ -16666,6 +17042,7 @@ export {
   listIdentities,
   listProfiles,
   listProviders,
+  listSessions2 as listSessions,
   listUsageSnapshots,
   matchBranch,
   mintLeaf,
@@ -16700,6 +17077,7 @@ export {
   readProvider,
   readRcSelfHostRecord,
   readRcSessionFile,
+  readSessionAgentTree,
   readUsageSnapshot,
   realCodexAppServerPort,
   realConnectCertStore,