@cursor/july 0.1.2 → 0.1.3

package/src/internal/resolve-prod-target.ts

@@ -0,0 +1,150 @@
+/**
+ * Resolve a hosted (managed) agent-serve deployment into a base URL +
+ * request headers for chat/run/call/eval `--prod`.
+ *
+ * Uses short-lived `engineAccess` from the deployment status route
+ * (Cursor API key on the management API; `X-Anyrun-Port-Token` on the
+ * engine). Alias tokens are out of scope here.
+ */
+
+import { basename, resolve } from "node:path";
+import { resolveDeployAuth } from "./cli-deploy.js";
+import {
+  DeployApiError,
+  type DeploymentDetail,
+  slugFromDirectoryName,
+  validateDeploymentSlug,
+} from "./deploy-client.js";
+import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
+import { stderrPalette } from "./terminal-style.js";
+
+/**
+ * Interactive CLI keep-alive for hosted engines. Without these, a hibernated
+ * Anyrun pod returns 417 `pod_hibernated` and never wakes. Matches the
+ * cloud-agent interactive keep-alive shape (lower ≤ upper, seconds).
+ */
+export const PROD_ENGINE_WAKE_HEADERS: Readonly<Record<string, string>> = {
+  "x-anyrun-hibernation-lower-bound-s": "1800",
+  "x-anyrun-hibernation-upper-bound-s": "3600",
+};
+
+export interface ResolveProdTargetOptions {
+  dir: string;
+  cwd?: string;
+  /** Explicit deployment slug; otherwise derived from `--dir` basename. */
+  slug?: string;
+  team?: string;
+  apiKey?: string;
+  fetchImpl?: typeof fetch;
+  err?: (text: string) => void;
+}
+
+export interface ResolvedProdTarget {
+  agentUrl: string;
+  headers: Record<string, string>;
+  slug: string;
+  expiresAt: string;
+}
+
+/**
+ * Look up a running deployment and return its engineAccess URL/headers.
+ * Throws {@link Error} with a CLI-ready message on failure.
+ */
+export async function resolveProdTarget(
+  options: ResolveProdTargetOptions
+): Promise<ResolvedProdTarget> {
+  const err =
+    options.err ?? ((text: string) => void process.stderr.write(text));
+  const slug = resolveProdSlug(options);
+  const auth = await resolveDeployAuth({
+    team: options.team,
+    apiKey: options.apiKey,
+    fetchImpl: options.fetchImpl,
+    err,
+  });
+  if (typeof auth === "number") {
+    throw new Error(
+      `Could not resolve Cursor credentials/team for --prod (see above).`
+    );
+  }
+
+  let detail: DeploymentDetail;
+  try {
+    detail = await auth.client.getDeployment({
+      teamId: auth.teamId,
+      slug,
+    });
+  } catch (error) {
+    if (error instanceof DeployApiError) {
+      throw new Error(
+        `Deployment "${slug}" (team ${auth.teamId}): ${error.message}`
+      );
+    }
+    throw error;
+  }
+
+  // `degraded` still serves the previous ACTIVE engine; allow runtime access
+  // when the control plane minted engineAccess for it.
+  const access = detail.engineAccess;
+  const statusOk = detail.status === "running" || detail.status === "degraded";
+  if (!statusOk) {
+    const lastError =
+      detail.lastError === null || detail.lastError === undefined
+        ? ""
+        : ` ${sanitizeCustomerFacingDetail(detail.lastError)}`;
+    throw new Error(
+      `Deployment "${slug}" is ${detail.status}, not running.${lastError}\n` +
+        `Deploy or wait: \`${CLI} deploy --slug ${slug}\` / \`${CLI} deployment ${slug}\``
+    );
+  }
+  if (access === null || access === undefined) {
+    throw new Error(
+      `Deployment "${slug}" is ${detail.status} but is not reachable yet. ` +
+        `Try \`${CLI} deployment ${slug}\` or redeploy.`
+    );
+  }
+
+  err(`${stderrPalette().dim(`Using hosted deployment "${slug}".`)}\n`);
+
+  return {
+    agentUrl: access.url.replace(/\/$/, ""),
+    headers: {
+      ...access.headers,
+      ...PROD_ENGINE_WAKE_HEADERS,
+    },
+    slug,
+    expiresAt: access.expiresAt,
+  };
+}
+
+/** Strip obvious hosting internals from customer-facing error fragments. */
+function sanitizeCustomerFacingDetail(message: string): string {
+  return message
+    .replace(/https?:\/\/\S+/gi, "[url]")
+    .replace(/\bpod-[a-z0-9]+\b/gi, "[runtime]")
+    .replace(/\banyrun\b/gi, "runtime")
+    .replace(/\bcursorvm\.com\b/gi, "host");
+}
+
+/** Resolve the deployment slug the same way `deploy` does for a single dir. */
+export function resolveProdSlug(options: {
+  dir: string;
+  cwd?: string;
+  slug?: string;
+}): string {
+  if (options.slug !== undefined && options.slug !== "") {
+    const slugError = validateDeploymentSlug(options.slug);
+    if (slugError !== undefined) {
+      throw new Error(slugError);
+    }
+    return options.slug;
+  }
+  const dir = resolve(options.cwd ?? process.cwd(), options.dir);
+  const derived = slugFromDirectoryName(basename(dir));
+  if (derived === undefined) {
+    throw new Error(
+      `Could not derive a deployment slug from the directory name ${JSON.stringify(basename(dir))}; pass --slug.`
+    );
+  }
+  return derived;
+}

