@autohq/cli 0.1.87 → 0.1.89

package/dist/index.js

@@ -17654,6 +17654,307 @@ var init_run_diagnostics = __esm({
   }
 });
 
+// ../../packages/schemas/src/session-runs.ts
+var SESSION_RUN_STATUSES, SESSION_RUN_DISPLAY_TITLE_MAX_LENGTH, SessionRunStatusSchema, SessionRunDisplayTitleSchema, SESSION_RUN_CHECK_STATUSES, SESSION_RUN_CHECK_CONCLUSIONS, SESSION_RUN_CHECK_TIMEOUT_PHASES, SessionRunCheckStatusSchema, SessionRunCheckConclusionSchema, SessionRunCheckTimeoutPhaseSchema, ManualSessionRunRequestSchema, SessionRunArchiveRequestSchema, SessionRunsArchiveRequestSchema, SessionRunRecordSchema, SessionRunsArchiveResponseSchema;
+var init_session_runs = __esm({
+  "../../packages/schemas/src/session-runs.ts"() {
+    "use strict";
+    init_zod();
+    init_auth();
+    init_environments();
+    init_ids();
+    init_primitives();
+    init_profiles();
+    init_sessions();
+    init_tools();
+    SESSION_RUN_STATUSES = [
+      "queued",
+      "running",
+      "awaiting",
+      "failed",
+      "stopped"
+    ];
+    SESSION_RUN_DISPLAY_TITLE_MAX_LENGTH = 64;
+    SessionRunStatusSchema = external_exports.enum(SESSION_RUN_STATUSES);
+    SessionRunDisplayTitleSchema = external_exports.string().trim().max(SESSION_RUN_DISPLAY_TITLE_MAX_LENGTH);
+    SESSION_RUN_CHECK_STATUSES = [
+      "queued",
+      "in_progress",
+      "completed"
+    ];
+    SESSION_RUN_CHECK_CONCLUSIONS = ["success", "failure"];
+    SESSION_RUN_CHECK_TIMEOUT_PHASES = ["begin", "complete"];
+    SessionRunCheckStatusSchema = external_exports.enum(SESSION_RUN_CHECK_STATUSES);
+    SessionRunCheckConclusionSchema = external_exports.enum(
+      SESSION_RUN_CHECK_CONCLUSIONS
+    );
+    SessionRunCheckTimeoutPhaseSchema = external_exports.enum(
+      SESSION_RUN_CHECK_TIMEOUT_PHASES
+    );
+    ManualSessionRunRequestSchema = external_exports.object({
+      message: external_exports.string().trim().min(1).max(2e4).optional(),
+      interactive: external_exports.boolean().optional()
+    });
+    SessionRunArchiveRequestSchema = external_exports.object({
+      archived: external_exports.boolean()
+    });
+    SessionRunsArchiveRequestSchema = external_exports.object({
+      run_ids: external_exports.array(SessionRunIdSchema2).min(1).max(100),
+      archived: external_exports.boolean()
+    });
+    SessionRunRecordSchema = external_exports.object({
+      id: SessionRunIdSchema2,
+      organizationId: external_exports.string().trim().min(1),
+      projectId: external_exports.string().trim().min(1).nullable(),
+      sessionId: SessionIdSchema,
+      runtimeId: RuntimeIdSchema2.nullable(),
+      status: SessionRunStatusSchema,
+      idempotencyKey: external_exports.string().min(1).nullable(),
+      correlationKey: external_exports.string().nullable(),
+      workflowId: external_exports.string().min(1),
+      displayTitle: SessionRunDisplayTitleSchema,
+      starterActor: AuthActorSchema.nullable(),
+      sessionSnapshot: SessionResourceSchema,
+      profileSnapshot: ProfileResourceSchema,
+      environmentSnapshot: EnvironmentResourceSchema,
+      toolSnapshots: external_exports.array(
+        external_exports.discriminatedUnion("source", [
+          external_exports.object({
+            source: external_exports.literal("inline"),
+            alias: ToolAliasSchema,
+            spec: RemoteMcpToolSchema.or(LocalToolSchema)
+          }),
+          external_exports.object({
+            source: external_exports.literal("resource"),
+            alias: ToolAliasSchema,
+            resource: ToolResourceSchema
+          })
+        ])
+      ),
+      input: JsonValueSchema2,
+      createdAt: external_exports.string().datetime(),
+      updatedAt: external_exports.string().datetime(),
+      startedAt: external_exports.string().datetime().nullable(),
+      finishedAt: external_exports.string().datetime().nullable(),
+      archivedAt: external_exports.string().datetime().nullable(),
+      error: JsonValueSchema2.nullable()
+    });
+    SessionRunsArchiveResponseSchema = external_exports.object({
+      archived: external_exports.boolean(),
+      runs: external_exports.array(SessionRunRecordSchema)
+    });
+  }
+});
+
+// ../../packages/schemas/src/run-introspection.ts
+var TruncatedValueSchema, RunConversationSearchSnippetSchema, RunConversationSearchMatchSchema, RunConversationSearchResponseSchema, RunToolExchangeSchema, RunToolExchangesResponseSchema, RUN_TRIGGER_DELIVERY_ACTIONS, RunTriggerDeliveryActionSchema, RUN_EVENT_ORIGIN_KINDS, RunEventOriginKindSchema, RunTriggerDeliveryRecordSchema, RunTriggersResponseSchema, RunArtifactRecordSchema, RunArtifactsResponseSchema, RunTurnSchema, RunToolStatSchema, RunSummarySchema;
+var init_run_introspection = __esm({
+  "../../packages/schemas/src/run-introspection.ts"() {
+    "use strict";
+    init_zod();
+    init_auth();
+    init_conversation();
+    init_ids();
+    init_primitives();
+    init_session_runs();
+    TruncatedValueSchema = external_exports.object({
+      truncated: external_exports.literal(true),
+      truncatedPreview: external_exports.string(),
+      originalBytes: external_exports.number().int().nonnegative()
+    });
+    RunConversationSearchSnippetSchema = external_exports.object({
+      partIndex: external_exports.number().int().nonnegative(),
+      partType: external_exports.string(),
+      /** The search term this snippet was produced for. */
+      query: external_exports.string(),
+      text: external_exports.string()
+    });
+    RunConversationSearchMatchSchema = external_exports.object({
+      sequence: external_exports.number().int().nonnegative(),
+      role: ConversationRoleSchema2,
+      kind: ConversationEntryKindSchema2,
+      status: ConversationEntryStatusSchema2,
+      createdAt: external_exports.string().datetime(),
+      /** Which of the requested terms matched this entry. */
+      matchedQueries: external_exports.array(external_exports.string()),
+      /** Total match occurrences across terms in this entry. */
+      matchCount: external_exports.number().int().positive(),
+      snippets: external_exports.array(RunConversationSearchSnippetSchema)
+    });
+    RunConversationSearchResponseSchema = external_exports.object({
+      matches: external_exports.array(RunConversationSearchMatchSchema),
+      hasMore: external_exports.boolean(),
+      /**
+       * Sequence of the last candidate entry scanned (not just the last confirmed
+       * match) — pass as `afterSequence` to continue without re-scanning
+       * candidates the match confirmation dropped. Null when nothing was scanned.
+       */
+      nextAfterSequence: external_exports.number().int().nullable()
+    });
+    RunToolExchangeSchema = external_exports.object({
+      name: external_exports.string(),
+      callSequence: external_exports.number().int().nonnegative(),
+      resultSequence: external_exports.number().int().nonnegative().nullable(),
+      input: JsonValueSchema2,
+      output: JsonValueSchema2.nullable(),
+      /** Null while the call has no recorded result. */
+      isError: external_exports.boolean().nullable(),
+      /** Result `completedAt` minus call `createdAt`; null without a result. */
+      durationMs: external_exports.number().int().nonnegative().nullable(),
+      startedAt: external_exports.string().datetime(),
+      completedAt: external_exports.string().datetime().nullable()
+    });
+    RunToolExchangesResponseSchema = external_exports.object({
+      exchanges: external_exports.array(RunToolExchangeSchema),
+      hasMore: external_exports.boolean(),
+      /**
+       * Sequence bounds of the entries window this page consumed (not just the
+       * returned exchanges) — continue paging with `after`/`before` from these so
+       * filtered-out entries are not re-scanned. Null when nothing was scanned.
+       */
+      nextAfterSequence: external_exports.number().int().nullable(),
+      nextBeforeSequence: external_exports.number().int().nullable()
+    });
+    RUN_TRIGGER_DELIVERY_ACTIONS = [
+      "started",
+      "signaled",
+      "dropped",
+      "warned",
+      "errored"
+    ];
+    RunTriggerDeliveryActionSchema = external_exports.enum(
+      RUN_TRIGGER_DELIVERY_ACTIONS
+    );
+    RUN_EVENT_ORIGIN_KINDS = [
+      "internal",
+      "provider_grant",
+      "webhook"
+    ];
+    RunEventOriginKindSchema = external_exports.enum(RUN_EVENT_ORIGIN_KINDS);
+    RunTriggerDeliveryRecordSchema = external_exports.object({
+      action: RunTriggerDeliveryActionSchema,
+      triggerId: external_exports.string(),
+      eventKey: external_exports.string(),
+      originKind: RunEventOriginKindSchema,
+      occurredAt: external_exports.string().datetime(),
+      receivedAt: external_exports.string().datetime(),
+      deliveredAt: external_exports.string().datetime(),
+      reason: external_exports.string().nullable(),
+      /** Event payload; may be a {@link TruncatedValueSchema} marker. */
+      payload: JsonValueSchema2.optional()
+    });
+    RunTriggersResponseSchema = external_exports.object({
+      /** The `started` delivery that spawned the run; null for manual/agent spawns. */
+      spawn: RunTriggerDeliveryRecordSchema.nullable(),
+      /** Who started the run, for manual/CLI/agent spawns. */
+      starter: AuthActorSchema.nullable(),
+      /** Subsequent deliveries against the run, chronological. */
+      deliveries: external_exports.array(RunTriggerDeliveryRecordSchema)
+    });
+    RunArtifactRecordSchema = external_exports.object({
+      artifactType: external_exports.string(),
+      externalId: external_exports.string(),
+      payload: JsonValueSchema2,
+      recordedAt: external_exports.string().datetime()
+    });
+    RunArtifactsResponseSchema = external_exports.object({
+      artifacts: external_exports.array(RunArtifactRecordSchema)
+    });
+    RunTurnSchema = external_exports.object({
+      startSequence: external_exports.number().int().nonnegative(),
+      endSequence: external_exports.number().int().nonnegative(),
+      startedAt: external_exports.string().datetime(),
+      completedAt: external_exports.string().datetime().nullable(),
+      toolCallCount: external_exports.number().int().nonnegative()
+    });
+    RunToolStatSchema = external_exports.object({
+      name: external_exports.string(),
+      /** Run-wide call count from the SQL aggregate. */
+      calls: external_exports.number().int().nonnegative(),
+      /**
+       * Derived from the summary's recent-entries window (most recent ~1000
+       * entries), so on very long runs `errors` and `durationMs` can understate
+       * relative to the run-wide `calls`.
+       */
+      errors: external_exports.number().int().nonnegative(),
+      durationMs: external_exports.object({
+        p50: external_exports.number().nonnegative().nullable(),
+        max: external_exports.number().nonnegative().nullable()
+      })
+    });
+    RunSummarySchema = external_exports.object({
+      run: external_exports.object({
+        id: SessionRunIdSchema2,
+        sessionName: external_exports.string(),
+        profileName: external_exports.string(),
+        displayTitle: external_exports.string(),
+        status: SessionRunStatusSchema,
+        error: JsonValueSchema2.nullable(),
+        workflowId: external_exports.string(),
+        createdAt: external_exports.string().datetime(),
+        startedAt: external_exports.string().datetime().nullable(),
+        finishedAt: external_exports.string().datetime().nullable(),
+        archivedAt: external_exports.string().datetime().nullable()
+      }),
+      timing: external_exports.object({
+        /** `startedAt - createdAt`; null until the run starts. */
+        queuedMs: external_exports.number().int().nonnegative().nullable(),
+        /** `(finishedAt ?? now) - startedAt`; null until the run starts. */
+        activeMs: external_exports.number().int().nonnegative().nullable(),
+        /** `(finishedAt ?? now) - createdAt`. */
+        totalMs: external_exports.number().int().nonnegative()
+      }),
+      conversation: external_exports.object({
+        entryCount: external_exports.number().int().nonnegative(),
+        firstEntryAt: external_exports.string().datetime().nullable(),
+        lastEntryAt: external_exports.string().datetime().nullable(),
+        countsByKind: external_exports.object({
+          status: external_exports.number().int().nonnegative(),
+          message: external_exports.number().int().nonnegative(),
+          tool_call: external_exports.number().int().nonnegative(),
+          tool_result: external_exports.number().int().nonnegative(),
+          question: external_exports.number().int().nonnegative()
+        }),
+        failedEntryCount: external_exports.number().int().nonnegative(),
+        lastSequence: external_exports.number().int().nonnegative()
+      }),
+      tools: external_exports.array(RunToolStatSchema),
+      /**
+       * True when the run has more conversation entries than the summary's
+       * recent-entries window, meaning per-tool `errors`/`durationMs` (and
+       * `turns`) describe only the most recent slice of the run.
+       */
+      toolStatsWindowed: external_exports.boolean(),
+      trigger: external_exports.object({
+        /** Spawning event key, or "manual" / "agent" for actor-started runs. */
+        spawn: external_exports.string(),
+        signaledCount: external_exports.number().int().nonnegative(),
+        droppedCount: external_exports.number().int().nonnegative()
+      }),
+      artifacts: external_exports.object({
+        count: external_exports.number().int().nonnegative(),
+        types: external_exports.array(external_exports.string())
+      }),
+      /** Derived per-user-message turns, capped to the most recent. */
+      turns: external_exports.array(RunTurnSchema),
+      commands: external_exports.object({
+        total: external_exports.number().int().nonnegative(),
+        byKind: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
+        failed: external_exports.number().int().nonnegative()
+      }),
+      checks: external_exports.array(
+        external_exports.object({
+          name: external_exports.string(),
+          displayName: external_exports.string(),
+          status: SessionRunCheckStatusSchema,
+          conclusion: SessionRunCheckConclusionSchema.nullable(),
+          completedAt: external_exports.string().datetime().nullable()
+        })
+      )
+    });
+  }
+});
+
 // ../../packages/schemas/src/session-run-commands.ts
 var SESSION_RUN_COMMAND_KINDS, SESSION_RUN_DISPATCH_COMMAND_KINDS, SESSION_RUN_PERSISTED_COMMAND_KINDS, SESSION_RUN_LIFECYCLE_COMMAND_KINDS, SESSION_RUN_COMMAND_STATUSES, SESSION_RUN_DISPATCH_COMMAND_STATUSES, SessionRunCommandKindSchema2, SessionRunPersistedCommandKindSchema, SessionRunDispatchCommandKindSchema, SessionRunLifecycleCommandKindSchema, SessionRunCommandStatusSchema, SessionRunDispatchCommandStatusSchema, SessionRunCommandSenderSchema, SessionRunMessageCommandPayloadSchema, SessionRunAnswerCommandPayloadSchema, SessionRunLifecycleCommandPayloadSchema, SessionRunCommandPayloadSchema, CreateSessionRunMessageCommandRequestSchema, CreateSessionRunAnswerCommandRequestSchema, CreateSessionRunLifecycleCommandRequestSchema, CreateSessionRunCommandRequestSchema, SessionRunResolutionPolicySchema, SessionAddressedCommandTargetSchema, SessionRunCommandRecordBaseSchema, SessionRunStartCommandPayloadSchema, SessionRunStartWithMessageCommandPayloadSchema, SessionRunPersistedCommandPayloadSchema, SessionRunCommandRecordSchema, SessionRunDispatchMessageCommandPayloadSchema, SessionRunDispatchAnswerCommandPayloadSchema, SessionRunDispatchStopCommandPayloadSchema, SessionRunDispatchCommandPayloadSchema, SessionRunDispatchCommandRecordBaseSchema, SessionRunDispatchCommandRecordSchema;
 var init_session_run_commands = __esm({
@@ -17970,98 +18271,6 @@ var init_runtimes = __esm({
   }
 });
 
-// ../../packages/schemas/src/session-runs.ts
-var SESSION_RUN_STATUSES, SESSION_RUN_DISPLAY_TITLE_MAX_LENGTH, SessionRunStatusSchema, SessionRunDisplayTitleSchema, SESSION_RUN_CHECK_STATUSES, SESSION_RUN_CHECK_CONCLUSIONS, SESSION_RUN_CHECK_TIMEOUT_PHASES, SessionRunCheckStatusSchema, SessionRunCheckConclusionSchema, SessionRunCheckTimeoutPhaseSchema, ManualSessionRunRequestSchema, SessionRunArchiveRequestSchema, SessionRunsArchiveRequestSchema, SessionRunRecordSchema, SessionRunsArchiveResponseSchema;
-var init_session_runs = __esm({
-  "../../packages/schemas/src/session-runs.ts"() {
-    "use strict";
-    init_zod();
-    init_auth();
-    init_environments();
-    init_ids();
-    init_primitives();
-    init_profiles();
-    init_sessions();
-    init_tools();
-    SESSION_RUN_STATUSES = [
-      "queued",
-      "running",
-      "awaiting",
-      "failed",
-      "stopped"
-    ];
-    SESSION_RUN_DISPLAY_TITLE_MAX_LENGTH = 64;
-    SessionRunStatusSchema = external_exports.enum(SESSION_RUN_STATUSES);
-    SessionRunDisplayTitleSchema = external_exports.string().trim().max(SESSION_RUN_DISPLAY_TITLE_MAX_LENGTH);
-    SESSION_RUN_CHECK_STATUSES = [
-      "queued",
-      "in_progress",
-      "completed"
-    ];
-    SESSION_RUN_CHECK_CONCLUSIONS = ["success", "failure"];
-    SESSION_RUN_CHECK_TIMEOUT_PHASES = ["begin", "complete"];
-    SessionRunCheckStatusSchema = external_exports.enum(SESSION_RUN_CHECK_STATUSES);
-    SessionRunCheckConclusionSchema = external_exports.enum(
-      SESSION_RUN_CHECK_CONCLUSIONS
-    );
-    SessionRunCheckTimeoutPhaseSchema = external_exports.enum(
-      SESSION_RUN_CHECK_TIMEOUT_PHASES
-    );
-    ManualSessionRunRequestSchema = external_exports.object({
-      message: external_exports.string().trim().min(1).max(2e4).optional(),
-      interactive: external_exports.boolean().optional()
-    });
-    SessionRunArchiveRequestSchema = external_exports.object({
-      archived: external_exports.boolean()
-    });
-    SessionRunsArchiveRequestSchema = external_exports.object({
-      run_ids: external_exports.array(SessionRunIdSchema2).min(1).max(100),
-      archived: external_exports.boolean()
-    });
-    SessionRunRecordSchema = external_exports.object({
-      id: SessionRunIdSchema2,
-      organizationId: external_exports.string().trim().min(1),
-      projectId: external_exports.string().trim().min(1).nullable(),
-      sessionId: SessionIdSchema,
-      runtimeId: RuntimeIdSchema2.nullable(),
-      status: SessionRunStatusSchema,
-      idempotencyKey: external_exports.string().min(1).nullable(),
-      correlationKey: external_exports.string().nullable(),
-      workflowId: external_exports.string().min(1),
-      displayTitle: SessionRunDisplayTitleSchema,
-      starterActor: AuthActorSchema.nullable(),
-      sessionSnapshot: SessionResourceSchema,
-      profileSnapshot: ProfileResourceSchema,
-      environmentSnapshot: EnvironmentResourceSchema,
-      toolSnapshots: external_exports.array(
-        external_exports.discriminatedUnion("source", [
-          external_exports.object({
-            source: external_exports.literal("inline"),
-            alias: ToolAliasSchema,
-            spec: RemoteMcpToolSchema.or(LocalToolSchema)
-          }),
-          external_exports.object({
-            source: external_exports.literal("resource"),
-            alias: ToolAliasSchema,
-            resource: ToolResourceSchema
-          })
-        ])
-      ),
-      input: JsonValueSchema2,
-      createdAt: external_exports.string().datetime(),
-      updatedAt: external_exports.string().datetime(),
-      startedAt: external_exports.string().datetime().nullable(),
-      finishedAt: external_exports.string().datetime().nullable(),
-      archivedAt: external_exports.string().datetime().nullable(),
-      error: JsonValueSchema2.nullable()
-    });
-    SessionRunsArchiveResponseSchema = external_exports.object({
-      archived: external_exports.boolean(),
-      runs: external_exports.array(SessionRunRecordSchema)
-    });
-  }
-});
-
 // ../../packages/schemas/src/temporal.ts
 var ResourceReconciliationScopeSchema;
 var init_temporal = __esm({
@@ -18097,6 +18306,7 @@ var init_src = __esm({
     init_realtime();
     init_resources();
     init_run_diagnostics();
+    init_run_introspection();
     init_secrets();
     init_session_run_commands();
     init_runtimes();
@@ -18158,20 +18368,42 @@ var init_active_project = __esm({
 });
 
 // src/lib/config/path.ts
+import { createHash } from "crypto";
 import { homedir } from "os";
-import { join } from "path";
+import { join, normalize } from "path";
 function defaultConfigPath() {
   return process.env.AUTO_CLI_CONFIG ?? join(homedir(), ".auto", "config.yaml");
 }
+function profilesDir(configPath = defaultConfigPath()) {
+  return normalize(join(configPath, "..", PROFILES_DIR_NAME));
+}
+function profileFileName(input) {
+  const key = `${input.userEmail.toLowerCase()}
+${serverHost(input.serverUrl)}`;
+  const hash2 = createHash("sha256").update(key).digest("hex").slice(0, 8);
+  return `${slug(input.userEmail)}--${slug(serverHost(input.serverUrl))}-${hash2}.yaml`;
+}
+function serverHost(serverUrl) {
+  try {
+    return new URL(serverUrl).host;
+  } catch {
+    return serverUrl;
+  }
+}
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "_");
+}
+var PROFILES_DIR_NAME;
 var init_path = __esm({
   "src/lib/config/path.ts"() {
     "use strict";
+    PROFILES_DIR_NAME = "profiles";
   }
 });
 
 // src/lib/config/file.ts
 import { chmodSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { basename, dirname as dirname2, join as join2 } from "path";
 function readConfig(path = defaultConfigPath()) {
   try {
     const text = readFileSync2(path, "utf8");
@@ -18179,21 +18411,8 @@ function readConfig(path = defaultConfigPath()) {
     for (const line of text.split(/\r?\n/)) {
       const match = /^([A-Za-z0-9_]+):\s*(.*)$/.exec(line.trim());
       if (!match) continue;
-      const value = match[2] ?? "";
-      if (match[1] === "serverUrl") config2.serverUrl = value;
-      if (match[1] === "organizationId") config2.organizationId = value;
-      if (match[1] === "projectId") config2.projectId = value;
-      if (match[1] === "refreshToken") config2.refreshToken = value;
-      if (match[1] === "accessToken") config2.accessToken = value;
-      if (match[1] === "accessTokenExpiresAt") {
-        config2.accessTokenExpiresAt = value;
-      }
-      if (match[1] === "accessTokenOrganizationId") {
-        config2.accessTokenOrganizationId = value;
-      }
-      if (match[1] === "accessTokenProjectId") {
-        config2.accessTokenProjectId = value;
-      }
+      const key = CONFIG_KEYS.find((candidate) => candidate === match[1]);
+      if (key) config2[key] = match[2] ?? "";
     }
     return config2;
   } catch (err) {
@@ -18202,17 +18421,26 @@ function readConfig(path = defaultConfigPath()) {
   }
 }
 function writeConfig(config2, path = defaultConfigPath()) {
+  writeConfigFile(config2, path);
+  if (config2.userEmail && config2.serverUrl && basename(dirname2(path)) !== PROFILES_DIR_NAME) {
+    writeConfigFile(
+      config2,
+      join2(
+        dirname2(path),
+        PROFILES_DIR_NAME,
+        profileFileName({
+          userEmail: config2.userEmail,
+          serverUrl: config2.serverUrl
+        })
+      )
+    );
+  }
+}
+function writeConfigFile(config2, path) {
   mkdirSync2(dirname2(path), { recursive: true });
-  const lines = [
-    ["serverUrl", config2.serverUrl],
-    ["organizationId", config2.organizationId],
-    ["projectId", config2.projectId],
-    ["refreshToken", config2.refreshToken],
-    ["accessToken", config2.accessToken],
-    ["accessTokenExpiresAt", config2.accessTokenExpiresAt],
-    ["accessTokenOrganizationId", config2.accessTokenOrganizationId],
-    ["accessTokenProjectId", config2.accessTokenProjectId]
-  ].filter(([, value]) => value).map(([key, value]) => `${key}: ${value}`);
+  const lines = CONFIG_KEYS.filter((key) => config2[key]).map(
+    (key) => `${key}: ${config2[key]}`
+  );
   writeFileSync2(path, `${lines.join("\n")}
 `, {
     encoding: "utf8",
@@ -18220,10 +18448,23 @@ function writeConfig(config2, path = defaultConfigPath()) {
   });
   chmodSync(path, 384);
 }
+var CONFIG_KEYS;
 var init_file = __esm({
   "src/lib/config/file.ts"() {
     "use strict";
     init_path();
+    CONFIG_KEYS = [
+      "serverUrl",
+      "userId",
+      "userEmail",
+      "organizationId",
+      "projectId",
+      "refreshToken",
+      "accessToken",
+      "accessTokenExpiresAt",
+      "accessTokenOrganizationId",
+      "accessTokenProjectId"
+    ];
   }
 });
 
@@ -18957,8 +19198,9 @@ function createApiClient(input) {
   }
   async function requestJson(path, options = {}) {
     const url2 = new URL(apiUrl(path, options.apiBaseUrl));
-    for (const [name, value] of Object.entries(options.searchParams ?? {})) {
-      url2.searchParams.set(name, value);
+    const searchParamEntries = Array.isArray(options.searchParams) ? options.searchParams : Object.entries(options.searchParams ?? {});
+    for (const [name, value] of searchParamEntries) {
+      url2.searchParams.append(name, value);
     }
     const response = await authenticatedFetch(
       url2.toString(),
@@ -19692,21 +19934,101 @@ function createApiClient(input) {
       }
       return await response.json();
     },
-    async listSessionRuns(sessionName, options = {}) {
-      const scope = activeProject();
+    async listSessionRuns(sessionName, options = {}) {
+      const scope = activeProject();
+      return requestJson(
+        sessionApiPath(scope, sessionName, "/runs"),
+        {
+          apiBaseUrl: options.apiBaseUrl,
+          searchParams: runListSearchParams(options)
+        }
+      );
+    },
+    async listRuns(options = {}) {
+      const scope = activeProject();
+      return requestJson(projectApiPath(scope, "/runs"), {
+        apiBaseUrl: options.apiBaseUrl,
+        searchParams: runListSearchParams(options)
+      });
+    },
+    async getRunSummary(runId, options = {}) {
+      return requestJson(runApiPath(runId, "/summary"), {
+        apiBaseUrl: options.apiBaseUrl
+      });
+    },
+    async getRunConversation(runId, options = {}) {
+      const searchParams = [];
+      if (options.cursor) searchParams.push(["cursor", options.cursor]);
+      if (options.before !== void 0)
+        searchParams.push(["before", String(options.before)]);
+      if (options.limit !== void 0)
+        searchParams.push(["limit", String(options.limit)]);
+      if (options.order) searchParams.push(["order", options.order]);
+      for (const kind of options.kinds ?? []) searchParams.push(["kind", kind]);
+      for (const role of options.roles ?? []) searchParams.push(["role", role]);
+      return requestJson(
+        runApiPath(runId, "/conversation"),
+        {
+          apiBaseUrl: options.apiBaseUrl,
+          searchParams
+        }
+      );
+    },
+    async searchRunConversation(runId, queries, options = {}) {
+      const searchParams = queries.map((query) => [
+        "q",
+        query
+      ]);
+      if (options.after !== void 0)
+        searchParams.push(["after", String(options.after)]);
+      for (const kind of options.kinds ?? []) searchParams.push(["kind", kind]);
+      for (const role of options.roles ?? []) searchParams.push(["role", role]);
+      if (options.limit !== void 0)
+        searchParams.push(["limit", String(options.limit)]);
+      return requestJson(
+        runApiPath(runId, "/conversation/search"),
+        {
+          apiBaseUrl: options.apiBaseUrl,
+          searchParams
+        }
+      );
+    },
+    async listRunToolExchanges(runId, options = {}) {
+      const searchParams = [];
+      if (options.toolName) searchParams.push(["toolName", options.toolName]);
+      if (options.errorsOnly) searchParams.push(["errorsOnly", "true"]);
+      if (options.after !== void 0)
+        searchParams.push(["after", String(options.after)]);
+      if (options.before !== void 0)
+        searchParams.push(["before", String(options.before)]);
+      if (options.order) searchParams.push(["order", options.order]);
+      if (options.limit !== void 0)
+        searchParams.push(["limit", String(options.limit)]);
+      return requestJson(
+        runApiPath(runId, "/tools"),
+        {
+          apiBaseUrl: options.apiBaseUrl,
+          searchParams
+        }
+      );
+    },
+    async listRunTriggers(runId, options = {}) {
+      return requestJson(runApiPath(runId, "/triggers"), {
+        apiBaseUrl: options.apiBaseUrl,
+        searchParams: options.payload ? { payload: options.payload } : void 0
+      });
+    },
+    async listRunArtifacts(runId, options = {}) {
       return requestJson(
-        sessionApiPath(scope, sessionName, "/runs"),
+        runApiPath(runId, "/artifacts"),
         {
-          apiBaseUrl: options.apiBaseUrl,
-          searchParams: options.includeArchived ? { include_archived: "true" } : void 0
+          apiBaseUrl: options.apiBaseUrl
         }
       );
     },
-    async listRuns(options = {}) {
-      const scope = activeProject();
-      return requestJson(projectApiPath(scope, "/runs"), {
-        apiBaseUrl: options.apiBaseUrl,
-        searchParams: options.includeArchived ? { include_archived: "true" } : void 0
+    async listRunCommands(runId, options = {}) {
+      return requestJson(runApiPath(runId, "/commands"), {
+        apiBaseUrl: options.apiBaseUrl
       });
     },
     getOperatorInfo() {
@@ -19766,6 +20088,22 @@ function createApiClient(input) {
     }
   };
 }
+function runListSearchParams(options) {
+  const searchParams = [];
+  if (options.includeArchived) {
+    searchParams.push(["include_archived", "true"]);
+  }
+  for (const status of options.statuses ?? []) {
+    searchParams.push(["status", status]);
+  }
+  if (options.since) {
+    searchParams.push(["created_after", options.since]);
+  }
+  if (options.limit !== void 0) {
+    searchParams.push(["limit", String(options.limit)]);
+  }
+  return searchParams;
+}
 var init_client = __esm({
   "src/lib/api/client.ts"() {
     "use strict";
@@ -20213,7 +20551,7 @@ var init_connect = __esm({
 });
 
 // src/commands/apply/files.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import {
   readFileSync as readFileSync3,
   readdirSync,
@@ -20221,11 +20559,11 @@ import {
   statSync
 } from "fs";
 import {
-  basename,
+  basename as basename2,
   dirname as dirname3,
   extname,
   isAbsolute,
-  join as join2,
+  join as join3,
   resolve
 } from "path";
 import { parseAllDocuments as parseYamlDocuments } from "yaml";
@@ -20241,7 +20579,7 @@ function readProjectApplyRequest(options) {
     );
     return { ...request, assets: assets2 };
   }
-  const directory = options.directory ?? join2(process.cwd(), ".auto");
+  const directory = options.directory ?? join3(process.cwd(), ".auto");
   const files = applyFiles(directory);
   if (files.length === 0) {
     throw new Error(`No resource files found in ${directory}`);
@@ -20304,7 +20642,7 @@ function applyFiles(root) {
   const files = [];
   for (const kind of APPLY_RESOURCE_ORDER) {
     const directory = APPLY_DIRECTORIES[kind];
-    const path = join2(root, directory);
+    const path = join3(root, directory);
     let entries;
     try {
       entries = readdirSync(path, { withFileTypes: true });
@@ -20378,7 +20716,7 @@ function readApplyAssets(resources, projectRoot) {
     });
     const bytes = readFileSync3(resolvedPath);
     assets[avatarAsset] = {
-      sha256: createHash("sha256").update(bytes).digest("hex"),
+      sha256: createHash2("sha256").update(bytes).digest("hex"),
       contentType: extname(resolvedPath).toLowerCase() === ".png" ? "image/png" : "image/jpeg",
       dataBase64: bytes.toString("base64")
     };
@@ -20442,12 +20780,12 @@ function validateSessionAvatarAsset(input) {
 }
 function applyProjectRoot(directory) {
   const resolved = resolve(directory);
-  return basename(resolved) === ".auto" ? dirname3(resolved) : resolved;
+  return basename2(resolved) === ".auto" ? dirname3(resolved) : resolved;
 }
 function applyFileProjectRoot(file2) {
   let dir = dirname3(resolve(file2));
   while (true) {
-    if (basename(dir) === ".auto") {
+    if (basename2(dir) === ".auto") {
       return dirname3(dir);
     }
     const parent = dirname3(dir);
@@ -20484,7 +20822,7 @@ function isRecord(value) {
 function resourceApplyFiles(directory, entries) {
   const files = [];
   for (const entry of entries) {
-    const path = join2(directory, entry.name);
+    const path = join3(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(
         ...resourceApplyFiles(path, readdirSync(path, { withFileTypes: true }))
@@ -20633,13 +20971,49 @@ var init_actions = __esm({
   }
 });
 
+// src/lib/config/profiles.ts
+import { readdirSync as readdirSync2 } from "fs";
+import { join as join4 } from "path";
+function listProfiles(configPath = defaultConfigPath()) {
+  const dir = profilesDir(configPath);
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  return entries.filter((entry) => entry.endsWith(".yaml")).sort().map((entry) => {
+    const path = join4(dir, entry);
+    return { path, config: readConfig(path) };
+  }).filter((profile) => profile.config.userEmail);
+}
+function findAccountProfile(input) {
+  const candidates = listProfiles(input.configPath).map((profile) => profile.config).filter((config2) => config2.serverUrl === input.serverUrl);
+  return candidates.find(
+    (config2) => input.userId && config2.userId === input.userId
+  ) ?? // Email is only a fallback for when a user id is missing on either side;
+  // it must never override a known user-id mismatch (emails can be
+  // reassigned to a different user).
+  candidates.find(
+    (config2) => input.userEmail && config2.userEmail?.toLowerCase() === input.userEmail.toLowerCase() && !(input.userId && config2.userId && config2.userId !== input.userId)
+  );
+}
+var init_profiles2 = __esm({
+  "src/lib/config/profiles.ts"() {
+    "use strict";
+    init_file();
+    init_path();
+  }
+});
+
 // src/commands/auth/pkce.ts
-import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
 function pkceVerifier() {
   return randomBytes2(32).toString("base64url");
 }
 function pkceChallenge(verifier) {
-  return createHash2("sha256").update(verifier).digest("base64url");
+  return createHash3("sha256").update(verifier).digest("base64url");
 }
 var init_pkce = __esm({
   "src/commands/auth/pkce.ts"() {
@@ -20650,7 +21024,6 @@ var init_pkce = __esm({
 // src/commands/auth/login.ts
 async function login(input) {
   const serverUrl = resolveApiBaseUrl({ explicit: input.options.apiUrl });
-  const previous = readConfig(input.configPath);
   if (input.options.device) {
     const device = await postJson(
       input.fetch,
@@ -20668,194 +21041,158 @@ async function login(input) {
         await sleep(Math.max(0, device.interval) * 1e3);
       }
       firstAttempt = false;
+      let token3;
       try {
-        const token2 = await postJson(
+        token3 = await postJson(
           input.fetch,
           `${serverUrl}/api/v1/auth/cli/token`,
           {
             grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-            device_code: device.device_code,
-            ...previous.organizationId && previous.projectId ? {
-              organization_id: previous.organizationId,
-              project_id: previous.projectId
-            } : {}
+            device_code: device.device_code
           }
         );
-        writeConfig(
-          {
-            ...previous,
-            serverUrl,
-            refreshToken: token2.refresh_token,
-            accessToken: token2.access_token,
-            accessTokenExpiresAt: token2.access_token ? accessTokenExpiresAt(token2) : void 0,
-            accessTokenOrganizationId: token2.access_token ? previous.organizationId : void 0,
-            accessTokenProjectId: token2.access_token ? previous.projectId : void 0
-          },
-          input.configPath
-        );
-        input.writeOutput("Logged in.");
-        return;
       } catch (error51) {
         if (error51 instanceof Error && error51.message === "authorization_pending") {
           continue;
         }
         throw error51;
       }
+      await finishLogin({
+        token: token3,
+        serverUrl,
+        fetch: input.fetch,
+        configPath: input.configPath,
+        writeOutput: input.writeOutput
+      });
+      return;
     }
     throw new Error("Device authorization expired before approval.");
   }
   const verifier = input.options.verifier ?? pkceVerifier();
   if (!input.options.code) {
-    const selectionDetails = await resolveLoginSelectionDetails({
-      configPath: input.configPath,
-      env: input.env ?? process.env,
-      fetch: input.fetch,
-      serverUrl,
-      previous,
-      writeError: input.writeError ?? (() => {
-      })
-    });
     const callback = await createOAuthLoopbackCallback({
-      successHtml: (result) => renderOAuthLoopbackPage({
+      successHtml: () => renderOAuthLoopbackPage({
         status: "success",
         eyebrow: "Auto CLI",
         title: "Login authorized",
         message: "Auto received the browser authorization. The CLI will finish signing you in from your terminal.",
-        details: [
-          { label: "Server", value: serverUrl },
-          {
-            label: "Organization",
-            value: result.organizationName ?? selectionDetails.organization
-          },
-          {
-            label: "Project",
-            value: result.projectName ?? selectionDetails.project
-          }
-        ]
+        details: [{ label: "Server", value: serverUrl }]
       }),
       failureHtml: () => renderOAuthLoopbackPage({
         status: "failure",
         eyebrow: "Auto CLI",
         title: "Login failed",
         message: "The browser authorization did not complete. Return to your terminal to retry or inspect the error.",
-        details: [
-          { label: "Server", value: serverUrl },
-          { label: "Organization", value: selectionDetails.organization },
-          { label: "Project", value: selectionDetails.project }
-        ]
+        details: [{ label: "Server", value: serverUrl }]
       })
     });
     try {
       const authorizeUrl = new URL("/auth/cli", serverUrl);
       authorizeUrl.searchParams.set("pkce_challenge", pkceChallenge(verifier));
       authorizeUrl.searchParams.set("redirect_uri", callback.redirectUri);
-      if (previous.organizationId && previous.projectId) {
-        authorizeUrl.searchParams.set(
-          "organization_id",
-          previous.organizationId
-        );
-        authorizeUrl.searchParams.set("project_id", previous.projectId);
-      }
       input.writeOutput(`Opening ${authorizeUrl.toString()}`);
       input.writeOutput("Waiting for browser authorization...");
       openBrowser(authorizeUrl.toString());
       const { code } = await callback.result;
-      await exchangeCode({
+      const token3 = await exchangeAuthorizationCode({
         code,
-        configPath: input.configPath,
         fetch: input.fetch,
-        previous,
         redirectUri: callback.redirectUri,
         serverUrl,
         verifier
       });
-      input.writeOutput("Logged in.");
+      await finishLogin({
+        token: token3,
+        serverUrl,
+        fetch: input.fetch,
+        configPath: input.configPath,
+        writeOutput: input.writeOutput
+      });
       return;
     } finally {
       callback.close();
     }
   }
-  await exchangeCode({
+  const token2 = await exchangeAuthorizationCode({
     code: input.options.code,
-    configPath: input.configPath,
     fetch: input.fetch,
-    previous,
     redirectUri: "http://127.0.0.1/callback",
     serverUrl,
     verifier
   });
-  input.writeOutput("Logged in.");
+  await finishLogin({
+    token: token2,
+    serverUrl,
+    fetch: input.fetch,
+    configPath: input.configPath,
+    writeOutput: input.writeOutput
+  });
 }
-async function exchangeCode(input) {
-  const token2 = await postJson(
+async function exchangeAuthorizationCode(input) {
+  return postJson(
     input.fetch,
     `${input.serverUrl}/api/v1/auth/cli/token`,
     {
       grant_type: "authorization_code",
       code: input.code,
       code_verifier: input.verifier,
-      redirect_uri: input.redirectUri,
-      ...input.previous.organizationId && input.previous.projectId ? {
-        organization_id: input.previous.organizationId,
-        project_id: input.previous.projectId
-      } : {}
+      redirect_uri: input.redirectUri
     }
   );
-  writeConfig(
-    {
-      ...input.previous,
-      serverUrl: input.serverUrl,
-      refreshToken: token2.refresh_token,
-      accessToken: token2.access_token,
-      accessTokenExpiresAt: token2.access_token ? accessTokenExpiresAt(token2) : void 0,
-      accessTokenOrganizationId: token2.access_token ? input.previous.organizationId : void 0,
-      accessTokenProjectId: token2.access_token ? input.previous.projectId : void 0
-    },
-    input.configPath
-  );
 }
-async function resolveLoginSelectionDetails(input) {
-  const fallback = {
-    organization: input.previous.organizationId,
-    project: input.previous.projectId
-  };
-  if (!input.previous.organizationId) {
-    return fallback;
-  }
-  const client = createApiClient({
+async function finishLogin(input) {
+  const { token: token2, serverUrl } = input;
+  const previous = readConfig(input.configPath);
+  const profile = token2.user ? findAccountProfile({
     configPath: input.configPath,
-    env: input.env,
-    fetch: input.fetch,
-    writeError: input.writeError
-  });
-  try {
-    if (input.previous.projectId) {
-      const projects = await client.listProjects({
-        apiBaseUrl: input.serverUrl
-      });
-      const project = projects.projects.find(
-        (candidate) => candidate.organizationId === input.previous.organizationId && candidate.projectId === input.previous.projectId
+    serverUrl,
+    userId: token2.user.id,
+    userEmail: token2.user.email
+  }) : void 0;
+  const selectionSource = profile ?? previous;
+  const selection = selectionSource.organizationId && selectionSource.projectId ? {
+    organizationId: selectionSource.organizationId,
+    projectId: selectionSource.projectId
+  } : void 0;
+  let config2 = {
+    serverUrl,
+    userId: token2.user?.id,
+    userEmail: token2.user?.email,
+    refreshToken: token2.refresh_token,
+    accessToken: token2.access_token,
+    accessTokenExpiresAt: token2.access_token ? accessTokenExpiresAt(token2) : void 0
+  };
+  if (selection) {
+    try {
+      const scoped = await postJson(
+        input.fetch,
+        `${serverUrl}/api/v1/auth/cli/token`,
+        {
+          grant_type: "refresh_token",
+          refresh_token: token2.refresh_token,
+          organization_id: selection.organizationId,
+          project_id: selection.projectId
+        }
+      );
+      config2 = {
+        ...config2,
+        ...selection,
+        refreshToken: scoped.refresh_token,
+        accessToken: scoped.access_token,
+        accessTokenExpiresAt: scoped.access_token ? accessTokenExpiresAt(scoped) : void 0,
+        accessTokenOrganizationId: scoped.access_token ? selection.organizationId : void 0,
+        accessTokenProjectId: scoped.access_token ? selection.projectId : void 0
+      };
+    } catch {
+      input.writeOutput(
+        "The saved organization/project selection is not available for this account; run `auto orgs list` to pick a new one."
       );
-      if (project) {
-        return {
-          organization: project.organizationName,
-          project: project.projectName
-        };
-      }
     }
-    const organizations = await client.listOrganizations({
-      apiBaseUrl: input.serverUrl
-    });
-    const organization = organizations.organizations.find(
-      (candidate) => candidate.organizationId === input.previous.organizationId
-    );
-    return {
-      organization: organization?.organizationName ?? fallback.organization,
-      project: fallback.project
-    };
-  } catch {
-    return fallback;
   }
+  writeConfig(config2, input.configPath);
+  input.writeOutput(
+    token2.user ? `Logged in as ${token2.user.email}.` : "Logged in."
+  );
 }
 async function sleep(ms) {
   await new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -20864,11 +21201,11 @@ var init_login = __esm({
   "src/commands/auth/login.ts"() {
     "use strict";
     init_base_url();
-    init_client();
     init_http();
     init_tokens();
     init_browser();
     init_file();
+    init_profiles2();
     init_loopback();
     init_pkce();
   }
@@ -20878,7 +21215,7 @@ var init_login = __esm({
 import { spawn as spawn2 } from "child_process";
 import { mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 import { parseAllDocuments as parseYamlDocuments2, stringify as stringify2 } from "yaml";
 async function editResource(input) {
   const reference = parseEditableResource(input.resource);
@@ -20893,8 +21230,8 @@ async function editResource(input) {
   const document = editableResourceDocument(reference.kind, current);
   const source = `${stringify2(document).trimEnd()}
 `;
-  const tempRoot = mkdtempSync(join3(tmpdir(), "auto-edit-"));
-  const filePath = join3(tempRoot, `${reference.kind}-${reference.name}.yaml`);
+  const tempRoot = mkdtempSync(join5(tmpdir(), "auto-edit-"));
+  const filePath = join5(tempRoot, `${reference.kind}-${reference.name}.yaml`);
   writeFileSync3(filePath, source, "utf8");
   let removeTempFile = false;
   try {
@@ -21153,7 +21490,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.87",
+      version: "0.1.89",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -23836,7 +24173,10 @@ function sessionRunsQueryOptions(client, sessionName, apiUrl, includeArchived =
     queryFn: async () => {
       const res = await client.listSessionRuns(sessionName ?? "", {
         apiBaseUrl: apiUrl,
-        includeArchived
+        includeArchived,
+        // The run-list routes default to 50; ask for the server max so the
+        // TUI keeps showing deep history.
+        limit: TUI_RUN_LIST_LIMIT
       });
       return res.runs;
     },
@@ -23850,7 +24190,8 @@ function runsQueryOptions(client, apiUrl, includeArchived = false) {
     queryFn: async () => {
       const res = await client.listRuns({
         apiBaseUrl: apiUrl,
-        includeArchived
+        includeArchived,
+        limit: TUI_RUN_LIST_LIMIT
       });
       return res.runs;
     },
@@ -23966,12 +24307,13 @@ function invalidateRunsQueries(queryClient, apiUrl, runs) {
     });
   }
 }
-var queryKeys, RUNS_REFETCH_INTERVAL_MS;
+var TUI_RUN_LIST_LIMIT, queryKeys, RUNS_REFETCH_INTERVAL_MS;
 var init_queries = __esm({
   "src/tui/hooks/queries.ts"() {
     "use strict";
     init_src();
     init_ApiClientContext();
+    TUI_RUN_LIST_LIMIT = 200;
     queryKeys = {
       environments: (apiUrl) => ["environments", apiUrl],
       profiles: (apiUrl) => ["profiles", apiUrl],
@@ -24329,7 +24671,7 @@ var init_SessionsView = __esm({
 
 // src/tui/SpecInspector.tsx
 import { Box as Box12, Text as Text13 } from "ink";
-import { stringify as stringify3 } from "yaml";
+import { stringify as stringify4 } from "yaml";
 import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 function SpecInspector({
   kind,
@@ -24360,7 +24702,7 @@ function specLineCount(spec) {
   return yamlLines(spec).length;
 }
 function yamlLines(spec) {
-  return stringify3(spec).trimEnd().split("\n");
+  return stringify4(spec).trimEnd().split("\n");
 }
 function YamlLine({ line }) {
   const match = /^(\s*)([^:#][^:]*:)(.*)$/.exec(line);
@@ -28006,6 +28348,7 @@ init_login();
 
 // src/commands/auth/profile.ts
 init_file();
+init_profiles2();
 async function handleAuthStatus(context) {
   const result = await fetchAuthStatus(context);
   context.io.writeResult(result, formatAuthStatusText);
@@ -28030,12 +28373,58 @@ function logout(context) {
   );
   context.writeOutput("Logged out.");
 }
+function switchAccount(context, accountEmail, options = {}) {
+  const profiles = listProfiles(context.configPath);
+  if (profiles.length === 0) {
+    throw new Error("No stored accounts. Run `auto auth login` first.");
+  }
+  const active = readConfig(context.configPath);
+  if (!accountEmail) {
+    for (const profile of profiles) {
+      context.writeOutput(accountLine(profile.config, active));
+    }
+    return;
+  }
+  const matches = profiles.map((profile) => profile.config).filter(
+    (config2) => config2.userEmail?.toLowerCase() === accountEmail.toLowerCase() && (!options.server || config2.serverUrl === options.server)
+  );
+  if (matches.length === 0) {
+    throw new Error(
+      `No stored account for ${accountEmail}. Run \`auto auth login\` to add it.`
+    );
+  }
+  const match = matches.length === 1 ? matches[0] : matches.find((config2) => config2.serverUrl === active.serverUrl);
+  if (!match) {
+    throw new Error(
+      `Multiple servers have a stored account for ${accountEmail}: ${matches.map((config2) => config2.serverUrl).join(
+        ", "
+      )}. Pick one with \`auto auth switch ${accountEmail} --server <url>\`.`
+    );
+  }
+  writeConfig(match, context.configPath);
+  context.writeOutput(`Switched to ${match.userEmail} (${match.serverUrl}).`);
+  if (!match.refreshToken) {
+    context.writeOutput(
+      "This account has no stored credentials; run `auto auth login`."
+    );
+  }
+}
+function accountLine(config2, active) {
+  const isActive = Boolean(config2.userEmail) && config2.userEmail === active.userEmail && config2.serverUrl === active.serverUrl;
+  return [
+    config2.userEmail,
+    `server=${config2.serverUrl ?? "(unset)"}`,
+    config2.refreshToken ? void 0 : "logged_out",
+    isActive ? "(active)" : void 0
+  ].filter(Boolean).join(" ");
+}
 async function fetchAuthStatus(context) {
   const config2 = readConfig(context.configPath);
   const client = createContextApiClient(context);
   const operator = client.getOperatorInfo();
   const base = {
     serverUrl: config2.serverUrl ?? context.env.AUTO_API_BASE_URL ?? null,
+    account: config2.userEmail ?? null,
     organizationId: config2.organizationId ?? null,
     projectId: config2.projectId ?? null,
     authSource: operator.authType
@@ -28077,6 +28466,9 @@ async function fetchAuthStatus(context) {
 }
 function formatAuthStatusText(result, writeLine) {
   writeLine(`server: ${result.serverUrl ?? "(unset)"}`);
+  if (result.account) {
+    writeLine(`account: ${result.account}`);
+  }
   writeLine(`organization: ${result.organizationId ?? "(unset)"}`);
   writeLine(`project: ${result.projectId ?? "(unset)"}`);
   writeLine(
@@ -28189,6 +28581,11 @@ function registerAuthCommands(program, context) {
     await handleWhoami(context);
   });
   auth.command("logout").description("Remove the local user refresh token.").action(() => logout(context));
+  auth.command("switch").description(
+    "Switch the active account to a stored profile, or list stored accounts."
+  ).argument("[email]", "Email of a stored account").option("--server <url>", "Auto web server URL of the stored account").action(
+    (email3, options) => switchAccount(context, email3, options)
+  );
 }
 
 // src/lib/stdio/readline.ts
@@ -30339,26 +30736,292 @@ function validateNonNegativeInteger(value, label) {
   }
 }
 
+// src/commands/runs/introspect.ts
+var PREVIEW_CHARS = 160;
+async function handleRunsShow(context, runId, options = {}) {
+  const client = createContextApiClient(context);
+  const apiBaseUrl = apiUrlFromOptions(context, options);
+  const [run, summary] = await Promise.all([
+    client.getRun(runId, { apiBaseUrl }),
+    client.getRunSummary(runId, { apiBaseUrl })
+  ]);
+  context.io.writeResult({ run, summary }, formatRunShowText);
+}
+function formatRunShowText(result, writeLine) {
+  const { summary } = result;
+  writeLine(
+    `${summary.run.id} ${summary.run.status} session=${summary.run.sessionName} profile=${summary.run.profileName}`
+  );
+  if (summary.run.displayTitle) {
+    writeLine(`title: ${summary.run.displayTitle}`);
+  }
+  writeLine(
+    `created=${summary.run.createdAt} started=${summary.run.startedAt ?? "-"} finished=${summary.run.finishedAt ?? "-"}`
+  );
+  writeLine(
+    `timing: queued=${formatMs(summary.timing.queuedMs)} active=${formatMs(summary.timing.activeMs)} total=${formatMs(summary.timing.totalMs)}`
+  );
+  writeLine(
+    `entries=${summary.conversation.entryCount} failed=${summary.conversation.failedEntryCount} turns=${summary.turns.length} lastSequence=${summary.conversation.lastSequence}`
+  );
+  writeLine(
+    `trigger: spawn=${summary.trigger.spawn} signaled=${summary.trigger.signaledCount} dropped=${summary.trigger.droppedCount}`
+  );
+  if (summary.artifacts.count > 0) {
+    writeLine(
+      `artifacts: ${summary.artifacts.count} (${summary.artifacts.types.join(", ")})`
+    );
+  }
+  writeLine(
+    `commands: ${summary.commands.total} failed=${summary.commands.failed}`
+  );
+  if (summary.tools.length > 0) {
+    writeLine("tools:");
+    for (const tool of summary.tools) {
+      writeLine(
+        `  ${tool.name} calls=${tool.calls} errors=${tool.errors} p50=${formatMs(tool.durationMs.p50)} max=${formatMs(tool.durationMs.max)}`
+      );
+    }
+  }
+  for (const check2 of summary.checks) {
+    writeLine(
+      `check: ${check2.name} ${check2.status}${check2.conclusion ? ` ${check2.conclusion}` : ""}`
+    );
+  }
+  if (summary.run.error !== null) {
+    writeLine(`error: ${JSON.stringify(summary.run.error)}`);
+  }
+}
+async function handleRunsConversation(context, runId, options = {}) {
+  const client = createContextApiClient(context);
+  const tailMode = !options.after;
+  const response = await client.getRunConversation(runId, {
+    apiBaseUrl: apiUrlFromOptions(context, options),
+    cursor: options.after,
+    before: options.before,
+    order: tailMode ? "desc" : "asc",
+    limit: options.tail ?? 25,
+    kinds: options.kind
+  });
+  const events = [...response.events].sort((a, b) => a.sequence - b.sequence);
+  context.io.writeResult(
+    {
+      runId,
+      events,
+      cursor: response.cursor,
+      hasMore: response.hasMore,
+      full: Boolean(options.full),
+      tailMode
+    },
+    formatConversationText
+  );
+}
+function formatConversationText(result, writeLine) {
+  if (result.events.length === 0) {
+    writeLine("No conversation entries.");
+    return;
+  }
+  for (const event of result.events) {
+    const failed = event.status === "failed" ? " FAILED" : "";
+    writeLine(
+      `${event.sequence} ${event.role}/${event.kind}${failed}: ${entryPreview(event, result.full)}`
+    );
+  }
+  if (result.hasMore) {
+    if (result.tailMode) {
+      const oldest = result.events[0]?.sequence;
+      writeLine(
+        `(more older entries; rerun with --before ${oldest ?? "<sequence>"})`
+      );
+    } else {
+      writeLine(`(more entries; continue with --after ${result.cursor})`);
+    }
+  }
+}
+async function handleRunsSearch(context, runId, queries, options = {}) {
+  const client = createContextApiClient(context);
+  const response = await client.searchRunConversation(runId, queries, {
+    apiBaseUrl: apiUrlFromOptions(context, options),
+    kinds: options.kind,
+    after: options.after,
+    limit: options.limit
+  });
+  context.io.writeResult({ runId, queries, ...response }, formatSearchText);
+}
+function formatSearchText(result, writeLine) {
+  if (result.matches.length === 0) {
+    writeLine(`No matches for: ${result.queries.join(", ")}`);
+    return;
+  }
+  for (const match of result.matches) {
+    for (const snippet of match.snippets) {
+      writeLine(
+        `${match.sequence} ${match.kind} [${snippet.query}]: ${singleLine(snippet.text)}`
+      );
+    }
+  }
+  if (result.hasMore) {
+    writeLine(
+      `(more scanned entries; continue with --after ${result.nextAfterSequence ?? "<sequence>"})`
+    );
+  }
+}
+async function handleRunsTools(context, runId, options = {}) {
+  const client = createContextApiClient(context);
+  const response = await client.listRunToolExchanges(runId, {
+    apiBaseUrl: apiUrlFromOptions(context, options),
+    toolName: options.tool,
+    errorsOnly: options.errors,
+    after: options.after,
+    before: options.before,
+    limit: options.limit
+  });
+  context.io.writeResult({ runId, ...response }, formatToolsText);
+}
+function formatToolsText(result, writeLine) {
+  if (result.exchanges.length === 0) {
+    writeLine("No tool exchanges.");
+    return;
+  }
+  for (const exchange of result.exchanges) {
+    const duration4 = exchange.durationMs === null ? "-" : `${exchange.durationMs}ms`;
+    const outcome = exchange.isError === null ? "pending" : exchange.isError ? "ERR" : "ok";
+    writeLine(
+      `${exchange.callSequence} ${exchange.name} ${duration4} ${outcome}: ${preview(exchange.input)}`
+    );
+  }
+  if (result.hasMore) {
+    writeLine(
+      `(more exchanges; page older with --before ${result.nextBeforeSequence ?? "<sequence>"})`
+    );
+  }
+}
+async function handleRunsTriggers(context, runId, options = {}) {
+  const client = createContextApiClient(context);
+  const response = await client.listRunTriggers(runId, {
+    apiBaseUrl: apiUrlFromOptions(context, options)
+  });
+  context.io.writeResult({ runId, ...response }, formatTriggersText);
+}
+function formatTriggersText(result, writeLine) {
+  if (result.spawn) {
+    writeLine(
+      `spawn: ${result.spawn.eventKey} (${result.spawn.originKind}) delivered=${result.spawn.deliveredAt}`
+    );
+  } else if (result.starter) {
+    writeLine(
+      `spawn: ${result.starter.principal.kind === "run" ? "agent" : "manual"} starter=${JSON.stringify(result.starter.principal)}`
+    );
+  } else {
+    writeLine("spawn: manual");
+  }
+  if (result.deliveries.length === 0) {
+    writeLine("No subsequent deliveries.");
+    return;
+  }
+  for (const delivery of result.deliveries) {
+    const reason = delivery.reason ? ` reason=${delivery.reason}` : "";
+    writeLine(
+      `${delivery.deliveredAt} ${delivery.action} ${delivery.eventKey}${reason}`
+    );
+  }
+}
+async function handleRunsArtifacts(context, runId, options = {}) {
+  const client = createContextApiClient(context);
+  const response = await client.listRunArtifacts(runId, {
+    apiBaseUrl: apiUrlFromOptions(context, options)
+  });
+  context.io.writeResult({ runId, ...response }, formatArtifactsText);
+}
+function formatArtifactsText(result, writeLine) {
+  if (result.artifacts.length === 0) {
+    writeLine("No artifacts currently owned.");
+    return;
+  }
+  for (const artifact of result.artifacts) {
+    writeLine(
+      `${artifact.artifactType} ${artifact.externalId} recorded=${artifact.recordedAt}`
+    );
+  }
+}
+async function handleRunsCommands(context, runId, options = {}) {
+  const client = createContextApiClient(context);
+  const response = await client.listRunCommands(runId, {
+    apiBaseUrl: apiUrlFromOptions(context, options)
+  });
+  context.io.writeResult({ runId, ...response }, formatCommandsText);
+}
+function formatCommandsText(result, writeLine) {
+  if (result.commands.length === 0) {
+    writeLine("No commands.");
+    return;
+  }
+  for (const command of result.commands) {
+    writeLine(
+      `${command.createdAt} ${command.kind} ${command.status} sender=${command.sender.type}: ${preview(command.payload)}`
+    );
+  }
+}
+function formatMs(value) {
+  return value === null ? "-" : `${value}ms`;
+}
+function entryPreview(event, full) {
+  const texts = event.content.parts.map((part) => {
+    switch (part.type) {
+      case "text":
+        return part.text;
+      case "tool_call":
+        return `${part.name} ${stringify3(part.input)}`;
+      case "tool_result":
+        return stringify3(part.output);
+      case "question":
+        return part.questions.map((question) => question.question).join(" ");
+      default:
+        return "";
+    }
+  });
+  const joined = singleLine(texts.join(" "));
+  return full ? joined : clip(joined);
+}
+function preview(value) {
+  return clip(singleLine(stringify3(value)));
+}
+function stringify3(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function singleLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function clip(text) {
+  return text.length > PREVIEW_CHARS ? `${text.slice(0, PREVIEW_CHARS)}\u2026` : text;
+}
+
 // src/commands/runs/list.ts
 async function handleRunsList(context, sessionName, options = {}) {
-  const result = await fetchSessionRuns(context, sessionName, options);
+  const result = await fetchRuns(context, sessionName, options);
   context.io.writeResult(result, formatRunsText);
 }
-async function fetchSessionRuns(context, sessionName, options) {
+async function fetchRuns(context, sessionName, options) {
   const client = createContextApiClient(context);
-  const response = await client.listSessionRuns(sessionName, {
+  const clientOptions = {
     apiBaseUrl: apiUrlFromOptions(context, options),
-    includeArchived: options.includeArchived
-  });
+    includeArchived: options.includeArchived,
+    statuses: options.status,
+    since: options.since,
+    limit: options.limit
+  };
+  const response = sessionName ? await client.listSessionRuns(sessionName, clientOptions) : await client.listRuns(clientOptions);
   return {
-    session: sessionName,
+    session: sessionName ?? null,
     runs: response.runs,
     includeArchived: Boolean(options.includeArchived)
   };
 }
 function formatRunsText(result, writeLine) {
   if (result.runs.length === 0) {
-    writeLine(`No runs found for session ${result.session}.`);
+    writeLine(
+      result.session ? `No runs found for session ${result.session}.` : "No runs found in the current project."
+    );
     return;
   }
   for (const run of result.runs) {
@@ -30368,13 +31031,63 @@ function formatRunsText(result, writeLine) {
 }
 
 // src/commands/runs/commands.ts
+function collect(value, previous = []) {
+  return [...previous, value];
+}
 function registerRunCommands(program, context) {
   const runs = program.command("runs").description("Inspect session runs.");
-  runs.command("list").description("List runs for a session.").requiredOption("--session <name>", "session name").option("--include-archived", "include archived runs").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(
-    async (options) => {
-      await handleRunsList(context, options.session, options);
+  runs.command("list").description("List runs for a session or the whole project.").option("--session <name>", "session name").option("--include-archived", "include archived runs").option("--status <status>", "filter by run status (repeatable)", collect).option("--since <iso-timestamp>", "only runs created after this time").option("--limit <count>", "maximum runs to return", parsePositiveInteger).option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (options) => {
+    await handleRunsList(context, options.session, options);
+  });
+  runs.command("show").description("Show a run's lifecycle, timing, and behavior summary.").argument("<run-id>", "run id").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (runId, commandOptions) => {
+    await handleRunsShow(context, runId, commandOptions);
+  });
+  runs.command("conversation").description(
+    "Read a snapshot of a run's conversation (most recent entries by default)."
+  ).argument("<run-id>", "run id").option(
+    "--tail <count>",
+    "number of most recent entries",
+    parsePositiveInteger
+  ).option("--after <cursor>", "read forward from an rt:<sequence> cursor").option(
+    "--before <sequence>",
+    "only entries older than this sequence (backward paging)",
+    parsePositiveInteger
+  ).option("--kind <kind>", "filter by entry kind (repeatable)", collect).option("--full", "do not clip entry previews in text output").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(
+    async (runId, commandOptions) => {
+      await handleRunsConversation(context, runId, commandOptions);
+    }
+  );
+  runs.command("search").description("Grep a run's transcript; multiple query terms OR together.").argument("<run-id>", "run id").argument("<query...>", "search term(s), at least 2 characters each").option("--kind <kind>", "filter by entry kind (repeatable)", collect).option(
+    "--after <sequence>",
+    "only entries after this sequence (forward paging)",
+    parsePositiveInteger
+  ).option("--limit <count>", "maximum matched entries", parsePositiveInteger).option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(
+    async (runId, queries, commandOptions) => {
+      await handleRunsSearch(context, runId, queries, commandOptions);
+    }
+  );
+  runs.command("tools").description("List a run's paired tool calls and results with timing.").argument("<run-id>", "run id").option("--tool <name>", "filter by tool name").option("--errors", "only failed exchanges").option(
+    "--after <sequence>",
+    "only exchanges after this entry sequence",
+    parsePositiveInteger
+  ).option(
+    "--before <sequence>",
+    "only exchanges before this entry sequence (backward paging)",
+    parsePositiveInteger
+  ).option("--limit <count>", "maximum exchanges", parsePositiveInteger).option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(
+    async (runId, commandOptions) => {
+      await handleRunsTools(context, runId, commandOptions);
     }
   );
+  runs.command("triggers").description("Show what spawned a run and the events delivered to it.").argument("<run-id>", "run id").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (runId, commandOptions) => {
+    await handleRunsTriggers(context, runId, commandOptions);
+  });
+  runs.command("artifacts").description("List artifacts a run currently owns.").argument("<run-id>", "run id").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (runId, commandOptions) => {
+    await handleRunsArtifacts(context, runId, commandOptions);
+  });
+  runs.command("commands").description("List a run's inbound command history.").argument("<run-id>", "run id").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (runId, commandOptions) => {
+    await handleRunsCommands(context, runId, commandOptions);
+  });
   runs.command("archive").description("Archive runs so they are hidden from default run lists.").argument("<run-ids...>", "run id(s)").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (runIds, commandOptions) => {
     if (runIds.length === 1) {
       await archiveRunAction(context, runIds[0], commandOptions);
@@ -30745,7 +31458,7 @@ init_resources2();
 init_browser();
 import { existsSync as existsSync2, mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var POLL_INTERVAL_MS = 2e3;
 var POLL_TIMEOUT_MS = 5 * 6e4;
 var SLACK_APPS_URL = "https://api.slack.com/apps";
@@ -30906,7 +31619,7 @@ async function promptForIconUploads(input, options) {
   }
 }
 function stagedLocationLabel(stagedPath) {
-  return stagedPath.startsWith(`${join4(homedir2(), "Downloads")}/`) ? "Downloads" : "the printed path";
+  return stagedPath.startsWith(`${join6(homedir2(), "Downloads")}/`) ? "Downloads" : "the printed path";
 }
 async function stageAvatarImage(input) {
   try {
@@ -30918,9 +31631,9 @@ async function stageAvatarImage(input) {
     }
     const contentType = response.headers.get("content-type") ?? "";
     const extension = contentType.includes("jpeg") ? ".jpg" : ".png";
-    const downloads = join4(homedir2(), "Downloads");
-    const directory = existsSync2(downloads) ? downloads : mkdtempSync2(join4(tmpdir2(), "auto-avatar-"));
-    const path = join4(directory, `${input.session}-avatar${extension}`);
+    const downloads = join6(homedir2(), "Downloads");
+    const directory = existsSync2(downloads) ? downloads : mkdtempSync2(join6(tmpdir2(), "auto-avatar-"));
+    const path = join6(directory, `${input.session}-avatar${extension}`);
     writeFileSync4(path, Buffer.from(await response.arrayBuffer()));
     return path;
   } catch {