@alan-ai-hq/agent-manager-darwin-arm64 0.1.158 → 0.1.160

package/alan-agent.cjs

@@ -22501,6 +22501,56 @@ var init_run_log_upload = __esm({
   }
 });
 
+// ../shared/dist/runtime-v2/run-media.js
+function runMediaPath(runId) {
+  return `/public/machines/me/runs/${encodeURIComponent(runId)}/media`;
+}
+function runMediaCompletePath(runId, mediaId) {
+  return `${runMediaPath(runId)}/${encodeURIComponent(mediaId)}/complete`;
+}
+var INT4_MAX, runMediaSourceSchema, runMediaUploadRequestSchema, runMediaUploadTargetSchema, runMediaUploadResponseSchema, runMediaCompleteResponseSchema;
+var init_run_media = __esm({
+  "../shared/dist/runtime-v2/run-media.js"() {
+    "use strict";
+    init_zod();
+    INT4_MAX = 2147483647;
+    runMediaSourceSchema = external_exports.enum(["generated_image", "session_media"]);
+    runMediaUploadRequestSchema = external_exports.object({
+      /** The `id` the transcript update carries; one upload per id and run. */
+      mediaId: external_exports.string().min(1).max(200),
+      source: runMediaSourceSchema,
+      kind: external_exports.enum(["image", "video"]),
+      mimeType: external_exports.string().min(1).max(200),
+      filename: external_exports.string().min(1).max(500),
+      bytes: external_exports.number().int().positive().max(INT4_MAX),
+      sha256: external_exports.string().regex(/^[0-9a-f]{64}$/),
+      width: external_exports.number().int().min(0).max(INT4_MAX).nullish(),
+      height: external_exports.number().int().min(0).max(INT4_MAX).nullish(),
+      toolId: external_exports.string().max(500).optional(),
+      sourcePath: external_exports.string().max(4096).optional(),
+      ts: external_exports.number().int().positive().optional()
+    });
+    runMediaUploadTargetSchema = external_exports.object({
+      url: external_exports.url(),
+      /** Every header the signed PUT expects, besides the body's `content-length`. */
+      headers: external_exports.record(external_exports.string(), external_exports.string()),
+      expiresAt: external_exports.iso.datetime()
+    });
+    runMediaUploadResponseSchema = external_exports.discriminatedUnion("status", [
+      external_exports.object({
+        status: external_exports.literal("upload"),
+        mediaId: external_exports.string(),
+        upload: runMediaUploadTargetSchema
+      }),
+      external_exports.object({ status: external_exports.literal("ready"), mediaId: external_exports.string() })
+    ]);
+    runMediaCompleteResponseSchema = external_exports.object({
+      status: external_exports.literal("ready"),
+      mediaId: external_exports.string()
+    });
+  }
+});
+
 // ../shared/dist/runtime-v2/skills.js
 var MACHINE_SKILLS_SYNC_PATH, MAX_MACHINE_SKILLS, installedMachineSkillSchema, MAX_SKILL_UPLOADS, machineSkillScanRepositorySchema, machineSkillScanContextSchema, machineLocalSkillsReportSchema, machineSkillUploadSchema, machineSkillsSyncRequestSchema, desiredMachineSkillSchema, machineSkillDownloadSchema, machineSkillsSyncResponseSchema;
 var init_skills = __esm({
@@ -22624,6 +22674,7 @@ var init_runtime_v2 = __esm({
     init_mcp();
     init_run_log();
     init_run_log_upload();
+    init_run_media();
     init_skills();
     init_workspace();
   }
@@ -25967,6 +26018,12 @@ var init_event = __esm({
 });
 
 // ../shared/dist/agent/acp/reduce.js
+function upsertMcpServers(current, reported) {
+  const byName = new Map((current ?? []).map((server) => [server.name, server]));
+  for (const server of reported)
+    byName.set(server.name, server);
+  return [...byName.values()];
+}
 function emptyTranscript() {
   return { entries: [], state: "idle", notices: [], unknown: [] };
 }
@@ -26123,6 +26180,12 @@ ${update.description}` : update.title,
       state.thinkingTokens = update.estimated;
       return;
     }
+    case "_alan/mcp_servers": {
+      if (!isUpdate(update, "_alan/mcp_servers"))
+        return;
+      state.mcpServers = upsertMcpServers(state.mcpServers, update.servers);
+      return;
+    }
     // Owned by the tool call that references it, but kept so a terminal-aware
     // renderer can still consume the raw update.
     case "terminal_update":
@@ -26436,17 +26499,20 @@ function stepSummary(node2) {
   const update = node2.event.update;
   const children = node2.children.map(stepSummary);
   if (update.sessionUpdate === "terminal_update") {
-    const { output: _output, ...rest2 } = update;
-    return { ...node2, event: { ...node2.event, update: rest2 }, children };
+    const { output: output2, ...rest2 } = update;
+    const omitted = output2 === void 0 ? {} : { outputTruncated: true };
+    return { ...node2, event: { ...node2.event, update: { ...rest2, ...omitted } }, children };
   }
   if (update.sessionUpdate !== "tool_call_update")
     return { ...node2, children };
   const inputRecord = toolInputRecord(update.rawInput);
   if (rendersBesideSteps(update, inputRecord))
     return { ...node2, children };
-  const { content, rawOutput: _rawOutput, rawInput, ...rest } = update;
+  const { content, rawOutput, rawInput, ...rest } = update;
   const input2 = stepInput(rawInput, inputRecord);
-  const diffs = (Array.isArray(content) ? content : []).map(diffWithoutText).filter((block2) => block2 !== null);
+  const blocks = Array.isArray(content) ? content : [];
+  const diffs = blocks.map(diffWithoutText).filter((block2) => block2 !== null);
+  const outputOmitted = rawOutput !== void 0 && rawOutput !== null && rawOutput !== "" || blocks.length > 0;
   return {
     ...node2,
     event: {
@@ -26455,6 +26521,7 @@ function stepSummary(node2) {
         ...rest,
         ...input2.value === void 0 ? {} : { rawInput: input2.value },
         ...input2.truncated ? { inputTruncated: true } : {},
+        ...outputOmitted ? { outputTruncated: true } : {},
         ...diffs.length > 0 ? { content: diffs } : {}
       }
     },
@@ -26771,9 +26838,14 @@ var init_session_activity = __esm({
 });
 
 // ../shared/dist/agent/acp/transcript-byte-decoder.js
+var MIN_ELIDED_DATA_BYTES, DATA_KEY, MEDIA_MARKERS;
 var init_transcript_byte_decoder = __esm({
   "../shared/dist/agent/acp/transcript-byte-decoder.js"() {
     "use strict";
+    init_types2();
+    MIN_ELIDED_DATA_BYTES = 16 * 1024;
+    DATA_KEY = new TextEncoder().encode('"data":"');
+    MEDIA_MARKERS = [...MEDIA_SESSION_UPDATE_KINDS].map((kind) => new TextEncoder().encode(JSON.stringify(kind)));
   }
 });
 
@@ -26933,6 +27005,8 @@ function mergeTranscriptMessages(messages, cache2) {
       merged.usage = state.usage;
     if (state.title)
       merged.title = state.title;
+    if (state.mcpServers)
+      merged.mcpServers = upsertMcpServers(merged.mcpServers, state.mcpServers);
     updateOffset += state.updateCount ?? 0;
   }
   merged.updateCount = updateOffset;
@@ -28023,7 +28097,7 @@ var init_chunk_ZCTKXKYY = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-FYZKVT3E.js
+// ../agent-core/dist/chunk-WD7O4DYQ.js
 function detectImageMimeType(buffer) {
   if (buffer.length >= 8 && buffer.subarray(0, 8).equals(PNG_SIGNATURE)) return "image/png";
   if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
@@ -28159,6 +28233,27 @@ function resultText2(update) {
   if (typeof raw === "string") return raw;
   return raw === void 0 ? "" : JSON.stringify(raw);
 }
+function mediaUpdate(file2, body) {
+  const fields = {
+    id: file2.mediaId,
+    filename: file2.filename,
+    mimeType: file2.mimeType,
+    size: file2.data.length,
+    ...body,
+    sourcePath: file2.sourcePath,
+    sourceHash: file2.sha256,
+    toolId: file2.toolId,
+    ts: file2.ts,
+    ...file2.width === void 0 ? {} : { width: file2.width },
+    ...file2.height === void 0 ? {} : { height: file2.height }
+  };
+  if (file2.source === "generated_image") {
+    const image = { type: "generated_image", ...fields };
+    return { sessionUpdate: "_alan/generated_image", image };
+  }
+  const media = { type: "session_media", kind: file2.kind, ...fields };
+  return { sessionUpdate: "_alan/session_media", media };
+}
 function updateRequiredMessage(requirement, found) {
   const { cli, minimumVersion, feature } = requirement;
   const installed = found ? `${cli} ${found}` : `The ${cli} CLI`;
@@ -28443,8 +28538,8 @@ function silentStartError(name, timeoutMs) {
   };
 }
 var import_crypto4, import_fs5, import_path4, PNG_SIGNATURE, IMAGE_MIME_BY_EXT, VIDEO_MIME_BY_EXT, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS, MAX_IMAGE_BYTES, MAX_VIDEO_BYTES, MAX_TURN_MEDIA_DATA_CHARS, MTIME_SLACK_MS, AGENT_BROWSER_MENTION, AGENT_BROWSER_CAPTURE_COMMAND, LocalMediaReader, SessionOpenRefusal, JsonRpcError, ACP_PROTOCOL_VERSION, ACP_ERROR, STDERR_TAIL_LINES, RESULT_EXIT_GRACE_MS, PerTurnSession;
-var init_chunk_FYZKVT3E = __esm({
-  "../agent-core/dist/chunk-FYZKVT3E.js"() {
+var init_chunk_WD7O4DYQ = __esm({
+  "../agent-core/dist/chunk-WD7O4DYQ.js"() {
     "use strict";
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
@@ -28486,8 +28581,12 @@ var init_chunk_FYZKVT3E = __esm({
         this.#cwd = cwd;
         this.#clock = clock;
       }
-      /** Updates to record after `update`; nothing for anything but a tool call, which is almost all. */
+      /** Updates to record after `update`, with the bytes inline; nothing for most updates. */
       read(update) {
+        return this.find(update).map((found) => this.inline(found));
+      }
+      /** The media files a completed tool call wrote; nothing for anything but a tool call. */
+      find(update) {
         if (!isUpdate(update, "tool_call_update")) return [];
         const toolCallId = update.toolCallId;
         if (update.name !== void 0 || update.rawInput !== void 0) {
@@ -28533,20 +28632,42 @@ var init_chunk_FYZKVT3E = __esm({
           named: /* @__PURE__ */ new Set([...capturePaths(tool, content, extensions, cwd), ...this.#pathHints])
         });
       }
-      #payloadFields(file2, toolId, explicit) {
-        const dataChars = base64Length(file2.buffer.length);
-        const inline = explicit || this.#mediaDataChars + dataChars <= MAX_TURN_MEDIA_DATA_CHARS;
+      /** The update carrying the file's bytes, unless the turn's budget is spent on media nobody asked for. */
+      inline(found) {
+        const { file: file2 } = found;
+        const dataChars = base64Length(file2.data.length);
+        const inline = found.explicit || this.#mediaDataChars + dataChars <= MAX_TURN_MEDIA_DATA_CHARS;
         if (inline) this.#mediaDataChars += dataChars;
+        return mediaUpdate(
+          file2,
+          inline ? { data: file2.data.toString("base64") } : { inlineDataOmitted: true }
+        );
+      }
+      /** Uploads the file and returns a reference to it; inline as `inline` does when the upload fails. */
+      async publish(found, uploader, signal) {
+        try {
+          await uploader.upload(found.file, signal);
+          return mediaUpdate(found.file, { uploaded: true });
+        } catch {
+          return this.inline(found);
+        }
+      }
+      #found(file2, toolId, source, kind, explicit) {
         return {
-          id: (0, import_crypto4.randomUUID)(),
-          filename: (0, import_path4.basename)(file2.path),
-          mimeType: file2.mimeType,
-          size: file2.buffer.length,
-          ...inline ? { data: file2.buffer.toString("base64") } : { inlineDataOmitted: true },
-          sourcePath: file2.path,
-          sourceHash: (0, import_crypto4.createHash)("sha256").update(file2.buffer).digest("hex"),
-          toolId,
-          ts: this.#clock.now()
+          explicit,
+          file: {
+            mediaId: (0, import_crypto4.randomUUID)(),
+            source,
+            kind,
+            mimeType: file2.mimeType,
+            filename: (0, import_path4.basename)(file2.path),
+            data: file2.buffer,
+            sha256: (0, import_crypto4.createHash)("sha256").update(file2.buffer).digest("hex"),
+            ...kind === "image" ? imageDimensions(file2.buffer, file2.mimeType) : {},
+            toolId,
+            sourcePath: file2.path,
+            ts: this.#clock.now()
+          }
         };
       }
       #generatedImages(toolId, tool, content) {
@@ -28555,14 +28676,7 @@ var init_chunk_FYZKVT3E = __esm({
           mimeByExt: IMAGE_MIME_BY_EXT,
           maxBytes: MAX_IMAGE_BYTES
         });
-        return files.map((file2) => {
-          const image = {
-            type: "generated_image",
-            ...this.#payloadFields(file2, toolId, true),
-            ...imageDimensions(file2.buffer, file2.mimeType)
-          };
-          return { sessionUpdate: "_alan/generated_image", image };
-        });
+        return files.map((file2) => this.#found(file2, toolId, "generated_image", "image", true));
       }
       #sessionMedia(toolId, tool, content) {
         const isVideo = isAgentBrowserMedia(tool, content, "video");
@@ -28577,13 +28691,7 @@ var init_chunk_FYZKVT3E = __esm({
         );
         return files.map((file2) => {
           this.#pathHints.delete(file2.path);
-          const media = {
-            type: "session_media",
-            kind,
-            ...this.#payloadFields(file2, toolId, explicit),
-            ...kind === "image" ? imageDimensions(file2.buffer, file2.mimeType) : {}
-          };
-          return { sessionUpdate: "_alan/session_media", media };
+          return this.#found(file2, toolId, "session_media", kind, explicit);
         });
       }
     };
@@ -29778,16 +29886,16 @@ function externalServerConfig(server) {
   };
 }
 function claudeMcpConfig(mcp) {
-  const mcpServers = /* @__PURE__ */ Object.create(null);
+  const mcpServers2 = /* @__PURE__ */ Object.create(null);
   for (const [name, server] of Object.entries(mcp.externalServers ?? {})) {
-    mcpServers[name] = externalServerConfig(server);
+    mcpServers2[name] = externalServerConfig(server);
   }
-  mcpServers.alan = {
+  mcpServers2.alan = {
     type: "http",
     url: mcp.alanMcpUrl,
     headers: managedMcpHeaders(mcp.identity)
   };
-  return { mcpServers };
+  return { mcpServers: mcpServers2 };
 }
 function carriesCredential(mcp) {
   return mcp.identity.scope === "conversation" && mcp.identity.authorization !== void 0;
@@ -30012,11 +30120,27 @@ function parseStreamEvent(event, state) {
 function stringList(value2) {
   return asArray(value2).map((item) => asString(item)).filter(Boolean);
 }
+function mcpServers(value2) {
+  const servers = [];
+  for (const item of asArray(value2)) {
+    const record2 = asRecord(item);
+    const name = asString(record2?.name);
+    if (!record2 || !name) continue;
+    const source = asString(record2.source);
+    servers.push({
+      name,
+      status: CLAUDE_MCP_STATUS[asString(record2.status)] ?? "unknown",
+      ...source ? { source } : {}
+    });
+  }
+  return servers;
+}
 function initUpdates(event, state) {
   const model = asString(event.model);
   if (model) state.model = model;
   const tools = stringList(event.tools);
   const slashCommands = stringList(event.slash_commands);
+  const servers = mcpServers(event.mcp_servers);
   return [
     {
       sessionUpdate: "_alan/log",
@@ -30030,7 +30154,8 @@ function initUpdates(event, state) {
         ...tools.length > 0 ? { [TOOLS_META]: tools } : {},
         ...slashCommands.length > 0 ? { [SLASH_COMMANDS_META]: slashCommands } : {}
       }
-    }
+    },
+    ...servers.length > 0 ? [{ sessionUpdate: "_alan/mcp_servers", servers }] : []
   ];
 }
 function thinkingTokens(event) {
@@ -30984,12 +31109,12 @@ function claudeTurnClosingUpdates(records, state) {
 function readClaudeTranscriptTurns(chunk, baseOffset, skipped) {
   return readTranscriptTurns(claudeTranscriptFile, chunk, baseOffset, skipped);
 }
-var import_crypto7, import_fs6, import_path6, import_crypto8, import_promises31, EDIT_TOOLS, ThoughtBlocks, UNDERSTOOD_SYSTEM_SUBTYPES, RATE_LIMIT_WARN_AT, CLAUDE_GRAMMAR_NAME, SUBAGENT_TOOL_NAMES, controlResponseSchema, STOPPED_STATUSES, TaskRecords, TERMINAL_BACKGROUND_STATUSES, NON_TERMINAL_BACKGROUND_STATUSES, ASYNC_LAUNCH_ACK, BackgroundTasks, FAILED_STATUSES, STOPPED_BY_USER_TEXT, ClaudeTurn, STDERR_TAIL_LINES2, MAX_EARLY_LINES, UNSUPPORTED_STOP, OUTPUT_CLOSED_REASON, ClaudeSession, DEFAULTS, READ_ONLY_DISALLOWED_TOOLS, DEFAULT_MCP_TIMEOUT_MS, SYNTHETIC_MODEL, INTERRUPT_MARKER, NON_PROMPT_PREFIXES, PRELUDE_TYPES, claudeTranscriptFile;
+var import_crypto7, import_fs6, import_path6, import_crypto8, import_promises31, EDIT_TOOLS, ThoughtBlocks, UNDERSTOOD_SYSTEM_SUBTYPES, CLAUDE_MCP_STATUS, RATE_LIMIT_WARN_AT, CLAUDE_GRAMMAR_NAME, SUBAGENT_TOOL_NAMES, controlResponseSchema, STOPPED_STATUSES, TaskRecords, TERMINAL_BACKGROUND_STATUSES, NON_TERMINAL_BACKGROUND_STATUSES, ASYNC_LAUNCH_ACK, BackgroundTasks, FAILED_STATUSES, STOPPED_BY_USER_TEXT, ClaudeTurn, STDERR_TAIL_LINES2, MAX_EARLY_LINES, UNSUPPORTED_STOP, OUTPUT_CLOSED_REASON, ClaudeSession, DEFAULTS, READ_ONLY_DISALLOWED_TOOLS, DEFAULT_MCP_TIMEOUT_MS, SYNTHETIC_MODEL, INTERRUPT_MARKER, NON_PROMPT_PREFIXES, PRELUDE_TYPES, claudeTranscriptFile;
 var init_claude = __esm({
   "../agent-core/dist/providers/claude.js"() {
     "use strict";
     init_chunk_D4TIXPWZ();
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -31053,6 +31178,13 @@ var init_claude = __esm({
       "status",
       "commands_changed"
     ]);
+    CLAUDE_MCP_STATUS = {
+      connected: "connected",
+      pending: "starting",
+      "needs-auth": "needs_auth",
+      failed: "failed",
+      disabled: "disabled"
+    };
     RATE_LIMIT_WARN_AT = 0.8;
     CLAUDE_GRAMMAR_NAME = "claude_cli";
     SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set(["agent", "task"]);
@@ -33840,12 +33972,12 @@ function codexTurnInput(run2, context) {
     ...images.length ? { imagePaths: images.map((image) => image.path) } : {}
   };
 }
-var import_fs7, import_path7, import_crypto9, import_crypto10, import_crypto11, import_crypto12, TokenRefresher, MCP_STARTUP_TIMEOUT_SEC, FIELD_TYPES, YES_NO, ACCEPT_DECLINE, MAX_INLINE_GENERATED_IMAGE_BYTES, PNG_SIGNATURE2, JPEG_NON_FRAME_MARKERS, IMAGE_GEN_CALL, PROMPT_LITERAL, RELOCATE_EVERY_MS, CodexImageGenerationFold, CodexRolloutImages, CodexRateLimits, USER_INPUT_METHOD, PERMISSIONS_METHOD, ELICITATION_METHOD, COMMAND_OR_FILE, LEGACY, DECISIONS, COORDINATION_TOOLS, SETTLED_AGENT, STATUS, CHANGE_OPERATIONS, SILENT_ON_START, IGNORED_ITEMS, PLAN_STATUS, WORKER_LIFECYCLE, INFO_KINDS, SILENT, CodexTurn, STDERR_TAIL_LINES3, MAX_BETWEEN_UPDATES, UNSUPPORTED_REQUEST, DECLINED_ELICITATION, IMAGE_CATCH_UP_MS, IMAGE_POLL_MS, CodexSession, CODEX_MIN_VERSION, CODEX_REQUIREMENT, CODEX_TESTED_LINE, DEFAULTS2, CLIENT_INFO, STATUS2, EXITED_WITHOUT_RESPONSE, CodexExecTurn, DEFAULTS22, CodexExecSession, INJECTED_USER_PREFIXES, SHELL_TOOL_NAMES, ANNOUNCING_ITEM_TYPES, OUTPUT_MARKER, OPEN_PAGE_ACTIONS, FIND_IN_PAGE_ACTIONS, FILE_OPERATIONS, UNDERSTOOD_ITEM_TYPES, PRELUDE_TYPES2, PRELUDE_EVENTS, codexRolloutFile;
+var import_fs7, import_path7, import_crypto9, import_crypto10, import_crypto11, import_crypto12, TokenRefresher, MCP_STARTUP_TIMEOUT_SEC, FIELD_TYPES, YES_NO, ACCEPT_DECLINE, MAX_INLINE_GENERATED_IMAGE_BYTES, PNG_SIGNATURE2, JPEG_NON_FRAME_MARKERS, IMAGE_GEN_CALL, PROMPT_LITERAL, RELOCATE_EVERY_MS, CodexImageGenerationFold, CodexRolloutImages, CodexRateLimits, USER_INPUT_METHOD, PERMISSIONS_METHOD, ELICITATION_METHOD, COMMAND_OR_FILE, LEGACY, DECISIONS, COORDINATION_TOOLS, SETTLED_AGENT, STATUS, CHANGE_OPERATIONS, SILENT_ON_START, IGNORED_ITEMS, PLAN_STATUS, CODEX_MCP_STATUS, WORKER_LIFECYCLE, INFO_KINDS, SILENT, CodexTurn, STDERR_TAIL_LINES3, MAX_BETWEEN_UPDATES, UNSUPPORTED_REQUEST, DECLINED_ELICITATION, IMAGE_CATCH_UP_MS, IMAGE_POLL_MS, CodexSession, CODEX_MIN_VERSION, CODEX_REQUIREMENT, CODEX_TESTED_LINE, DEFAULTS2, CLIENT_INFO, STATUS2, EXITED_WITHOUT_RESPONSE, CodexExecTurn, DEFAULTS22, CodexExecSession, INJECTED_USER_PREFIXES, SHELL_TOOL_NAMES, ANNOUNCING_ITEM_TYPES, OUTPUT_MARKER, OPEN_PAGE_ACTIONS, FIND_IN_PAGE_ACTIONS, FILE_OPERATIONS, UNDERSTOOD_ITEM_TYPES, PRELUDE_TYPES2, PRELUDE_EVENTS, codexRolloutFile;
 var init_codex = __esm({
   "../agent-core/dist/providers/codex.js"() {
     "use strict";
     init_chunk_D4TIXPWZ();
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -34133,6 +34265,12 @@ var init_codex = __esm({
       ["inProgress", "in_progress"],
       ["completed", "completed"]
     ]);
+    CODEX_MCP_STATUS = {
+      starting: "starting",
+      ready: "connected",
+      failed: "failed",
+      cancelled: "failed"
+    };
     WORKER_LIFECYCLE = /* @__PURE__ */ new Set([
       "turn/started",
       "turn/completed",
@@ -34284,20 +34422,29 @@ var init_codex = __esm({
           )
         ];
       }
+      #mcpStatus(params) {
+        const name = asString(params.name);
+        if (!name) return [];
+        const reported = asString(params.status);
+        const reason = asString(params.error) || asString(params.failureReason);
+        const status = CODEX_MCP_STATUS[reported] ?? "unknown";
+        const listed = {
+          sessionUpdate: "_alan/mcp_servers",
+          servers: [{ name, status, ...status === "failed" && reason ? { error: reason } : {} }]
+        };
+        if (reported !== "failed") return [listed];
+        return [listed, ...this.#mcpFailure(name, reason)];
+      }
       /**
        * Only Alan's own MCP server failing matters in the chat: its tools are gone for the session.
        * The user's other servers (and their logins) belong to their Codex setup, not to Alan.
        */
-      #mcpStatus(params) {
-        if (asString(params.status) !== "failed") return [];
-        const name = asString(params.name);
+      #mcpFailure(name, reason) {
         if (canonicalizeManagedMcpServerName(name) !== MANAGED_MCP_SERVER_NAME) {
-          const reason2 = asString(params.error) || asString(params.failureReason);
           return [
-            logUpdate("codex/mcp", `MCP server ${name} failed to start${reason2 ? `: ${reason2}` : "."}`)
+            logUpdate("codex/mcp", `MCP server ${name} failed to start${reason ? `: ${reason}` : "."}`)
           ];
         }
-        const reason = asString(params.error) || asString(params.failureReason);
         const key = `mcp_server_failed\0${reason}`;
         if (this.#memory.shownWarnings.has(key)) return [];
         this.#memory.shownWarnings.add(key);
@@ -45242,7 +45389,7 @@ var require_tar_stream = __commonJS({
 var init_dist = __esm({
   "../agent-core/dist/index.js"() {
     "use strict";
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -45989,7 +46136,7 @@ var import_promises50, import_path10, import_crypto14, import_promises51, CURSOR
 var init_acp3 = __esm({
   "../agent-core/dist/providers/acp.js"() {
     "use strict";
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -47027,9 +47174,19 @@ function createPersistentDriver(provider4, options) {
         }
       };
       const media = new LocalMediaReader(spec.projectPath, clock);
+      const uploader = inputs.media;
+      let uploads = Promise.resolve();
       const recordWithMedia = (update) => {
         record2(update);
-        for (const found of media.read(update)) record2(found);
+        const found = media.find(update);
+        if (found.length === 0) return;
+        if (uploader === void 0) {
+          for (const item of found) record2(media.inline(item));
+          return;
+        }
+        uploads = uploads.then(async () => {
+          for (const item of found) record2(await media.publish(item, uploader, signal));
+        });
       };
       const forward = (event) => {
         if (event.type === "session_id") {
@@ -47123,6 +47280,7 @@ function createPersistentDriver(provider4, options) {
       } catch (error62) {
         return { outcome: "failed", message: errorMessage(error62) };
       } finally {
+        await uploads;
         signal.removeEventListener("abort", onAbort);
         if (live.turn === turn) live.turn = void 0;
       }
@@ -47252,7 +47410,8 @@ var init_persistent = __esm({
       "user_message",
       "user_message_chunk",
       "_alan/log",
-      "_alan/thinking_tokens"
+      "_alan/thinking_tokens",
+      "_alan/mcp_servers"
     ]);
     FIRST_OUTPUT_TIMEOUT_MS = 3e5;
   }
@@ -47956,7 +48115,7 @@ var import_crypto15, import_http10, import_crypto16, import_promises52, import_p
 var init_opencode = __esm({
   "../agent-core/dist/providers/opencode.js"() {
     "use strict";
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -50007,7 +50166,7 @@ var import_crypto18, import_promises53, FACTORY_API_VERSION, FACTORY_PROTOCOL_VE
 var init_droid = __esm({
   "../agent-core/dist/providers/droid.js"() {
     "use strict";
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -51117,7 +51276,7 @@ var init_antigravity = __esm({
   "../agent-core/dist/providers/antigravity.js"() {
     "use strict";
     init_chunk_D4TIXPWZ();
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -51821,7 +51980,7 @@ var import_promises55, import_path16, import_crypto20, COMMAND_CODE_GRAMMAR_NAME
 var init_command_code = __esm({
   "../agent-core/dist/providers/command-code.js"() {
     "use strict";
-    init_chunk_FYZKVT3E();
+    init_chunk_WD7O4DYQ();
     init_chunk_OUEMTEUX();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
@@ -57224,7 +57383,7 @@ var require_websocket_server = __commonJS({
 // package.json
 var package_default = {
   name: "@alan-ai-hq/agent-manager",
-  version: "0.1.158",
+  version: "0.1.160",
   private: true,
   type: "module",
   description: "Alan machine runtime (alan-agent): identity, link, reconciler, session holders, run log, uploader, local API",
@@ -58044,6 +58203,7 @@ function createGitHubProxyForwarder(options) {
 init_runtime_v2();
 init_zod();
 var REQUEST_TIMEOUT_MS3 = 3e4;
+var MEDIA_PUT_TIMEOUT_MS = 3e5;
 var credentialRefusalSchema = external_exports.object({ message: external_exports.string().trim().min(1) });
 function credentialFailureMessage(response, fallback) {
   if (response.status !== 409) return fallback;
@@ -58112,6 +58272,33 @@ function createHolderApiClient({
         throw new RuntimeFault("io_failed", `MCP credential request failed: ${response.status}`);
       }
       return machineMcpCredentialSchema.parse(jsonBody(response));
+    },
+    uploadRunMedia: async (runId, media, data, signal) => {
+      const reserved = await request2("POST", runMediaPath(runId), signal, media);
+      if (!isOk(reserved)) {
+        throw new RuntimeFault("io_failed", `Media upload request failed: ${reserved.status}`);
+      }
+      const reservation = runMediaUploadResponseSchema.parse(jsonBody(reserved));
+      if (reservation.status === "ready") return;
+      const stored = await transport.send({
+        method: "PUT",
+        url: new URL(reservation.upload.url),
+        headers: {
+          ...reservation.upload.headers,
+          "content-length": String(data.byteLength)
+        },
+        body: data,
+        redirect: "error",
+        signal: AbortSignal.any([signal, AbortSignal.timeout(MEDIA_PUT_TIMEOUT_MS)])
+      });
+      if (!isOk(stored)) {
+        throw new RuntimeFault("io_failed", `Media upload failed: ${stored.status}`);
+      }
+      const completed = await request2("POST", runMediaCompletePath(runId, media.mediaId), signal);
+      if (!isOk(completed)) {
+        throw new RuntimeFault("io_failed", `Media upload completion failed: ${completed.status}`);
+      }
+      runMediaCompleteResponseSchema.parse(jsonBody(completed));
     }
   };
 }
@@ -70777,6 +70964,13 @@ function attachmentPath(spec, attachment, index, runDir) {
   }
   return (0, import_node_path54.join)(runDir, `${index}-${safeFilename(attachment.filename)}`);
 }
+function runMediaUploader(source, runId) {
+  const upload = source.uploadMedia?.bind(source);
+  if (upload === void 0) return void 0;
+  return {
+    upload: ({ data, ...media }, signal) => upload(runId, { ...media, bytes: data.byteLength }, data, signal)
+  };
+}
 async function prepareRunInputs(spec, { source, tmpDir, signal, skills = [] }) {
   const dir = (0, import_node_path54.join)(tmpDir, "runs", spec.runId);
   const cleanup = async () => {
@@ -70803,9 +70997,11 @@ async function prepareRunInputs(spec, { source, tmpDir, signal, skills = [] }) {
         ...attachment.height === void 0 ? {} : { height: attachment.height }
       });
     }
+    const media = runMediaUploader(source, spec.runId);
     return {
       attachments,
       providerEnv: credential.env,
+      ...media === void 0 ? {} : { media },
       ...credential.codex === void 0 ? {} : { codex: credential.codex },
       skills,
       [Symbol.asyncDispose]: cleanup
@@ -74461,7 +74657,8 @@ async function machineAccess(paths, log, conversationId, transport) {
     fetchProviderCredential: async (runId, signal) => {
       void managedMcp?.authorization(signal);
       return (await api()).fetchProviderCredential(runId, signal);
-    }
+    },
+    uploadMedia: async (runId, media, data, signal) => (await api()).uploadRunMedia(runId, media, data, signal)
   };
   const codexCredentials = {
     refresh: async (runId, rejectedAccessTokenSha256) => (await api()).refreshCodexCredential(
@@ -80592,6 +80789,9 @@ init_zod();
 var RETRY_DELAYS_MS = [250, 500, 1e3, 2e3, 5e3, 1e4, 3e4];
 var PARK_MS = 5 * 6e4;
 var UNAUTHORIZED = 401;
+var CREDENTIAL_PARK_MS = 5 * 6e4;
+var CREDENTIAL_PARK_MAX_MS = 60 * 6e4;
+var UPLOAD_COALESCE_MS = 500;
 var RETRY_JITTER = 0.2;
 var uploadProgressSchema = external_exports.object({
   admittedOffset: external_exports.number().int().nonnegative(),
@@ -80612,43 +80812,78 @@ function startUploader({
   log,
   archive,
   random = Math.random,
-  onUnauthorized
+  onUnauthorized,
+  accessToken = () => ""
 }) {
   const controller = new AbortController();
   const active = /* @__PURE__ */ new Map();
   const again = /* @__PURE__ */ new Set();
+  const againNow = /* @__PURE__ */ new Set();
+  const lastSentAt = /* @__PURE__ */ new Map();
+  const coalescing = /* @__PURE__ */ new Map();
   const sealed = /* @__PURE__ */ new Set();
   const receiptBackoff = /* @__PURE__ */ new Map();
   let pendingRuns = /* @__PURE__ */ new Map();
   const retrying = /* @__PURE__ */ new Set();
   let renewing = null;
-  const retryDelay = (failures) => {
-    const base = RETRY_DELAYS_MS[Math.min(failures, RETRY_DELAYS_MS.length - 1)] ?? 3e4;
-    return Math.round(base * (1 - RETRY_JITTER + 2 * RETRY_JITTER * random()));
-  };
+  let credentialPark = null;
+  let revoked = false;
+  const jitter = (ms) => Math.round(ms * (1 - RETRY_JITTER + 2 * RETRY_JITTER * random()));
+  const retryDelay = (failures) => jitter(RETRY_DELAYS_MS[Math.min(failures, RETRY_DELAYS_MS.length - 1)] ?? 3e4);
   const renewCredential = () => {
-    if (onUnauthorized === void 0) return Promise.resolve();
-    renewing ??= onUnauthorized().catch((error62) => log.warn("upload.renew_failed", { error: error62 })).finally(() => {
+    if (onUnauthorized === void 0) return Promise.resolve("unchanged");
+    renewing ??= onUnauthorized().catch((error62) => {
+      log.warn("upload.renew_failed", { error: error62 });
+      return "unchanged";
+    }).finally(() => {
       renewing = null;
     });
     return renewing;
   };
+  const credentialParked = () => {
+    if (credentialPark === null) return false;
+    if (accessToken() !== credentialPark.token) {
+      credentialPark = null;
+      return false;
+    }
+    return credentialPark.until > clock.now();
+  };
+  const parkForCredential = (token) => {
+    if (credentialParked()) return;
+    const failures = (credentialPark?.failures ?? 0) + 1;
+    const delay4 = Math.min(CREDENTIAL_PARK_MS * 2 ** (failures - 1), CREDENTIAL_PARK_MAX_MS);
+    credentialPark = { failures, until: clock.now() + jitter(delay4), token };
+    log.warn("upload.credential_parked", { failures, parkedUntil: credentialPark.until });
+  };
+  const unauthorized = async (runId, tokenAtStart) => {
+    const renewal = await renewCredential();
+    if (renewal === "revoked") {
+      revoked = true;
+      log.error("upload.credential_revoked", { runId });
+      return;
+    }
+    if (renewal === "renewed" || accessToken() !== tokenAtStart) {
+      credentialPark = null;
+      deferReceipt(runId);
+      return;
+    }
+    parkForCredential(tokenAtStart);
+  };
   const deferReceipt = (runId) => {
     const failures = (receiptBackoff.get(runId)?.failures ?? 0) + 1;
     receiptBackoff.set(runId, { failures, notBefore: clock.now() + retryDelay(failures) });
   };
-  const reject = async (runId, progressPath, progress, rejection2) => {
+  const reject = async (runId, progressPath, progress, rejection2, tokenAtStart) => {
     log.error("upload.rejected", { runId, status: rejection2.status, message: rejection2.message });
     if (rejection2.status === UNAUTHORIZED) {
-      await renewCredential();
-      deferReceipt(runId);
+      await unauthorized(runId, tokenAtStart);
       return;
     }
     const parkedUntil = clock.now() + PARK_MS;
     await writeJsonFileAtomic(progressPath, { ...progress, parkedUntil });
     log.warn("upload.parked", { runId, parkedUntil });
   };
-  const progressOf = async (runId, target, path4) => {
+  const progressOf = async (runId, target, path4, tokenAtStart) => {
     const stored = await readJsonFile(path4, uploadProgressSchema);
     if (stored.kind === "ok") return stored.value;
     const listed = pendingRuns.get(runId);
@@ -80661,6 +80896,7 @@ function startUploader({
     switch (receipt.kind) {
       case "read": {
         receiptBackoff.delete(runId);
+        credentialPark = null;
         log.debug("upload.resumed", {
           runId,
           admittedOffset: receipt.receipt?.admittedOffset ?? 0
@@ -80670,7 +80906,7 @@ function startUploader({
         return progress;
       }
       case "rejected":
-        await reject(runId, path4, progressFromReceipt(null), receipt);
+        await reject(runId, path4, progressFromReceipt(null), receipt, tokenAtStart);
         return null;
       case "retry": {
         deferReceipt(runId);
@@ -80682,6 +80918,7 @@ function startUploader({
   };
   const sendNext = async (upload2, progress) => {
     const ended = (await readLastRecord(upload2.logPath))?.update.sessionUpdate === "_alan/run.ended";
+    const size = await upload2.reader.size();
     const chunk = await upload2.reader.readFrom(
       toByteOffset(progress.admittedOffset),
       MAX_RUN_LOG_CHUNK_BYTES
@@ -80696,14 +80933,14 @@ function startUploader({
           sealed: atEnd || outcome2.receipt.finalOffset !== null
         };
         await writeJsonFileAtomic(upload2.progressPath, next);
-        return { kind: "advanced", progress: next };
+        return { kind: "advanced", progress: next, more: ended || chunk.to < size };
       }
       case "offset_conflict": {
         const receipt = await api.readReceipt(upload2.target, controller.signal);
         if (receipt.kind === "read") {
           const next = progressFromReceipt(receipt.receipt);
           await writeJsonFileAtomic(upload2.progressPath, next);
-          return { kind: "advanced", progress: next };
+          return { kind: "advanced", progress: next, more: true };
         }
         return receipt.kind === "retry" ? receipt : { kind: "rejected", rejection: receipt };
       }
@@ -80720,7 +80957,18 @@ function startUploader({
     log.warn("upload.retrying", { runId, status, delayMs: delay4 });
     await clock.sleep(delay4, controller.signal);
   };
-  const drain = async (runUpload, initial) => {
+  const recordAccepted = (runId, progress) => {
+    receiptBackoff.delete(runId);
+    credentialPark = null;
+    if (!progress.sealed) {
+      lastSentAt.set(runId, clock.monotonic());
+      return;
+    }
+    sealed.add(runId);
+    lastSentAt.delete(runId);
+    log.info("upload.sealed", { runId, bytes: progress.admittedOffset });
+  };
+  const drain = async (runUpload, initial, tokenAtStart) => {
     const { runId } = runUpload.target;
     let progress = initial;
     let failures = 0;
@@ -80728,7 +80976,7 @@ function startUploader({
       const step = await sendNext(runUpload, progress);
       if (step.kind === "caught_up") return "settled";
       if (step.kind === "rejected") {
-        await reject(runId, runUpload.progressPath, progress, step.rejection);
+        await reject(runId, runUpload.progressPath, progress, step.rejection, tokenAtStart);
         return "retry_later";
       }
       if (step.kind === "retry") {
@@ -80737,13 +80985,9 @@ function startUploader({
         continue;
       }
       failures = 0;
-      receiptBackoff.delete(runId);
       progress = step.progress;
-      if (progress.sealed) {
-        sealed.add(runId);
-        log.info("upload.sealed", { runId, bytes: progress.admittedOffset });
-        return "settled";
-      }
+      recordAccepted(runId, progress);
+      if (progress.sealed || !step.more) return "settled";
     }
     return "settled";
   };
@@ -80754,9 +80998,11 @@ function startUploader({
       const meta3 = await readRunMeta(dir.meta);
       if (meta3 === null) return "settled";
       const target = { conversationId: meta3.conversationId, runId };
+      if (credentialParked()) return "retry_later";
       const backoff = receiptBackoff.get(runId);
       if (backoff !== void 0 && backoff.notBefore > clock.now()) return "retry_later";
-      const progress = await progressOf(runId, target, dir.upload);
+      const tokenAtStart = accessToken();
+      const progress = await progressOf(runId, target, dir.upload, tokenAtStart);
       if (progress === null) return "retry_later";
       if (progress.sealed) {
         sealed.add(runId);
@@ -80766,11 +81012,12 @@ function startUploader({
         return "retry_later";
       }
       const reader = __using(_stack, await openRunLogReader(dir.log), true);
-      const attempt2 = await drain(
+      const attempt3 = await drain(
         { target, reader, logPath: dir.log, progressPath: dir.upload },
-        progress
+        progress,
+        tokenAtStart
       );
-      return attempt2;
+      return attempt3;
     } catch (_) {
       var _error = _, _hasError = true;
     } finally {
@@ -80778,20 +81025,48 @@ function startUploader({
       _promise2 && await _promise2;
     }
   };
-  const run2 = (runId) => {
+  const coalesce = async (runId) => {
+    const delay4 = (lastSentAt.get(runId) ?? Number.NEGATIVE_INFINITY) + UPLOAD_COALESCE_MS;
+    const remaining = delay4 - clock.monotonic();
+    if (remaining <= 0) return;
+    const wake = new AbortController();
+    coalescing.set(runId, wake);
+    try {
+      await clock.sleep(remaining, AbortSignal.any([wake.signal, controller.signal]));
+    } catch {
+    } finally {
+      coalescing.delete(runId);
+    }
+  };
+  const attempt2 = async (runId, timing) => {
+    if (timing === "coalesced") await coalesce(runId);
+    again.delete(runId);
+    againNow.delete(runId);
+    if (controller.signal.aborted) return "settled";
+    return upload(runId);
+  };
+  const run2 = (runId, timing = "immediate") => {
+    if (revoked) return;
     if (active.has(runId)) {
       again.add(runId);
+      if (timing === "immediate") {
+        againNow.add(runId);
+        coalescing.get(runId)?.abort();
+      }
       return;
     }
-    const task = upload(runId).then((attempt2) => {
-      if (attempt2 === "settled") retrying.delete(runId);
+    const task = attempt2(runId, timing).then((attempt3) => {
+      if (attempt3 === "settled") retrying.delete(runId);
       else retrying.add(runId);
     }).catch((error62) => {
       retrying.add(runId);
       if (!controller.signal.aborted) log.warn("upload.failed", { runId, error: error62 });
     }).finally(() => {
       active.delete(runId);
-      if (again.delete(runId) && !controller.signal.aborted) run2(runId);
+      const now = againNow.delete(runId);
+      if (again.delete(runId) && !controller.signal.aborted) {
+        run2(runId, now ? "immediate" : "coalesced");
+      }
     });
     active.set(runId, task);
   };
@@ -80838,7 +81113,8 @@ function startUploader({
     return found;
   };
   return {
-    notify: run2,
+    notify: (runId) => run2(runId, "coalesced"),
+    uploadNow: (runId) => run2(runId, "immediate"),
     sweep: sweep2,
     pending: (uploads) => {
       pendingRuns = new Map(
@@ -81246,6 +81522,7 @@ async function startMachinePlane(deps) {
         () => identity.renewAfterRejection(stopped.signal)
       );
       if (renewal.kind === "revoked") deps.onRevoked();
+      return renewal;
     };
     const sessionsOpened = Promise.withResolvers();
     const planeOpened = Promise.withResolvers();
@@ -81288,7 +81565,9 @@ async function startMachinePlane(deps) {
           refreshDesired();
         },
         onConnectRefused: (error62) => updates.connectRefused(error62),
-        refreshCredential: renewAfterRejection,
+        refreshCredential: async () => {
+          await renewAfterRejection();
+        },
         onStateChange: deps.onStatusChange,
         answerWorkspaceQuery: (request2) => workspaces.answer(request2),
         respond: (request2) => sessions.respond(request2),
@@ -81350,7 +81629,11 @@ async function startMachinePlane(deps) {
         clock,
         log,
         archive,
-        onUnauthorized: renewAfterRejection
+        onUnauthorized: async () => {
+          const renewal = await renewAfterRejection();
+          return renewal.kind === "renewed" || renewal.kind === "revoked" ? renewal.kind : "unchanged";
+        },
+        accessToken: identity.accessToken
       })
     );
     const nativeIngest = stack.use(
@@ -81414,7 +81697,7 @@ async function startMachinePlane(deps) {
         onTurnEnded: (runId) => {
           runsShownRunning.delete(runId);
           deps.onStatusChange();
-          uploader.notify(runId);
+          uploader.uploadNow(runId);
           appends.notify(runId);
           nativeIngest.runEnded(runId);
           followActiveRuns().catch((error62) => log.warn("power.follow_failed", { error: error62 }));