package/src/internal/run-client.ts

@@ -7,6 +7,7 @@
  */
 
 import type { SessionEvent, SessionPurpose } from "../types.js";
+import { mergeRequestHeaders, type RequestAuth } from "./request-headers.js";
 import { buildTrajectory, type Trajectory } from "./trajectory.js";
 
 /** Thrown when a turn stream exceeds `timeoutMs`; carries the session id. */
@@ -19,9 +20,8 @@ export class RunSessionTimeoutError extends Error {
     this.name = "RunSessionTimeoutError";
   }
 }
-export interface RunClientOptions {
+export interface RunClientOptions extends RequestAuth {
   baseUrl: string;
-  bearerToken?: string;
   /** Abort a hung turn. */
   timeoutMs?: number;
   /** Called for each stream event as it arrives (for CLI progress). */
@@ -72,6 +72,11 @@ export async function runSession(
   const allEvents: SessionEvent[] = [];
   let nextEventIndex = 0;
 
+  const auth: RequestAuth = {
+    bearerToken: options.bearerToken,
+    headers: options.headers,
+  };
+
   for (const message of options.messages) {
     const turn = await runOneTurn({
       baseUrl,
@@ -79,18 +84,13 @@ export async function runSession(
       sessionId,
       continuationToken,
       startIndex: sessionId === undefined ? 0 : nextEventIndex,
-      bearerToken: options.bearerToken,
+      auth,
       timeoutMs: options.timeoutMs,
       onEvent: options.onEvent,
-      ...(sessionId === undefined && options.purpose !== undefined
-        ? { purpose: options.purpose }
-        : {}),
-      ...(sessionId === undefined && options.workspaceDir !== undefined
-        ? { workspaceDir: options.workspaceDir }
-        : {}),
-      ...(sessionId === undefined && options.workspaceFiles !== undefined
-        ? { workspaceFiles: options.workspaceFiles }
-        : {}),
+      purpose: sessionId === undefined ? options.purpose : undefined,
+      workspaceDir: sessionId === undefined ? options.workspaceDir : undefined,
+      workspaceFiles:
+        sessionId === undefined ? options.workspaceFiles : undefined,
     });
     sessionId = turn.sessionId;
     continuationToken = turn.continuationToken;
@@ -128,7 +128,7 @@ interface OneTurnArgs {
   workspaceDir?: string;
   workspaceFiles?: Record<string, string>;
   startIndex: number;
-  bearerToken?: string;
+  auth?: RequestAuth;
   timeoutMs?: number;
   onEvent?: (event: SessionEvent) => void;
 }
@@ -145,20 +145,21 @@ async function runOneTurn(args: OneTurnArgs): Promise<OneTurnResult> {
   let continuationToken = args.continuationToken;
 
   if (sessionId === undefined) {
+    const body: Record<string, unknown> = { message: args.message };
+    if (args.purpose !== undefined) {
+      body.purpose = args.purpose;
+    }
+    if (args.workspaceDir !== undefined) {
+      body.workspaceDir = args.workspaceDir;
+    }
+    if (args.workspaceFiles !== undefined) {
+      body.workspaceFiles = args.workspaceFiles;
+    }
     const created = await postJson(
       args.baseUrl,
       "/v1/session",
-      {
-        message: args.message,
-        ...(args.purpose === undefined ? {} : { purpose: args.purpose }),
-        ...(args.workspaceDir === undefined
-          ? {}
-          : { workspaceDir: args.workspaceDir }),
-        ...(args.workspaceFiles === undefined
-          ? {}
-          : { workspaceFiles: args.workspaceFiles }),
-      },
-      args.bearerToken
+      body,
+      args.auth
     );
     if (created.status >= 400 || created.body.ok === false) {
       throw new Error(
@@ -172,7 +173,7 @@ async function runOneTurn(args: OneTurnArgs): Promise<OneTurnResult> {
       args.baseUrl,
       `/v1/session/${sessionId}`,
       { message: args.message, continuationToken },
-      args.bearerToken
+      args.auth
     );
     if (resp.status >= 400 || resp.body.ok === false) {
       throw new Error(
@@ -190,7 +191,7 @@ async function runOneTurn(args: OneTurnArgs): Promise<OneTurnResult> {
     baseUrl: args.baseUrl,
     sessionId,
     startIndex: args.startIndex,
-    bearerToken: args.bearerToken,
+    auth: args.auth,
     timeoutMs: args.timeoutMs,
     onEvent: args.onEvent,
   });
@@ -209,7 +210,7 @@ async function collectStream(args: {
   baseUrl: string;
   sessionId: string;
   startIndex: number;
-  bearerToken?: string;
+  auth?: RequestAuth;
   timeoutMs?: number;
   onEvent?: (event: SessionEvent) => void;
 }): Promise<SessionEvent[]> {
@@ -223,7 +224,7 @@ async function collectStream(args: {
     const resp = await fetch(
       `${args.baseUrl}/v1/session/${args.sessionId}/stream?startIndex=${args.startIndex}`,
       {
-        headers: authHeaders(args.bearerToken),
+        headers: mergeRequestHeaders(args.auth),
         signal: controller.signal,
       }
     );
@@ -283,23 +284,17 @@ async function collectStream(args: {
   }
 }
 
-function authHeaders(bearerToken: string | undefined): Record<string, string> {
-  return bearerToken === undefined
-    ? {}
-    : { authorization: `Bearer ${bearerToken}` };
-}
-
 async function postJson(
   baseUrl: string,
   path: string,
   body: unknown,
-  bearerToken?: string
+  auth?: RequestAuth
 ): Promise<{ status: number; body: Record<string, unknown> }> {
   const resp = await fetch(`${baseUrl}${path}`, {
     method: "POST",
     headers: {
       "content-type": "application/json",
-      ...authHeaders(bearerToken),
+      ...mergeRequestHeaders(auth),
     },
     body: JSON.stringify(body),
   });
@@ -312,6 +307,14 @@ async function postJson(
       parsed = { message: text };
     }
   }
+  const anyrunReason = resp.headers.get("x-anyrun-failure-reason");
+  if (
+    anyrunReason !== null &&
+    anyrunReason !== "" &&
+    (parsed.message === undefined || parsed.message === "")
+  ) {
+    parsed.message = anyrunReason;
+  }
   return { status: resp.status, body: parsed };
 }
 

package/src/internal/server.ts

@@ -50,6 +50,7 @@ import {
 import { CursorBackendClient } from "./cursor/backend-client.js";
 import {
   cursorBackendUrl,
+  cursorExternalApiUrl,
   type ResolvedApiKey,
   resolveApiKey,
   SIGN_IN_HINT,
@@ -227,8 +228,13 @@ export async function startServer(
       );
     }
     if (options.allowAnonymous === true) {
-      throw new Error(
-        "githubChannel({ cursorAccount: true }) cannot be served with --allow-anonymous because admitted callers could use the signed-in account's GitHub access."
+      if (options.allowAnonymousCursorGithub !== true) {
+        throw new Error(
+          "githubChannel({ cursorAccount: true }) cannot be served with --allow-anonymous because admitted callers could use the signed-in account's GitHub access. If every admitted caller is trusted (e.g. behind an SSO proxy), opt in with --allow-anonymous-cursor-github."
+        );
+      }
+      logger(
+        "[agent-serve] warning: --allow-anonymous-cursor-github — every admitted HTTP caller can drive sessions holding the signed-in account's repo-scoped GitHub credential; serve this only behind a trusted boundary (e.g. an SSO proxy)"
       );
     }
     if (cursorGithubConfig.scope.permissions === "contents-write") {
@@ -1330,7 +1336,10 @@ function requireCursorEventsAuth(
   }
   return {
     apiKey,
-    baseUrl: config.baseUrl ?? accountKey?.backendUrl ?? cursorBackendUrl(),
+    // `/v0/scm-events/*` lives on the external API (api.cursor.com), not
+    // api2. Prefer that default over the account key's backendUrl, which
+    // follows cursorBackendUrl() (api2) when CURSOR_API_KEY is set.
+    baseUrl: config.baseUrl ?? cursorExternalApiUrl(),
   };
 }
 

package/src/internal/session-engine.ts

@@ -54,6 +54,7 @@ import { type ABSnapshot, buildABSnapshot } from "./ab-snapshot.js";
 import { ApprovalGate } from "./approval-gate.js";
 import { samePrincipal } from "./auth.js";
 import { mergeCloudOptions, resolveSessionRuntime } from "./cloud-merge.js";
+import { isDevMode } from "./dev-mode.js";
 import { EventLogStore } from "./event-log.js";
 import { TurnEventMapper } from "./event-mapper.js";
 import { createHostPlatforms, type HostPlatforms } from "./host-platforms.js";
@@ -65,6 +66,11 @@ import {
 } from "./ids.js";
 import { validateToolInput } from "./json-schema.js";
 import { McpHost } from "./mcp-host.js";
+import {
+  buildIdentitySection,
+  buildSessionContextBlock,
+  SCHEDULE_CHANNEL_PREFIX,
+} from "./prompt-context.js";
 import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections.js";
 import type { AgentRunner } from "./sdk-runner.js";
 import { SessionStore } from "./session-store.js";
@@ -77,7 +83,7 @@ import {
 } from "./workspace.js";
 
 export const HTTP_CHANNEL_ID = "http";
-export const SCHEDULE_CHANNEL_PREFIX = "schedule:";
+export { SCHEDULE_CHANNEL_PREFIX } from "./prompt-context.js";
 
 export class SessionBusyError extends Error {
   constructor(sessionId: string) {
@@ -744,7 +750,10 @@ export class SessionEngine {
           // events while sibling parallel tools are still executing.
           if (
             update.type === "tool-call-started" ||
-            update.type === "tool-call-completed"
+            update.type === "tool-call-completed" ||
+            // Nested subagent progress (newer SDKs); string check keeps
+            // typecheck green against older published `@cursor/sdk` pins.
+            (update as { type: string }).type === "tool-call-delta"
           ) {
             await yieldEventLoop();
           }
@@ -847,14 +856,24 @@ export class SessionEngine {
           })
         : undefined;
     let turnPrompt = prompt;
+    if (isFirstTurn) {
+      const contextBlock = buildSessionContextBlock({
+        sessionId: record.sessionId,
+        channelId: record.channelId,
+        channelKind: this.channelsById.get(record.channelId)?.meta?.kind,
+        environment: isDevMode() ? "local dev server" : "hosted deployment",
+      });
+      turnPrompt = `${contextBlock}\n\n${prompt}`;
+    }
     if (runtime === "cloud" && isFirstTurn) {
       const preamble = [
         agent.instructions?.trim() ?? "",
+        buildIdentitySection(agent),
         buildAgentToolsCatalog(agent.tools, { includeScripts: true }),
       ]
         .filter((part) => part !== "")
         .join("\n\n");
-      turnPrompt = preamble === "" ? prompt : `${preamble}\n\n${prompt}`;
+      turnPrompt = `${preamble}\n\n${turnPrompt}`;
     }
     return {
       sessionId: record.sessionId,

package/src/internal/sessions-client.ts

@@ -0,0 +1,182 @@
+/**
+ * Session list / event fetch for CLI (`sessions`, `session`, chat reattach).
+ *
+ * Customer-facing errors never include hosting URLs or infra jargon.
+ */
+
+import type { SessionEvent, SessionSummary } from "../types.js";
+import { sanitizeCustomerError } from "./logs-client.js";
+import { mergeRequestHeaders, type RequestAuth } from "./request-headers.js";
+
+export async function listSessions(args: {
+  baseUrl: string;
+  auth?: RequestAuth;
+  fetchImpl?: typeof fetch;
+}): Promise<SessionSummary[]> {
+  const baseUrl = args.baseUrl.replace(/\/$/, "");
+  const fetchImpl = args.fetchImpl ?? fetch;
+  let resp: Response;
+  try {
+    resp = await fetchImpl(`${baseUrl}/v1/sessions`, {
+      headers: mergeRequestHeaders(args.auth),
+    });
+  } catch (error) {
+    throw new Error(
+      sanitizeCustomerError(
+        error instanceof Error ? error.message : "Could not list sessions."
+      )
+    );
+  }
+  if (!resp.ok) {
+    throw new Error(`Could not list sessions (HTTP ${resp.status}).`);
+  }
+  const body = (await resp.json()) as { sessions?: unknown };
+  if (!Array.isArray(body.sessions)) {
+    return [];
+  }
+  const out: SessionSummary[] = [];
+  for (const row of body.sessions) {
+    const parsed = parseSessionSummary(row);
+    if (parsed !== undefined) {
+      out.push(parsed);
+    }
+  }
+  return out;
+}
+
+export async function fetchSessionEvents(args: {
+  baseUrl: string;
+  sessionId: string;
+  auth?: RequestAuth;
+  fetchImpl?: typeof fetch;
+}): Promise<SessionEvent[]> {
+  const baseUrl = args.baseUrl.replace(/\/$/, "");
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const path = `/v1/session/${encodeURIComponent(args.sessionId)}/events`;
+
+  try {
+    const jsonResp = await fetchImpl(`${baseUrl}${path}?format=json`, {
+      headers: mergeRequestHeaders(args.auth),
+    });
+    if (jsonResp.ok) {
+      const body = (await jsonResp.json()) as { events?: unknown };
+      if (Array.isArray(body.events)) {
+        return body.events as SessionEvent[];
+      }
+    } else if (jsonResp.status === 404) {
+      throw new Error(`Session ${args.sessionId} not found.`);
+    } else if (jsonResp.status === 403) {
+      throw new Error(
+        `Session ${args.sessionId} is not readable by this caller.`
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Session ")) {
+      throw error;
+    }
+    // Fall through to NDJSON.
+  }
+
+  try {
+    const resp = await fetchImpl(`${baseUrl}${path}`, {
+      headers: mergeRequestHeaders(args.auth),
+    });
+    if (resp.status === 404) {
+      throw new Error(`Session ${args.sessionId} not found.`);
+    }
+    if (resp.status === 403) {
+      throw new Error(
+        `Session ${args.sessionId} is not readable by this caller.`
+      );
+    }
+    if (!resp.ok) {
+      throw new Error(`Could not fetch session events (HTTP ${resp.status}).`);
+    }
+    const text = await resp.text();
+    const events: SessionEvent[] = [];
+    for (const line of text.split("\n")) {
+      if (line.trim() === "") {
+        continue;
+      }
+      try {
+        events.push(JSON.parse(line) as SessionEvent);
+      } catch {
+        // skip malformed lines
+      }
+    }
+    return events;
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Session ")) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.startsWith("Could not fetch")) {
+      throw new Error(sanitizeCustomerError(error.message));
+    }
+    throw new Error(
+      sanitizeCustomerError(
+        error instanceof Error
+          ? error.message
+          : "Could not fetch session events."
+      )
+    );
+  }
+}
+
+/** Lenient parse so partial stubs / older servers still list by sessionId. */
+function parseSessionSummary(value: unknown): SessionSummary | undefined {
+  if (typeof value !== "object" || value === null) {
+    return undefined;
+  }
+  const row = value as Record<string, unknown>;
+  if (typeof row.sessionId !== "string" || row.sessionId === "") {
+    return undefined;
+  }
+  const continuationToken =
+    typeof row.continuationToken === "string"
+      ? row.continuationToken
+      : row.continuationToken === null
+        ? null
+        : null;
+  return {
+    sessionId: row.sessionId,
+    channelId: typeof row.channelId === "string" ? row.channelId : "",
+    mode: row.mode === "task" ? "task" : "chat",
+    title: typeof row.title === "string" ? row.title : undefined,
+    turnCount: typeof row.turnCount === "number" ? row.turnCount : 0,
+    running: row.running === true,
+    createdAt: typeof row.createdAt === "string" ? row.createdAt : "",
+    updatedAt: typeof row.updatedAt === "string" ? row.updatedAt : "",
+    continuationToken,
+    externalUrl:
+      typeof row.externalUrl === "string" ? row.externalUrl : undefined,
+  };
+}
+
+/** Format a sessions table (id, channel, mode, turns, running, updated). */
+export function formatSessionsTable(sessions: SessionSummary[]): string {
+  if (sessions.length === 0) {
+    return "No sessions.\n";
+  }
+  const header = ["SESSION", "CHANNEL", "MODE", "TURNS", "RUNNING", "UPDATED"];
+  const rows = sessions.map((s) => [
+    s.sessionId,
+    s.channelId,
+    s.mode,
+    String(s.turnCount),
+    s.running ? "yes" : "no",
+    s.updatedAt,
+  ]);
+  return `${renderTable(header, rows)}\n`;
+}
+
+function renderTable(header: string[], rows: string[][]): string {
+  const widths = header.map((h, i) =>
+    Math.max(h.length, ...rows.map((row) => (row[i] ?? "").length))
+  );
+  const renderRow = (row: string[]): string =>
+    row
+      .map((cell, i) => cell.padEnd(widths[i] ?? 0))
+      .join("  ")
+      .trimEnd();
+  return [renderRow(header), ...rows.map(renderRow)].join("\n");
+}

package/src/internal/stream-progress.ts

@@ -64,6 +64,9 @@ export function createStreamProgress(options?: {
           break;
         }
         case "reasoning.appended": {
+          if (event.data.parentCallId !== undefined) {
+            break;
+          }
           if (!thinkingShown) {
             thinkingShown = true;
             write(c.dim("  · thinking…\n"));
@@ -71,6 +74,11 @@ export function createStreamProgress(options?: {
           break;
         }
         case "message.appended": {
+          // Nested subagent deltas stay inside the task chip/indent, not
+          // the parent agent stream.
+          if (event.data.parentCallId !== undefined) {
+            break;
+          }
           if (!assistantOpen) {
             write(`${c.green("‹ agent")}  `);
             assistantOpen = true;
@@ -79,6 +87,9 @@ export function createStreamProgress(options?: {
           break;
         }
         case "message.completed": {
+          if (event.data.parentCallId !== undefined) {
+            break;
+          }
           closeAssistant();
           break;
         }
@@ -98,9 +109,18 @@ export function createStreamProgress(options?: {
           closeAssistant();
           const now = Date.now();
           for (const call of event.data.calls) {
+            if (call.toolName === "task" && call.parentCallId === undefined) {
+              // Covered by subagent.called; avoid a duplicate bare `task` line.
+              continue;
+            }
             toolStartedAt.set(call.callId, now);
+            const indent =
+              call.parentCallId !== undefined ||
+              event.data.parentCallId !== undefined
+                ? "    "
+                : "  ";
             write(
-              `  ${c.magenta("⚙")} ${c.bold(call.toolName)}${c.dim(
+              `${indent}${c.magenta("⚙")} ${c.bold(call.toolName)}${c.dim(
                 formatArgs(call.args)
               )}\n`
             );
@@ -127,13 +147,21 @@ export function createStreamProgress(options?: {
           break;
         }
         case "action.result": {
+          if (
+            event.data.toolName === "task" &&
+            event.data.parentCallId === undefined
+          ) {
+            break;
+          }
           const started = toolStartedAt.get(event.data.callId);
           toolStartedAt.delete(event.data.callId);
           const dur =
             started === undefined ? "" : c.dim(` ${elapsed(started)}`);
           const mark = event.data.isError ? c.red("✗") : c.magenta("✓");
+          const indent =
+            event.data.parentCallId !== undefined ? "      " : "    ";
           write(
-            `    ${mark} ${c.bold(event.data.toolName)}${dur} ${c.dim(
+            `${indent}${mark} ${c.bold(event.data.toolName)}${dur} ${c.dim(
               truncate(stringify(event.data.output), 90)
             )}\n`
           );
@@ -149,6 +177,12 @@ export function createStreamProgress(options?: {
           );
           break;
         }
+        case "subagent.completed": {
+          write(
+            `  ${c.magenta("✓")} ${c.bold(event.data.name ?? "subagent")} ${c.dim("done")}\n`
+          );
+          break;
+        }
         case "turn.completed": {
           closeAssistant();
           const usage = event.data.usage;