@alan-ai-hq/agent-manager-linux-x64 0.1.159 → 0.1.161

package/alan-agent.cjs

@@ -637,14 +637,14 @@ function codePointLength(str) {
   const units = str.length;
   if (!highSurrogate.test(str))
     return units;
-  let count = units;
+  let count2 = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count--;
+      count2--;
       i++;
     }
   }
-  return count;
+  return count2;
 }
 function getLengthableOrigin(input2) {
   if (Array.isArray(input2))
@@ -5147,8 +5147,8 @@ var init_az = __esm({
 });
 
 // ../../node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -7942,8 +7942,8 @@ var init_hu = __esm({
 });
 
 // ../../node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count, one, many) {
-  return Math.abs(count) === 1 ? one : many;
+function getArmenianPlural(count2, one, many) {
+  return Math.abs(count2) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -10841,8 +10841,8 @@ var init_ro = __esm({
 });
 
 // ../../node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -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();
   }
@@ -25470,8 +25521,8 @@ function diffRows(patch) {
     return { kind: "meta", text: line };
   });
 }
-function patchForPath(text3, path4, count) {
-  if (count === 1)
+function patchForPath(text3, path4, count2) {
+  if (count2 === 1)
     return text3;
   const normalized2 = path4.replace(/^\/+/, "");
   return text3.split(/(?=^diff --git )/m).find((part) => {
@@ -26042,6 +26093,13 @@ function applyUpdate(state, update) {
   index.last = state.entries.at(-1);
   return state;
 }
+function usageContextTokens(meta3) {
+  const usage = meta3?.["alan.dev/usage"];
+  if (typeof usage !== "object" || usage === null || !("contextTokens" in usage))
+    return void 0;
+  const { contextTokens } = usage;
+  return typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0 ? contextTokens : void 0;
+}
 function awaitingToolCallIds(meta3) {
   const ids = meta3?.[AWAITING_TOOL_CALLS_META];
   return Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : [];
@@ -26093,9 +26151,11 @@ function applyOne(state, index, update) {
     case "usage_update": {
       if (!isUpdate(update, "usage_update"))
         return;
+      const contextTokens = usageContextTokens(update._meta);
       state.usage = {
         used: update.used,
         size: update.size,
+        ...contextTokens === void 0 ? {} : { contextTokens },
         ...update.cost ? { cost: update.cost } : {}
       };
       delete state.thinkingTokens;
@@ -26448,17 +26508,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: {
@@ -26467,6 +26530,7 @@ function stepSummary(node2) {
         ...rest,
         ...input2.value === void 0 ? {} : { rawInput: input2.value },
         ...input2.truncated ? { inputTruncated: true } : {},
+        ...outputOmitted ? { outputTruncated: true } : {},
         ...diffs.length > 0 ? { content: diffs } : {}
       }
     },
@@ -26783,9 +26847,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)));
   }
 });
 
@@ -26987,7 +27056,7 @@ var init_acp = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-OUEMTEUX.js
+// ../agent-core/dist/chunk-RBQC7XZH.js
 function textBlock(text3) {
   return { type: "text", text: text3 };
 }
@@ -27122,8 +27191,8 @@ function readPatchHunks(value2) {
     return hunk ? [hunk] : [];
   });
 }
-function hunkRange(start, count) {
-  return count === 1 ? String(start) : `${start},${count}`;
+function hunkRange(start, count2) {
+  return count2 === 1 ? String(start) : `${start},${count2}`;
 }
 function hunkHeader(hunk) {
   return `@@ -${hunkRange(hunk.oldStart, hunk.oldLines)} +${hunkRange(hunk.newStart, hunk.newLines)} @@`;
@@ -27134,14 +27203,14 @@ function patchPath(path4) {
 function wholeFileHunk(content, deleted) {
   const lines2 = content === "" ? [] : content.split("\n");
   if (lines2.at(-1) === "") lines2.pop();
-  const count = lines2.length;
+  const count2 = lines2.length;
   const marked = lines2.map((line) => `${deleted ? "-" : "+"}${line}`);
   if (content && !content.endsWith("\n")) marked.push("\");
   return {
-    oldStart: deleted && count ? 1 : 0,
-    oldLines: deleted ? count : 0,
-    newStart: !deleted && count ? 1 : 0,
-    newLines: deleted ? 0 : count,
+    oldStart: deleted && count2 ? 1 : 0,
+    oldLines: deleted ? count2 : 0,
+    newStart: !deleted && count2 ? 1 : 0,
+    newLines: deleted ? 0 : count2,
     lines: marked
   };
 }
@@ -27236,8 +27305,8 @@ function planEntries(todos) {
   });
 }
 var PROVIDER_PAYLOAD_META, TOOL_RESULT_ONLY_META, PARENT_TOOL_CALL_META, SUBAGENT_LAUNCHER_META, SUBAGENT_TASK_ID_META, SUBAGENT_OUTPUT_FILE_META, USAGE_META, TODOS_META, NOTICE_KIND_META, ASK_USER_QUESTIONS_META, USER_ANSWER_META, AWAITING_TOOL_CALLS_META2, EXIT_PLAN_MODE_INPUT_META, BACKGROUND_TASK_META, TASK_PROGRESS_META, RATE_LIMIT_META, MODEL_META, TOOLS_META, SLASH_COMMANDS_META, TOOL_KIND_RULES, ANSWER_PREFIX, ACCEPT_WORDS, MIN_INLINE_MEDIA_CHARS, DATA_URL_PREFIX, BASE64_BODY, PLAN_ENTRY_STATUSES;
-var init_chunk_OUEMTEUX = __esm({
-  "../agent-core/dist/chunk-OUEMTEUX.js"() {
+var init_chunk_RBQC7XZH = __esm({
+  "../agent-core/dist/chunk-RBQC7XZH.js"() {
     "use strict";
     init_chunk_YXWJW7I5();
     init_constants();
@@ -27293,12 +27362,12 @@ var init_chunk_OUEMTEUX = __esm({
 var init_acp2 = __esm({
   "../agent-core/dist/acp.js"() {
     "use strict";
-    init_chunk_OUEMTEUX();
+    init_chunk_RBQC7XZH();
     init_chunk_YXWJW7I5();
   }
 });
 
-// ../agent-core/dist/chunk-D4TIXPWZ.js
+// ../agent-core/dist/chunk-TFIO37PI.js
 function isRecordValue(value2) {
   return value2 !== null;
 }
@@ -27477,10 +27546,10 @@ function readTranscriptTurns(transcript, chunk, baseOffset, skipped = []) {
   return { turns, consumedBytes: consumedEnd - baseOffset };
 }
 var import_fs4, NEWLINE2, TranscriptCursor, TranscriptLineLookup, CONTENT_UPDATES;
-var init_chunk_D4TIXPWZ = __esm({
-  "../agent-core/dist/chunk-D4TIXPWZ.js"() {
+var init_chunk_TFIO37PI = __esm({
+  "../agent-core/dist/chunk-TFIO37PI.js"() {
     "use strict";
-    init_chunk_OUEMTEUX();
+    init_chunk_RBQC7XZH();
     init_chunk_YXWJW7I5();
     import_fs4 = require("fs");
     NEWLINE2 = 10;
@@ -28037,7 +28106,7 @@ var init_chunk_ZCTKXKYY = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-FYZKVT3E.js
+// ../agent-core/dist/chunk-N2M5D7RS.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) {
@@ -28173,6 +28242,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`;
@@ -28457,10 +28547,10 @@ 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_N2M5D7RS = __esm({
+  "../agent-core/dist/chunk-N2M5D7RS.js"() {
     "use strict";
-    init_chunk_OUEMTEUX();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_YXWJW7I5();
@@ -28500,8 +28590,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) {
@@ -28547,20 +28641,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) {
@@ -28569,14 +28685,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");
@@ -28591,13 +28700,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);
         });
       }
     };
@@ -30550,9 +30653,29 @@ function backgroundTaskProgress(event, tasks) {
     }
   ];
 }
+function claudeMessageContextTokens(message2) {
+  if (asString(message2?.model) === "<synthetic>") return void 0;
+  const usage = asRecord(message2?.usage);
+  if (!usage) return void 0;
+  const tokens2 = (asFiniteNumber(usage.input_tokens) ?? 0) + (asFiniteNumber(usage.cache_read_input_tokens) ?? 0) + (asFiniteNumber(usage.cache_creation_input_tokens) ?? 0) + (asFiniteNumber(usage.output_tokens) ?? 0);
+  return tokens2 > 0 ? tokens2 : void 0;
+}
+function resultContextWindow(event, model) {
+  const byModel = asRecord(event.modelUsage);
+  if (!byModel) return void 0;
+  const own2 = asFiniteNumber(asRecord(byModel[model])?.contextWindow);
+  if (own2 !== void 0) return own2;
+  let largest;
+  for (const entry of Object.values(byModel)) {
+    const size = asFiniteNumber(asRecord(entry)?.contextWindow);
+    if (size !== void 0 && size > (largest ?? 0)) largest = size;
+  }
+  return largest;
+}
 function resultUsage(event, context) {
   const usage = asRecord(event.usage);
   const model = asString(event.model).trim() || context.activeModel?.trim() || context.selectedModel?.trim() || "claude";
+  const contextSize = resultContextWindow(event, model);
   return usageUpdate({
     model,
     numTurns: asFiniteNumber(event.num_turns) ?? Math.max(context.iterations, 1),
@@ -30561,7 +30684,9 @@ function resultUsage(event, context) {
     outputTokens: asFiniteNumber(usage?.output_tokens) ?? 0,
     cacheReadTokens: asFiniteNumber(usage?.cache_read_input_tokens) ?? 0,
     cacheCreationTokens: asFiniteNumber(usage?.cache_creation_input_tokens) ?? 0,
-    costUsd: asFiniteNumber(event.total_cost_usd) ?? 0
+    costUsd: asFiniteNumber(event.total_cost_usd) ?? 0,
+    ...contextSize === void 0 ? {} : { contextSize },
+    ...context.contextTokens === void 0 ? {} : { contextTokens: context.contextTokens }
   });
 }
 function resultErrorText(event, subtype) {
@@ -30979,7 +31104,8 @@ function scanTurn(records) {
     model: "",
     lastStopReason: "",
     interrupted: false,
-    durationMs: void 0
+    durationMs: void 0,
+    contextTokens: void 0
   };
   for (const record2 of records) {
     if (isInterruptMarker(record2)) scan.interrupted = true;
@@ -30992,19 +31118,22 @@ function scanTurn(records) {
     scan.model ||= recordModel;
     const id = asString(message2.id) || asString(record2.uuid);
     scan.usageByMessage.set(id, messageUsage(message2));
+    if (isTopLevel(record2))
+      scan.contextTokens = claudeMessageContextTokens(message2) ?? scan.contextTokens;
     scan.lastStopReason = asString(message2.stop_reason);
   }
   return scan;
 }
 function claudeTurnClosingUpdates(records, state) {
-  const { usageByMessage, model, lastStopReason, interrupted, durationMs } = scanTurn(records);
+  const { usageByMessage, model, lastStopReason, interrupted, durationMs, contextTokens } = scanTurn(records);
   const updates = [];
   if (usageByMessage.size > 0) {
     const breakdown = {
       ...totalUsage(usageByMessage.values()),
       model,
       numTurns: usageByMessage.size,
-      ...durationMs ? { durationMs } : {}
+      ...durationMs ? { durationMs } : {},
+      ...contextTokens === void 0 ? {} : { contextTokens }
     };
     updates.push(usageUpdate(breakdown, state.model ?? ""));
   }
@@ -31019,9 +31148,9 @@ var import_crypto7, import_fs6, import_path6, import_crypto8, import_promises31,
 var init_claude = __esm({
   "../agent-core/dist/providers/claude.js"() {
     "use strict";
-    init_chunk_D4TIXPWZ();
-    init_chunk_FYZKVT3E();
-    init_chunk_OUEMTEUX();
+    init_chunk_TFIO37PI();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -31319,6 +31448,7 @@ var init_claude = __esm({
       #announced = /* @__PURE__ */ new Set();
       #awaitingAskDenialFallback = false;
       #iterations = 0;
+      #contextTokens;
       #providerErrorCode;
       #deferredOnAnswer = false;
       #deferredOnBackground = false;
@@ -31458,6 +31588,7 @@ var init_claude = __esm({
       #handleSystem(event) {
         const subtype = asString(event.subtype);
         if (subtype === "api_retry") this.#noteRetry(event);
+        if (subtype === "compact_boundary") this.#noteCompaction(event);
         if (subtype === "task_started") {
           this.tasks.registerRecord(event, parentToolUseId(event));
           this.taskRecords.track(event, this.tasks.resolveToolUseId(event));
@@ -31542,13 +31673,25 @@ var init_claude = __esm({
           status
         });
       }
+      /** The window was just rewritten; the pre-compaction figure would overstate it until the next call. */
+      #noteCompaction(event) {
+        if (parentToolUseId(event)) return;
+        const after = asFiniteNumber(asRecord(event.compact_metadata)?.post_tokens);
+        this.#contextTokens = after !== void 0 && after > 0 ? after : void 0;
+      }
+      #noteContext(event, message2) {
+        if (parentToolUseId(event)) return;
+        this.#contextTokens = claudeMessageContextTokens(message2) ?? this.#contextTokens;
+      }
       #handleAssistant(event) {
         if (this.#awaitingAskDenialFallback) {
           this.#awaitingAskDenialFallback = false;
           return;
         }
         this.#iterations += 1;
-        for (const raw of asArray(asRecord(event.message)?.content)) {
+        const message2 = asRecord(event.message);
+        this.#noteContext(event, message2);
+        for (const raw of asArray(message2?.content)) {
           const block2 = asRecord(raw);
           if (!block2 || asString(block2.type) !== "tool_use") continue;
           const id = asString(block2.id);
@@ -31568,7 +31711,8 @@ var init_claude = __esm({
           resultUsage(event, {
             activeModel: this.grammar.model,
             selectedModel: this.#options.selectedModel,
-            iterations: this.#iterations
+            iterations: this.#iterations,
+            ...this.#contextTokens === void 0 ? {} : { contextTokens: this.#contextTokens }
           })
         ];
         if (typeof event.num_turns === "number") this.#iterations = event.num_turns;
@@ -32806,6 +32950,59 @@ function planEntries2(plan2) {
     ];
   });
 }
+function count(value2) {
+  return asFiniteNumber(value2) ?? 0;
+}
+function withTotal(tokens2, reported) {
+  return { ...tokens2, total: reported || tokens2.input + tokens2.output };
+}
+function appServerTokens(record2) {
+  return withTotal(
+    {
+      input: count(record2.inputTokens),
+      cachedInput: count(record2.cachedInputTokens),
+      cacheWrite: count(record2.cacheWriteInputTokens),
+      output: count(record2.outputTokens)
+    },
+    count(record2.totalTokens)
+  );
+}
+function rolloutTokens(record2) {
+  return withTotal(
+    {
+      input: count(record2.input_tokens),
+      cachedInput: count(record2.cached_input_tokens),
+      cacheWrite: count(record2.cache_write_input_tokens),
+      output: count(record2.output_tokens)
+    },
+    count(record2.total_tokens)
+  );
+}
+function subtractTokens(from, amount2) {
+  const minus = (a, b) => Math.max(a - b, 0);
+  return {
+    input: minus(from.input, amount2.input),
+    cachedInput: minus(from.cachedInput, amount2.cachedInput),
+    cacheWrite: minus(from.cacheWrite, amount2.cacheWrite),
+    output: minus(from.output, amount2.output),
+    total: minus(from.total, amount2.total)
+  };
+}
+function codexBreakdown(tokens2) {
+  return {
+    inputTokens: Math.max(tokens2.input - tokens2.cachedInput - tokens2.cacheWrite, 0),
+    outputTokens: tokens2.output,
+    cacheReadTokens: tokens2.cachedInput,
+    cacheCreationTokens: tokens2.cacheWrite
+  };
+}
+function codexUsageUpdate(spend, extra, fallbackModel) {
+  const update = usageUpdate({ ...codexBreakdown(spend), ...extra }, fallbackModel);
+  return spend.total > 0 && isUpdate(update, "usage_update") ? { ...update, used: spend.total } : update;
+}
+function codexContextTokens(last) {
+  return last.total > 0 ? last.total : void 0;
+}
 function createCodexSessionMemory() {
   return { shownWarnings: /* @__PURE__ */ new Set(), workers: /* @__PURE__ */ new Map() };
 }
@@ -33191,6 +33388,7 @@ function createCodexRolloutState() {
   return {
     recordTime: 0,
     turnUsageSeen: false,
+    turnTokens: new CodexTurnTokens(),
     shellCallIds: /* @__PURE__ */ new Set(),
     announcedCallIds: /* @__PURE__ */ new Set(),
     failedCallIds: /* @__PURE__ */ new Set(),
@@ -33613,31 +33811,29 @@ function compactionNotice2() {
 function num(value2) {
   return asFiniteNumber(value2) ?? 0;
 }
-function tokenBreakdown(usage) {
-  return {
-    inputTokens: num(usage.input_tokens),
-    outputTokens: num(usage.output_tokens) + num(usage.reasoning_output_tokens),
-    cacheReadTokens: num(usage.cached_input_tokens),
-    cacheCreationTokens: num(usage.cache_write_input_tokens)
-  };
-}
-function reportedUsage(breakdown, totalTokens, state) {
-  const update = usageUpdate(breakdown, state.model ?? "");
-  return totalTokens && update.sessionUpdate === "usage_update" ? { ...update, used: totalTokens } : update;
+function reportedUsage(spend, state) {
+  return codexUsageUpdate(spend, state.turnTokens.context, state.model ?? "");
 }
 function turnUsage(payload, state) {
   const turn = asRecord(payload.turn_token_usage);
   if (!turn) return [];
   state.turnUsageSeen = true;
-  return [reportedUsage(tokenBreakdown(turn), num(turn.total_tokens), state)];
+  return [reportedUsage(rolloutTokens(turn), state)];
 }
 function tokenCount(payload, state) {
-  if (state.turnUsageSeen) return [];
   const info = asRecord(payload.info);
-  const total = asRecord(info?.total_token_usage);
-  if (!total) return [];
-  const breakdown = { ...tokenBreakdown(total), contextSize: num(info?.model_context_window) };
-  return [reportedUsage(breakdown, num(total.total_tokens), state)];
+  const totalRecord = asRecord(info?.total_token_usage);
+  if (!totalRecord) return [];
+  const total = rolloutTokens(totalRecord);
+  const lastRecord = asRecord(info?.last_token_usage);
+  if (lastRecord)
+    state.turnTokens.note(rolloutTokens(lastRecord), total, num(info?.model_context_window));
+  if (state.turnUsageSeen) return [];
+  return [reportedUsage(state.turnTokens.spend(total), state)];
+}
+function turnStarted(state) {
+  state.turnTokens = new CodexTurnTokens();
+  return [{ sessionUpdate: "state_update", state: "running" }];
 }
 function extensionItem(item, state) {
   switch (asString(item.kind)) {
@@ -33730,7 +33926,7 @@ function parseEventMsg(payload, state) {
     case "task_complete":
       return taskComplete(payload);
     case "task_started":
-      return [{ sessionUpdate: "state_update", state: "running" }];
+      return turnStarted(state);
     case "turn_aborted":
       return [{ sessionUpdate: "state_update", state: "idle", stopReason: "cancelled" }];
     case "error":
@@ -33878,13 +34074,13 @@ 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, 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 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, CodexTurnTokens, 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_OUEMTEUX();
+    init_chunk_TFIO37PI();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -33896,6 +34092,7 @@ var init_codex = __esm({
     import_crypto9 = require("crypto");
     import_crypto10 = require("crypto");
     init_runtime_v2();
+    init_acp();
     init_agent2();
     import_crypto11 = require("crypto");
     init_agent2();
@@ -34029,10 +34226,13 @@ var init_codex = __esm({
       #reported = /* @__PURE__ */ new Set();
       #cursor;
       #lastMiss;
-      constructor(locate2, clock) {
+      #onTokenCount;
+      /** `onTokenCount` also hears each `token_count` the rollout gains, for the turn's usage. */
+      constructor(locate2, clock, onTokenCount) {
         this.#locate = locate2;
         this.#clock = clock;
         this.#fold = new CodexImageGenerationFold(clock);
+        this.#onTokenCount = onTokenCount;
       }
       get waiting() {
         return this.#fold.waiting;
@@ -34053,7 +34253,10 @@ var init_codex = __esm({
       }
       /** What the rollout gained since the last drain. */
       drain() {
-        for (const line of this.#open()?.read() ?? []) this.#fold.foldLine(line.text);
+        for (const line of this.#open()?.read() ?? []) {
+          this.#fold.foldLine(line.text);
+          if (this.#onTokenCount) this.#readTokenCount(line.text, this.#onTokenCount);
+        }
         return this.admit(this.#fold.take());
       }
       /** The turn is over: what is left, then every call still pending as failed. */
@@ -34070,6 +34273,16 @@ var init_codex = __esm({
         }
         return updates;
       }
+      #readTokenCount(text3, onTokenCount) {
+        if (!text3.includes('"token_count"')) return;
+        try {
+          const payload = asRecord(asRecord(JSON.parse(text3))?.payload);
+          const info = asRecord(payload?.info);
+          if (asString(payload?.type) === "token_count" && info) onTokenCount(info);
+        } catch {
+          return;
+        }
+      }
       #open() {
         if (this.#cursor) return this.#cursor;
         const now = this.#clock.monotonic();
@@ -34171,6 +34384,31 @@ var init_codex = __esm({
       ["inProgress", "in_progress"],
       ["completed", "completed"]
     ]);
+    CodexTurnTokens = class {
+      #baseline;
+      #last;
+      #window;
+      /** Records one report; `total` absent means `last` is the whole turn so far. */
+      note(last, total, window2) {
+        if (total) this.#baseline ??= subtractTokens(total, last);
+        this.#last = last;
+        if (window2 !== void 0 && window2 > 0) this.#window = window2;
+      }
+      get hasBaseline() {
+        return this.#baseline !== void 0;
+      }
+      spend(total) {
+        return this.#baseline ? subtractTokens(total, this.#baseline) : total;
+      }
+      /** The context the turn's last call left, and the window, as far as they are known. */
+      get context() {
+        const contextTokens = this.#last ? codexContextTokens(this.#last) : void 0;
+        return {
+          ...this.#window === void 0 ? {} : { contextSize: this.#window },
+          ...contextTokens === void 0 ? {} : { contextTokens }
+        };
+      }
+    };
     CODEX_MCP_STATUS = {
       starting: "starting",
       ready: "connected",
@@ -34217,6 +34455,7 @@ var init_codex = __esm({
       #end;
       #failFast;
       #lastError;
+      #tokens = new CodexTurnTokens();
       codexTurnId;
       constructor(memory, clock = systemClock2) {
         this.#memory = memory;
@@ -34311,19 +34550,16 @@ var init_codex = __esm({
       }
       #usage(params) {
         const usage = asRecord(params.tokenUsage);
-        const last = asRecord(usage?.last);
-        if (!last) return [];
-        const number4 = (value2) => asFiniteNumber(value2) ?? 0;
+        const lastRecord = asRecord(usage?.last);
+        if (!lastRecord) return [];
+        const last = appServerTokens(lastRecord);
+        const totalRecord = asRecord(usage?.total);
+        const total = totalRecord ? appServerTokens(totalRecord) : void 0;
+        this.#tokens.note(last, total, asFiniteNumber(usage?.modelContextWindow));
         return [
-          usageUpdate(
-            {
-              inputTokens: number4(last.inputTokens),
-              outputTokens: number4(last.outputTokens) + number4(last.reasoningOutputTokens),
-              cacheReadTokens: number4(last.cachedInputTokens),
-              cacheCreationTokens: number4(last.cacheWriteInputTokens),
-              ...asFiniteNumber(usage?.modelContextWindow) === void 0 ? {} : { contextSize: number4(usage?.modelContextWindow) },
-              costUsd: 0
-            },
+          codexUsageUpdate(
+            total ? this.#tokens.spend(total) : last,
+            { ...this.#tokens.context, costUsd: 0 },
             this.#memory.model ?? "codex"
           )
         ];
@@ -34864,12 +35100,16 @@ var init_codex = __esm({
       #lastError;
       #answered = false;
       #images;
+      #tokens = new CodexTurnTokens();
+      #resumed;
       constructor(resumeId, rollout) {
         this.#threadId = resumeId;
+        this.#resumed = resumeId !== void 0;
         if (!rollout) return;
         this.#images = new CodexRolloutImages(
           () => this.#threadId ? findCodexRollout(rollout.codexHome, this.#threadId) : void 0,
-          rollout.clock
+          rollout.clock,
+          (info) => this.#noteTokenCount(info)
         );
         if (resumeId) this.#images.startAtEnd();
       }
@@ -34931,22 +35171,34 @@ var init_codex = __esm({
         if (mapped) return itemUpdates(mapped, completed);
         return [{ sessionUpdate: "_alan/unhandled", kind: `item/${type || "(untyped)"}` }];
       }
+      /** The rollout's per-call counts: exec's own usage is only the thread's running total. */
+      #noteTokenCount(info) {
+        const last = asRecord(info.last_token_usage);
+        const total = asRecord(info.total_token_usage);
+        if (!last) return;
+        this.#tokens.note(
+          rolloutTokens(last),
+          total ? rolloutTokens(total) : void 0,
+          asFiniteNumber(info.model_context_window)
+        );
+      }
       #completed(usage) {
         this.#end = { status: "completed" };
-        const number4 = (value2) => asFiniteNumber(value2) ?? 0;
+        const rolloutUpdates = this.#images?.drain() ?? [];
         return [
-          ...usage ? [
-            usageUpdate({
-              inputTokens: number4(usage.input_tokens),
-              outputTokens: number4(usage.output_tokens) + number4(usage.reasoning_output_tokens),
-              cacheReadTokens: number4(usage.cached_input_tokens),
-              cacheCreationTokens: number4(usage.cache_write_input_tokens),
-              costUsd: 0
-            })
-          ] : [],
+          ...rolloutUpdates,
+          ...usage ? this.#usage(rolloutTokens(usage)) : [],
           { sessionUpdate: "state_update", state: "idle", stopReason: "end_turn" }
         ];
       }
+      /** A resumed turn with no rollout counts cannot separate its spend from earlier turns'. */
+      #usage(threadTotal) {
+        const context = { ...this.#tokens.context, costUsd: 0 };
+        if (this.#resumed && !this.#tokens.hasBaseline) {
+          return context.contextTokens === void 0 ? [] : [usageUpdate(context)];
+        }
+        return [codexUsageUpdate(this.#tokens.spend(threadTotal), context, "")];
+      }
       #failed(error62, fallback) {
         const message2 = errorText(error62?.message) || errorText(error62?.detail) || fallback.trim();
         const classified = message2 ? classifyCliError(normalizeCodexCliErrorMessage(message2)) : this.#lastError ?? specForErrorKind("provider_error");
@@ -35081,6 +35333,14 @@ function resolveAlanCodeModelId(selectedModel, models) {
   if (requested && models.some((model) => model.id === requested)) return requested;
   return models.find((model) => model.isDefault)?.id ?? firstModel.id;
 }
+function disabledInheritedMcp(own2, inherited) {
+  const disabled = {};
+  for (const name of inherited ?? []) {
+    if (name in own2) continue;
+    disabled[name] = { enabled: false };
+  }
+  return disabled;
+}
 function parseExisting(existing) {
   if (!existing?.trim()) return {};
   try {
@@ -35108,6 +35368,8 @@ function alanCodeConfigContent(existing, input2) {
   const prompt = input2.prompt ?? ALAN_CODE_BASELINE_PROMPT;
   const hiddenSkills = { skill: { "customize-opencode": "deny" } };
   const plugins = Array.isArray(config2.plugin) ? config2.plugin : [];
+  const ownMcp = field(config2, "mcp");
+  const mcp = { ...ownMcp, ...disabledInheritedMcp(ownMcp, input2.inheritedMcpServers) };
   return JSON.stringify({
     $schema: "https://opencode.ai/config.json",
     ...config2,
@@ -35116,6 +35378,7 @@ function alanCodeConfigContent(existing, input2) {
     // 3.4 GB of a dev machine's engine database was these patches, against 82 sessions. Alan
     // does not use the engine's undo/revert, so the tracking stays off.
     snapshot: false,
+    ...Object.keys(mcp).length ? { mcp } : {},
     model: `${ALAN_CODE_ENGINE_PROVIDER_ID}/${input2.modelId}`,
     enabled_providers: [ALAN_CODE_ENGINE_PROVIDER_ID],
     provider: {
@@ -35434,6 +35697,77 @@ function alanCodeEngineEnv(input2) {
     [ALAN_CODE_CONVERSATION_ID_ENV]: input2.conversationId
   };
 }
+function openCodeGlobalConfigDirectory(env, home) {
+  const configHome = env.XDG_CONFIG_HOME?.trim() || (0, import_path9.join)(home, ".config");
+  return (0, import_path9.join)(configHome, "opencode");
+}
+function stripJsonc(text3) {
+  let out = "";
+  let index = 0;
+  while (index < text3.length) {
+    const skipTo = commentEnd(text3, index);
+    if (skipTo !== void 0) {
+      index = skipTo;
+      continue;
+    }
+    const char = text3[index];
+    if (char === "}" || char === "]") out = out.replace(/,\s*$/, "");
+    const end = char === '"' ? stringLiteralEnd(text3, index) : index + 1;
+    out += text3.slice(index, end);
+    index = end;
+  }
+  return out;
+}
+function commentEnd(text3, index) {
+  const pair = text3.slice(index, index + 2);
+  if (pair === "//") {
+    const newline = text3.indexOf("\n", index);
+    return newline === -1 ? text3.length : newline;
+  }
+  if (pair === "/*") {
+    const close2 = text3.indexOf("*/", index + 2);
+    return close2 === -1 ? text3.length : close2 + 2;
+  }
+  return void 0;
+}
+function stringLiteralEnd(text3, start) {
+  let index = start + 1;
+  while (index < text3.length) {
+    const char = text3[index];
+    if (char === "\\") {
+      index += 2;
+    } else if (char === '"') {
+      return index + 1;
+    } else {
+      index += 1;
+    }
+  }
+  return text3.length;
+}
+function parseJsonc(text3) {
+  try {
+    return JSON.parse(text3);
+  } catch {
+    try {
+      return JSON.parse(stripJsonc(text3));
+    } catch {
+      return void 0;
+    }
+  }
+}
+async function inheritedMcpServerNames(configDirectory) {
+  const names = /* @__PURE__ */ new Set();
+  for (const file2 of ["config.json", "opencode.json", "opencode.jsonc"]) {
+    const text3 = await (0, import_promises34.readFile)((0, import_path9.join)(configDirectory, file2), "utf8").catch(() => null);
+    if (text3 === null) continue;
+    const parsed = parseJsonc(text3);
+    const mcp = parsed !== null && typeof parsed === "object" ? parsed.mcp : void 0;
+    if (mcp !== null && typeof mcp === "object") {
+      for (const name of Object.keys(mcp)) names.add(name);
+    }
+  }
+  return [...names];
+}
 async function writePlugin(directory, apiOrigin) {
   const origin = (0, import_crypto13.createHash)("sha256").update(apiOrigin).digest("hex").slice(0, 12);
   const target = (0, import_path9.join)(directory, `engine-plugin-v${ALAN_CODE_ENGINE_PLUGIN_VERSION}-${origin}.mjs`);
@@ -35448,9 +35782,10 @@ async function prepareAlanCodeProfile(input2) {
   await Promise.all(
     directories.map((directory) => (0, import_promises34.mkdir)(directory, { recursive: true, mode: 448 }))
   );
-  const [pluginUrl, models] = await Promise.all([
+  const [pluginUrl, models, inheritedMcpServers] = await Promise.all([
     writePlugin((0, import_path9.join)(input2.engineRoot, "plugin"), input2.access.apiOrigin),
-    (input2.loadModels ?? fetchAlanCodeModels)(input2.access)
+    (input2.loadModels ?? fetchAlanCodeModels)(input2.access),
+    input2.globalConfigDirectory === void 0 ? Promise.resolve([]) : inheritedMcpServerNames(input2.globalConfigDirectory)
   ]);
   const modelId = resolveAlanCodeModelId(input2.requestedModel, models);
   return {
@@ -35458,7 +35793,8 @@ async function prepareAlanCodeProfile(input2) {
       baseURL: `${input2.access.apiOrigin}${ALAN_CODE_PROXY_PATH}`,
       modelId,
       models,
-      pluginUrl
+      pluginUrl,
+      inheritedMcpServers
     }),
     model: { providerID: ALAN_CODE_ENGINE_PROVIDER_ID, modelID: modelId }
   };
@@ -36096,8 +36432,8 @@ var require_Node = __commonJS({
         };
         const res = toJS.toJS(this, "", ctx);
         if (typeof onAnchor === "function")
-          for (const { count, res: res2 } of ctx.anchors.values())
-            onAnchor(res2, count);
+          for (const { count: count2, res: res2 } of ctx.anchors.values())
+            onAnchor(res2, count2);
         return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res;
       }
     };
@@ -36203,13 +36539,13 @@ var require_Alias = __commonJS({
         const anchor2 = anchors2 && source && anchors2.get(source);
         return anchor2 ? anchor2.count * anchor2.aliasCount : 0;
       } else if (identity.isCollection(node2)) {
-        let count = 0;
+        let count2 = 0;
         for (const item of node2.items) {
           const c = getAliasCount(doc, item, anchors2);
-          if (c > count)
-            count = c;
+          if (c > count2)
+            count2 = c;
         }
-        return count;
+        return count2;
       } else if (identity.isPair(node2)) {
         const kc = getAliasCount(doc, node2.key, anchors2);
         const vc = getAliasCount(doc, node2.value, anchors2);
@@ -39162,8 +39498,8 @@ var require_Document = __commonJS({
         };
         const res = toJS.toJS(this.contents, jsonArg ?? "", ctx);
         if (typeof onAnchor === "function")
-          for (const { count, res: res2 } of ctx.anchors.values())
-            onAnchor(res2, count);
+          for (const { count: count2, res: res2 } of ctx.anchors.values())
+            onAnchor(res2, count2);
         return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res;
       }
       /**
@@ -39240,12 +39576,12 @@ var require_errors = __commonJS({
         lineStr = prev + lineStr;
       }
       if (/[^ ]/.test(lineStr)) {
-        let count = 1;
+        let count2 = 1;
         const end = error62.linePos[1];
         if (end?.line === line && end.col > col) {
-          count = Math.max(1, Math.min(end.col - col, 80 - ci));
+          count2 = Math.max(1, Math.min(end.col - col, 80 - ci));
         }
-        const pointer = " ".repeat(ci) + "^".repeat(count);
+        const pointer = " ".repeat(ci) + "^".repeat(count2);
         error62.message += `:
 
 ${lineStr}
@@ -39487,7 +39823,7 @@ var require_resolve_block_map = __commonJS({
       if (ctx.atRoot)
         ctx.atRoot = false;
       let offset = bm.offset;
-      let commentEnd = null;
+      let commentEnd2 = null;
       for (const collItem of bm.items) {
         const { start, key, sep: sep4, value: value2 } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
@@ -39507,7 +39843,7 @@ var require_resolve_block_map = __commonJS({
               onError(offset, "BAD_INDENT", startColMsg);
           }
           if (!keyProps.anchor && !keyProps.tag && !sep4) {
-            commentEnd = keyProps.end;
+            commentEnd2 = keyProps.end;
             if (keyProps.comment) {
               if (map2.comment)
                 map2.comment += "\n" + keyProps.comment;
@@ -39569,9 +39905,9 @@ var require_resolve_block_map = __commonJS({
           map2.items.push(pair);
         }
       }
-      if (commentEnd && commentEnd < offset)
-        onError(commentEnd, "IMPOSSIBLE", "Map comment with trailing content");
-      map2.range = [bm.offset, offset, commentEnd ?? offset];
+      if (commentEnd2 && commentEnd2 < offset)
+        onError(commentEnd2, "IMPOSSIBLE", "Map comment with trailing content");
+      map2.range = [bm.offset, offset, commentEnd2 ?? offset];
       return map2;
     }
     exports2.resolveBlockMap = resolveBlockMap;
@@ -39593,7 +39929,7 @@ var require_resolve_block_seq = __commonJS({
       if (ctx.atKey)
         ctx.atKey = false;
       let offset = bs.offset;
-      let commentEnd = null;
+      let commentEnd2 = null;
       for (const { start, value: value2 } of bs.items) {
         const props = resolveProps.resolveProps(start, {
           indicator: "seq-item-ind",
@@ -39610,7 +39946,7 @@ var require_resolve_block_seq = __commonJS({
             else
               onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
           } else {
-            commentEnd = props.end;
+            commentEnd2 = props.end;
             if (props.comment)
               seq.comment = props.comment;
             continue;
@@ -39622,7 +39958,7 @@ var require_resolve_block_seq = __commonJS({
         offset = node2.range[2];
         seq.items.push(node2);
       }
-      seq.range = [bs.offset, offset, commentEnd ?? offset];
+      seq.range = [bs.offset, offset, commentEnd2 ?? offset];
       return seq;
     }
     exports2.resolveBlockSeq = resolveBlockSeq;
@@ -45295,8 +45631,8 @@ var require_tar_stream = __commonJS({
 var init_dist = __esm({
   "../agent-core/dist/index.js"() {
     "use strict";
-    init_chunk_FYZKVT3E();
-    init_chunk_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_YXWJW7I5();
@@ -45655,24 +45991,30 @@ function tokens(record2, ...keys) {
   }
   return void 0;
 }
-function promptUsage(result, fallbackModel) {
-  const usage = asRecord(result.usage) ?? asRecord(result._meta);
+function contextOf(update) {
+  const used = asFiniteNumber(update.used);
+  const size = asFiniteNumber(update.size);
+  if (used === void 0 || used <= 0) return void 0;
+  return { contextTokens: used, ...size !== void 0 && size > 0 ? { contextSize: size } : {} };
+}
+function promptSpend(result, profile) {
+  const meta3 = asRecord(result._meta);
+  const usage = asRecord(result.usage) ?? asRecord(meta3?.usage) ?? meta3;
   const input2 = tokens(usage, "inputTokens", "input_tokens");
   const output2 = tokens(usage, "outputTokens", "output_tokens");
   if (input2 === void 0 && output2 === void 0) return void 0;
   const thoughts = tokens(usage, "thoughtTokens", "reasoningTokens") ?? 0;
-  const meta3 = asRecord(result._meta);
-  return usageUpdate(
-    {
-      inputTokens: input2 ?? 0,
-      outputTokens: (output2 ?? 0) + thoughts,
-      cacheReadTokens: tokens(usage, "cachedReadTokens", "cacheReadTokens") ?? 0,
-      cacheCreationTokens: tokens(usage, "cachedWriteTokens", "cacheWriteTokens") ?? 0,
-      costUsd: 0,
-      ...asString(meta3?.modelId) ? { model: asString(meta3?.modelId) } : {}
-    },
-    fallbackModel
-  );
+  const cacheRead = tokens(usage, "cachedReadTokens", "cacheReadTokens") ?? 0;
+  const cacheWrite = tokens(usage, "cachedWriteTokens", "cacheWriteTokens") ?? 0;
+  const uncached = profile.promptInputIncludesCache ? Math.max((input2 ?? 0) - cacheRead - cacheWrite, 0) : input2 ?? 0;
+  return {
+    inputTokens: uncached,
+    outputTokens: (output2 ?? 0) + thoughts,
+    cacheReadTokens: cacheRead,
+    cacheCreationTokens: cacheWrite,
+    costUsd: 0,
+    ...asString(meta3?.modelId) ? { model: asString(meta3?.modelId) } : {}
+  };
 }
 function pendingAnswer2(pending, answer) {
   switch (pending.kind) {
@@ -46042,8 +46384,8 @@ 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_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -46273,9 +46615,52 @@ var init_acp3 = __esm({
       #bursts = /* @__PURE__ */ new Map();
       #counter = 0;
       #failure;
-      constructor(prefix, profile) {
+      #context;
+      #spend;
+      #onContext;
+      /** `context` is what the session's last turn left, until this turn reports its own. */
+      constructor(prefix, profile, context) {
         this.#prefix = prefix;
         this.#profile = profile;
+        this.#context = context;
+      }
+      get context() {
+        return this.#context;
+      }
+      /** The prompt's answer: what the turn spent, with the context so far, as one update. */
+      settle(result, fallbackModel) {
+        this.#spend = promptSpend(result, this.#profile);
+        return this.#usage(fallbackModel);
+      }
+      /** Resolves on the next `usage_update`, or after `ms`. */
+      async nextContext(ms, sleep) {
+        await Promise.race([
+          new Promise((resolve13) => {
+            this.#onContext = resolve13;
+          }),
+          sleep(ms)
+        ]);
+        this.#onContext = void 0;
+      }
+      /** Ends a `nextContext` wait at once: the turn is being cancelled. */
+      stopWaiting() {
+        this.#onContext?.();
+      }
+      /**
+       * The chat keeps a turn's last usage update, so each one carries both the spend and the
+       * context. An agent's own `usage_update` is context only and must not read as spend.
+       */
+      #noteContext(update) {
+        const context = contextOf(update);
+        if (!context) return [];
+        this.#context = context;
+        this.#onContext?.();
+        const usage = this.#usage(this.#spend?.model ?? "");
+        return usage ? [usage] : [];
+      }
+      #usage(fallbackModel) {
+        if (!this.#spend && !this.#context) return void 0;
+        return usageUpdate({ ...this.#spend, ...this.#context }, fallbackModel);
       }
       /** The first cause a vendor frame named; the prompt's own error is usually generic. */
       get failure() {
@@ -46305,6 +46690,8 @@ var init_acp3 = __esm({
                 entries: Array.isArray(update.entries) ? update.entries : []
               }
             ];
+          case "usage_update":
+            return this.#noteContext(update);
           case "current_mode_update":
             return [
               noticeUpdate("info", "mode_changed", asString(update.currentModeId) || "mode changed")
@@ -46430,7 +46817,13 @@ var init_acp3 = __esm({
           return active.done;
         }
         const prompt = this.#promptBlocks(input2);
-        this.#rpc.request("session/prompt", { sessionId, prompt }).then((result) => active.finish(this.#promptOutcome(active, asRecord(result) ?? {}))).catch((error62) => {
+        this.#rpc.request("session/prompt", { sessionId, prompt }).then(async (result) => {
+          const record2 = asRecord(result) ?? {};
+          const trailing = this.#profile.trailingUsageMs;
+          if (trailing && !active.cancelRequested)
+            await active.turn.nextContext(trailing, (ms) => this.#options.clock.sleep(ms));
+          active.finish(this.#promptOutcome(active, record2));
+        }).catch((error62) => {
           if (this.#state === "closed") return;
           active.finish(this.#errorOutcome(active, error62));
         });
@@ -46511,7 +46904,7 @@ var init_acp3 = __esm({
         ];
       }
       #promptOutcome(active, result) {
-        const usage = promptUsage(result, this.#config?.model ?? this.#profile.backendKind);
+        const usage = active.turn.settle(result, this.#config?.model ?? this.#profile.backendKind);
         if (usage) this.#emit({ type: "update", turnId: active.id, update: usage });
         const stopReason = asString(result.stopReason);
         const failure22 = active.turn.failure;
@@ -46545,6 +46938,7 @@ var init_acp3 = __esm({
       async #stopTurn(active) {
         if (active.cancelRequested) return active.done.then(() => void 0);
         active.cancelRequested = true;
+        active.turn.stopWaiting();
         const rung = await runCancelLadder({
           clock: this.#options.clock,
           graceMs: this.#options.interruptGraceMs,
@@ -46570,14 +46964,14 @@ var init_acp3 = __esm({
       }
       #startTurn(id) {
         this.#turns += 1;
-        const turn = new AcpTurn(`acp-${this.#turns}-${id}`, this.#profile);
+        const turn = new AcpTurn(`acp-${this.#turns}-${id}`, this.#profile, this.#idleTurn.context);
         let finish = () => {
         };
         const done = new Promise((resolve13) => {
           finish = (outcome2) => {
             if (this.#current?.id !== id) return;
             this.#current = void 0;
-            this.#idleTurn = new AcpTurn(`acp-between-${this.#turns}`, this.#profile);
+            this.#idleTurn = new AcpTurn(`acp-between-${this.#turns}`, this.#profile, turn.context);
             if (this.#state === "busy") this.#state = "idle";
             this.#host.scanDescendants(true);
             this.#emit({ type: "turn_ended", turnId: id, outcome: outcome2 });
@@ -46816,6 +47210,8 @@ var init_acp3 = __esm({
       }
     };
     grokAcpProfile = {
+      // Grok's ACP `inputTokens` is the full prompt; its own docs say only headless output subtracts cache.
+      promptInputIncludesCache: true,
       backendKind: "grok_cli",
       displayName: "Grok CLI",
       defaultCommand: "grok",
@@ -46846,7 +47242,9 @@ var init_acp3 = __esm({
       requirement: { cli: "kimi", feature: "`kimi acp`" },
       launchArgs: () => ["acp"],
       modelChannel: "session",
-      exitsOnStdinEof: true
+      exitsOnStdinEof: true,
+      // Kimi answers the prompt, then reads its context size and pushes `usage_update`.
+      trailingUsageMs: 1e3
     };
     ACP_PROFILES = {
       cursor_agent_cli: cursorAcpProfile,
@@ -47080,9 +47478,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") {
@@ -47176,6 +47584,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;
       }
@@ -47672,8 +48081,22 @@ function codeModeChildUpdates(tool, metadata) {
     };
   });
 }
+function stepContextTokens(step, total) {
+  const sum = step.inputTokens + step.outputTokens + step.cacheReadTokens + step.cacheCreationTokens;
+  const tokens2 = total !== void 0 && total > 0 ? total : sum;
+  return tokens2 > 0 ? tokens2 : void 0;
+}
+function addStepUsage(turn, step) {
+  return {
+    inputTokens: turn.inputTokens + step.inputTokens,
+    outputTokens: turn.outputTokens + step.outputTokens,
+    cacheReadTokens: turn.cacheReadTokens + step.cacheReadTokens,
+    cacheCreationTokens: turn.cacheCreationTokens + step.cacheCreationTokens,
+    costUsd: turn.costUsd === void 0 && step.costUsd === void 0 ? void 0 : (turn.costUsd ?? 0) + (step.costUsd ?? 0)
+  };
+}
 function createOpenCodeSessionMemory() {
-  return { userMessageIds: /* @__PURE__ */ new Set() };
+  return { userMessageIds: /* @__PURE__ */ new Set(), contextWindows: /* @__PURE__ */ new Map() };
 }
 function only(updates) {
   return { updates, actions: [] };
@@ -48006,12 +48429,12 @@ function openCodeTurnInput(run2, context) {
     ...images.length ? { imagePaths: images.map((image) => image.path) } : {}
   };
 }
-var import_crypto15, import_http10, import_crypto16, import_promises52, import_path11, import_path12, import_url2, import_crypto17, IDLE_SOCKET_MS3, OpenCodeHttpError, BASE62, messageIdClock, OpenCodeClient, OPENCODE_CONFIG_ENV, OPENCODE_ENGINE, TEXT_PARTS, STEP_PARTS, STOPPED_BY_USER, OpenCodeSubagents, NAMED_KINDS, OPENCODE_ABORTED_ERROR, PROVIDER_EVENT_META, TASK_TOOL_NAME, TASK_RESULT_TAG, TASK_ERROR_TAG, PERMISSION_DENIED, FILE_OPERATIONS2, PartReader, NOTHING, NON_INTERACTIVE_PERMISSIONS, CONTENT_FILTER_FINISHES, TRUNCATED_FINISHES, OUTPUT_PARTS, OpenCodeTurn, LISTENING, OUTPUT_TAIL_LINES, IMAGE_TYPES, OpenCodeSession, OPENCODE_MIN_VERSION, OPENCODE_REQUIREMENT, OPENCODE_TESTED_LINE, OPENCODE_SUPPORTED_MAJOR, DEFAULTS4, STORE_LOCKED, NON_INTERACTIVE_RULES, TITLE_LENGTH, MAX_VARIANT_LENGTH;
+var import_crypto15, import_http10, import_crypto16, import_promises52, import_path11, import_path12, import_url2, import_crypto17, IDLE_SOCKET_MS3, OpenCodeHttpError, BASE62, messageIdClock, OpenCodeClient, OPENCODE_CONFIG_ENV, OPENCODE_ENGINE, TEXT_PARTS, STEP_PARTS, STOPPED_BY_USER, OpenCodeSubagents, NAMED_KINDS, OPENCODE_ABORTED_ERROR, PROVIDER_EVENT_META, TASK_TOOL_NAME, TASK_RESULT_TAG, TASK_ERROR_TAG, PERMISSION_DENIED, FILE_OPERATIONS2, NO_USAGE, PartReader, NOTHING, NON_INTERACTIVE_PERMISSIONS, CONTENT_FILTER_FINISHES, TRUNCATED_FINISHES, OUTPUT_PARTS, OpenCodeTurn, LISTENING, OUTPUT_TAIL_LINES, IMAGE_TYPES, OpenCodeSession, OPENCODE_MIN_VERSION, OPENCODE_REQUIREMENT, OPENCODE_TESTED_LINE, OPENCODE_SUPPORTED_MAJOR, DEFAULTS4, STORE_LOCKED, NON_INTERACTIVE_RULES, TITLE_LENGTH, MAX_VARIANT_LENGTH;
 var init_opencode = __esm({
   "../agent-core/dist/providers/opencode.js"() {
     "use strict";
-    init_chunk_FYZKVT3E();
-    init_chunk_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -48193,6 +48616,22 @@ var init_opencode = __esm({
         const providers = Array.isArray(body?.providers) ? body.providers : [];
         return providers.map((provider4) => asString(asRecord(provider4)?.id)).filter(Boolean);
       }
+      /** `provider/model` \u2192 the model's context limit; 0 (a custom model's unknown) is left out. */
+      async modelContextWindows() {
+        const body = asRecord(await this.#call("provider list", "GET", "/config/providers"));
+        const windows = /* @__PURE__ */ new Map();
+        for (const provider4 of Array.isArray(body?.providers) ? body.providers : []) {
+          const record2 = asRecord(provider4);
+          const providerId = asString(record2?.id);
+          for (const [modelId, model] of Object.entries(asRecord(record2?.models) ?? {})) {
+            const limit = asFiniteNumber(asRecord(asRecord(model)?.limit)?.context);
+            if (providerId && limit !== void 0 && limit > 0) {
+              windows.set(`${providerId}/${modelId}`, limit);
+            }
+          }
+        }
+        return windows;
+      }
       /** Asks emitted while disconnected must still get a reply. Older engines may lack these routes. */
       async pendingAsks() {
         const read = async (path4, type) => {
@@ -48424,6 +48863,13 @@ var init_opencode = __esm({
       ["delete", "delete"],
       ["update", "modify"]
     ]);
+    NO_USAGE = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      costUsd: void 0
+    };
     PartReader = class {
       /** messageID \u2192 part ids in arrival order, so a multi-part message keeps its order. */
       #order = /* @__PURE__ */ new Map();
@@ -48433,6 +48879,7 @@ var init_opencode = __esm({
       /** To-do calls already sent as a plan; the running and completed frames repeat the input. */
       #planned = /* @__PURE__ */ new Set();
       #steps = /* @__PURE__ */ new Set();
+      #turnUsage = NO_USAGE;
       #partIds = /* @__PURE__ */ new Set();
       #anonymous = 0;
       #retainedChars = 0;
@@ -48447,6 +48894,9 @@ var init_opencode = __esm({
       }
       /** `provider/model` from the assistant message; step-finish frames do not repeat it. */
       model;
+      /** The model's context limit, when the server listed it. */
+      contextWindow;
+      #contextTokens;
       part(part, parentToolCallId) {
         const id = asString(part.id);
         if (id) this.#partIds.add(id);
@@ -48455,7 +48905,7 @@ var init_opencode = __esm({
             "protocol_violation",
             "Alan Code exceeded the retained event limit. Continue in a new turn."
           );
-        return withParent(this.#read(part), parentToolCallId);
+        return withParent(this.#read(part, parentToolCallId !== void 0), parentToolCallId);
       }
       /** A delta names only its part; the role and message come from the part's opening snapshot. */
       delta(partId, field3, delta, parentToolCallId) {
@@ -48467,7 +48917,7 @@ var init_opencode = __esm({
         const update = role === "text" ? { sessionUpdate: "agent_message_chunk", messageId, content } : { sessionUpdate: "agent_thought_chunk", messageId: `${messageId}:reasoning`, content };
         return withParent([update], parentToolCallId);
       }
-      #read(part) {
+      #read(part, child) {
         const type = asString(part.type);
         switch (type) {
           case "step-start":
@@ -48483,7 +48933,7 @@ var init_opencode = __esm({
             return this.#tool(part);
           case "step-finish":
           case "step_finish":
-            return this.#stepFinish(part);
+            return this.#stepFinish(part, child);
           case "snapshot":
           case "patch":
             return [];
@@ -48549,6 +48999,31 @@ var init_opencode = __esm({
         }
         return updates;
       }
+      #stepUsage(part, tokens2, child) {
+        const cache2 = asRecord(tokens2.cache);
+        const step = {
+          inputTokens: asFiniteNumber(tokens2.input) ?? 0,
+          // OpenCode counts reasoning apart from output, and cache apart from input.
+          outputTokens: (asFiniteNumber(tokens2.output) ?? 0) + (asFiniteNumber(tokens2.reasoning) ?? 0),
+          cacheReadTokens: asFiniteNumber(cache2?.read) ?? 0,
+          cacheCreationTokens: asFiniteNumber(cache2?.write) ?? 0
+        };
+        if (!child) this.#contextTokens = stepContextTokens(step, asFiniteNumber(tokens2.total));
+        this.#turnUsage = addStepUsage(this.#turnUsage, {
+          ...step,
+          costUsd: asFiniteNumber(part.cost)
+        });
+        const { costUsd, ...turnTokens } = this.#turnUsage;
+        return usageUpdate(
+          {
+            ...turnTokens,
+            ...costUsd === void 0 ? {} : { costUsd },
+            ...this.#contextTokens === void 0 ? {} : { contextTokens: this.#contextTokens },
+            ...this.contextWindow === void 0 ? {} : { contextSize: this.contextWindow }
+          },
+          this.model
+        );
+      }
       /** OpenCode's to-do list is the plan, sent once per call although every frame repeats it. */
       #plan(toolCallId, name, toolState) {
         const todos = asRecord(toolState?.input)?.todos;
@@ -48557,28 +49032,12 @@ var init_opencode = __esm({
         this.#planned.add(toolCallId);
         return [todoPlanUpdate(toolCallId, todos)];
       }
-      #stepFinish(part) {
+      #stepFinish(part, child) {
         const id = asString(part.id);
         if (id && this.#steps.has(id)) return [];
         if (id) this.#steps.add(id);
-        const updates = [];
         const tokens2 = asRecord(part.tokens);
-        if (tokens2) {
-          const cache2 = asRecord(tokens2.cache);
-          const cost = asFiniteNumber(part.cost);
-          updates.push(
-            usageUpdate(
-              {
-                inputTokens: asFiniteNumber(tokens2.input) ?? 0,
-                outputTokens: asFiniteNumber(tokens2.output) ?? 0,
-                cacheReadTokens: asFiniteNumber(cache2?.read) ?? 0,
-                cacheCreationTokens: asFiniteNumber(cache2?.write) ?? 0,
-                ...cost === void 0 ? {} : { costUsd: cost }
-              },
-              this.model
-            )
-          );
-        }
+        const updates = tokens2 ? [this.#stepUsage(part, tokens2, child)] : [];
         const reason = asString(part.reason);
         if (reason === "stop") {
           updates.push({ sessionUpdate: "state_update", state: "idle", stopReason: "end_turn" });
@@ -48763,7 +49222,10 @@ var init_opencode = __esm({
         if (finish) this.#finish = finish;
         const provider4 = asString(info.providerID);
         const model = asString(info.modelID);
-        if (provider4 && model) this.#parts.model = `${provider4}/${model}`;
+        if (provider4 && model) {
+          this.#parts.model = `${provider4}/${model}`;
+          this.#parts.contextWindow = this.#memory.contextWindows.get(this.#parts.model);
+        }
         const error62 = asRecord(info.error);
         if (!error62 || isAbortError(error62) || this.#error) return [];
         return this.#fail(classifyOpenCodeError(error62, `${this.#engine.label} session error.`));
@@ -48968,6 +49430,9 @@ var init_opencode = __esm({
       /** Subscribes before the session exists, so `session.created` and early asks are seen. */
       async connect(client) {
         this.#client = client;
+        client.modelContextWindows().then((windows) => {
+          this.#memory.contextWindows = windows;
+        }).catch(() => void 0);
         this.#events?.close();
         this.#events = await client.events({
           onEvent: (event) => {
@@ -49376,7 +49841,9 @@ function createAlanCodeHolderDriver(options) {
   });
   const env = options.cliEnvironment;
   const engine = resolveAlanCodeEngine({ env, platform: platform3, packaged: [] });
-  const engineRoot = alanCodeEngineRoot(env.HOME?.trim() || (0, import_node_os7.homedir)());
+  const home = env.HOME?.trim() || (0, import_node_os7.homedir)();
+  const engineRoot = alanCodeEngineRoot(home);
+  const globalConfigDirectory = openCodeGlobalConfigDirectory(env, home);
   options.log.info("alan_code.engine", { command: engine.command, source: engine.source });
   const open6 = async (planned) => {
     if (planned.profile === void 0) throw refuseWithoutCredential();
@@ -49414,6 +49881,7 @@ function createAlanCodeHolderDriver(options) {
             conversationId: spec.conversationId
           },
           engineRoot,
+          globalConfigDirectory,
           requestedModel: spec.model
         };
         const skills = options.installedSkills?.() ?? null;
@@ -50061,8 +50529,8 @@ 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_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -50107,7 +50575,10 @@ var init_droid = __esm({
         const notification = asRecord(params.notification);
         if (!notification) return [];
         const sessionId = asString(params.sessionId);
-        if (!sessionId || sessionId === this.#sessionId) return this.#read(notification);
+        if (!sessionId || sessionId === this.#sessionId) {
+          this.#noteContext(notification);
+          return this.#read(notification);
+        }
         const launcher = this.#memory.childLaunchers.get(sessionId);
         if (!launcher) return [];
         return this.#read(notification).map(
@@ -50117,6 +50588,14 @@ var init_droid = __esm({
           })
         );
       }
+      /** Droid's own context figure: the last call's input, cache reads and output. */
+      #noteContext(notification) {
+        if (asString(notification.type) !== "session_token_usage_changed") return;
+        const last = asRecord(notification.lastCallTokenUsage);
+        if (!last) return;
+        const tokens2 = (asFiniteNumber(last.inputTokens) ?? 0) + (asFiniteNumber(last.cacheReadTokens) ?? 0) + (asFiniteNumber(last.outputTokens) ?? 0);
+        if (tokens2 > 0) this.#memory.contextTokens = tokens2;
+      }
       #read(notification) {
         const type = asString(notification.type);
         if (SILENT2.has(type)) return [];
@@ -50191,6 +50670,7 @@ var init_droid = __esm({
               cacheCreationTokens: number4(usage?.cacheCreationTokens),
               numTurns: 1,
               ...duration3 === void 0 ? {} : { durationMs: duration3 },
+              ...this.#memory.contextTokens === void 0 ? {} : { contextTokens: this.#memory.contextTokens },
               costUsd: 0
             },
             this.#memory.model ?? "droid"
@@ -50999,6 +51479,23 @@ function providerError2(_grammar, frame) {
 function spellings(types, handle) {
   return types.map((type) => [type, handle]);
 }
+function stepTokens(stats) {
+  return {
+    inputTokens: firstNumber2(stats.input_tokens, stats.input),
+    outputTokens: firstNumber2(stats.output_tokens) + firstNumber2(stats.thinking_tokens),
+    cacheReadTokens: firstNumber2(stats.cache_read_tokens, stats.cached_input_tokens, stats.cached),
+    cacheCreationTokens: 0
+  };
+}
+function addStepTokens(total, step) {
+  if (!total) return step;
+  return {
+    inputTokens: total.inputTokens + step.inputTokens,
+    outputTokens: total.outputTokens + step.outputTokens,
+    cacheReadTokens: total.cacheReadTokens + step.cacheReadTokens,
+    cacheCreationTokens: total.cacheCreationTokens + step.cacheCreationTokens
+  };
+}
 function firstNumber2(...values) {
   for (const value2 of values) {
     const number4 = asFiniteNumber(value2);
@@ -51170,9 +51667,9 @@ var import_promises54, import_path13, import_fs9, import_path14, import_path15,
 var init_antigravity = __esm({
   "../agent-core/dist/providers/antigravity.js"() {
     "use strict";
-    init_chunk_D4TIXPWZ();
-    init_chunk_FYZKVT3E();
-    init_chunk_OUEMTEUX();
+    init_chunk_TFIO37PI();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -51530,6 +52027,11 @@ var init_antigravity = __esm({
       /** What `--conversation` takes: a frame's `conversation_id` wins over its `session_id`. */
       #conversationId;
       #forkReported = false;
+      /** The conversation this turn runs in; a subagent's steps come under another id. */
+      #rootConversation;
+      /** The sum of this turn's own steps: the result's usage is the whole conversation's. */
+      #stepSpend;
+      #contextTokens;
       constructor(options) {
         this.#options = options;
         this.#conversationId = options.resumeId;
@@ -51576,7 +52078,9 @@ var init_antigravity = __esm({
         const type = asString(frame.type);
         if (!type) return [];
         this.#conversationId = antigravityString(frame, "conversation_id") ?? antigravityString(frame, "session_id") ?? this.#conversationId;
+        this.#rootConversation ??= this.#conversationId;
         this.#track(type, frame);
+        this.#noteStep(type, frame);
         const forked = this.#silentFork();
         if (SESSION_START_TYPES.has(type)) {
           return [
@@ -51591,6 +52095,29 @@ var init_antigravity = __esm({
         if (RESULT_TYPES.has(type)) return [...forked, ...this.#onResult(type, frame)];
         return [...forked, ...this.#transcripts?.read() ?? []];
       }
+      /** A finished answer step of this conversation: one model call, with its own usage. */
+      #noteStep(type, frame) {
+        if (type !== "assistant_message" || asString(frame.state).toUpperCase() !== "DONE") return;
+        const usage = asRecord(frame.usage);
+        if (!usage) return;
+        const conversation = antigravityString(frame, "conversation_id");
+        if (conversation && this.#rootConversation && conversation !== this.#rootConversation) return;
+        const step = stepTokens(usage);
+        this.#stepSpend = addStepTokens(this.#stepSpend, step);
+        const context = step.inputTokens + step.cacheReadTokens + step.outputTokens;
+        if (context > 0) this.#contextTokens = context;
+      }
+      /**
+       * agy's result usage is cumulative over the conversation, so a resumed turn's spend comes
+       * from its steps; a first turn's result is its own.
+       */
+      #turnSpend(frame) {
+        const steps = this.#stepSpend;
+        this.#stepSpend = void 0;
+        if (steps) return steps;
+        if (this.#options.resumeId) return void 0;
+        return stepTokens(asRecord(frame.usage) ?? asRecord(frame.stats) ?? frame);
+      }
       #track(type, frame) {
         const transcripts = this.#transcripts;
         if (!transcripts) return;
@@ -51608,6 +52135,22 @@ var init_antigravity = __esm({
         this.#forkReported = true;
         return [noticeUpdate("warning", "session_resume_failed", RESUME_FORKED)];
       }
+      #resultUsage(frame) {
+        const spend = this.#turnSpend(frame);
+        const contextTokens = this.#contextTokens;
+        if (!spend && contextTokens === void 0) return [];
+        const stats = asRecord(frame.usage) ?? asRecord(frame.stats) ?? frame;
+        return [
+          usageUpdate({
+            model: formatAntigravityModelName(this.#model()),
+            numTurns: Math.max(this.#iterations, 1),
+            durationMs: asFiniteNumber(stats.duration_ms) ?? 0,
+            ...spend,
+            ...contextTokens === void 0 ? {} : { contextTokens },
+            costUsd: 0
+          })
+        ];
+      }
       #onResult(type, frame) {
         const updates = [];
         this.#iterations = Math.max(this.#iterations, asFiniteNumber(frame.num_turns) ?? 1);
@@ -51616,23 +52159,7 @@ var init_antigravity = __esm({
           updates.push(agentText(`antigravity-${this.#conversationId ?? "run"}-result`, resultText3));
           this.#resultShown = true;
         }
-        const stats = asRecord(frame.usage) ?? asRecord(frame.stats) ?? frame;
-        updates.push(
-          usageUpdate({
-            model: formatAntigravityModelName(this.#model()),
-            numTurns: Math.max(this.#iterations, 1),
-            durationMs: asFiniteNumber(stats.duration_ms) ?? 0,
-            inputTokens: firstNumber2(stats.input_tokens, stats.input),
-            outputTokens: firstNumber2(stats.output_tokens),
-            cacheReadTokens: firstNumber2(
-              stats.cache_read_tokens,
-              stats.cached_input_tokens,
-              stats.cached
-            ),
-            cacheCreationTokens: 0,
-            costUsd: 0
-          })
-        );
+        updates.push(...this.#resultUsage(frame));
         const status = asString(frame.status).toLowerCase();
         const succeeded = !status || SUCCESSFUL_STATUSES.has(status);
         if (succeeded) {
@@ -51875,8 +52402,8 @@ 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_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -52241,6 +52768,7 @@ var init_command_code = __esm({
       #streamed = false;
       #totals;
       #result;
+      #contextTokens;
       constructor(options) {
         this.#options = options;
         if (options.resumeId) this.#grammar.sessionId = options.resumeId;
@@ -52283,6 +52811,8 @@ var init_command_code = __esm({
       #onEvent(event) {
         switch (commandCodeString(event.type)) {
           case "model_request_end":
+            this.#noteContext(event.usage);
+            return this.#usage(event.usage);
           case "turn_end":
             return this.#usage(event.usage);
           case "run_end": {
@@ -52334,7 +52864,28 @@ var init_command_code = __esm({
           durationMs: durationMs ?? previous?.durationMs ?? 0
         };
         this.#totals = totals;
-        return [usageUpdate({ model: this.#model(), numTurns: 1, ...totals, costUsd: 0 })];
+        return [
+          usageUpdate({
+            model: this.#model(),
+            numTurns: 1,
+            ...totals,
+            // Command Code's own cost estimate takes cache out of inputTokens, which counts it.
+            inputTokens: Math.max(
+              totals.inputTokens - totals.cacheReadTokens - totals.cacheCreationTokens,
+              0
+            ),
+            ...this.#contextTokens === void 0 ? {} : { contextTokens: this.#contextTokens },
+            costUsd: 0
+          })
+        ];
+      }
+      /** One model call's prompt, cache included, plus its reply: what it left in the window. */
+      #noteContext(usage) {
+        const record2 = asRecord(usage);
+        const input2 = asFiniteNumber(record2?.inputTokens) ?? asFiniteNumber(record2?.input_tokens);
+        if (input2 === void 0 || input2 <= 0) return;
+        const output2 = asFiniteNumber(record2?.outputTokens) ?? asFiniteNumber(record2?.output_tokens);
+        this.#contextTokens = input2 + (output2 ?? 0);
       }
     };
     COMMAND_CODE_MAX_TURNS = 1e4;
@@ -57278,7 +57829,7 @@ var require_websocket_server = __commonJS({
 // package.json
 var package_default = {
   name: "@alan-ai-hq/agent-manager",
-  version: "0.1.159",
+  version: "0.1.161",
   private: true,
   type: "module",
   description: "Alan machine runtime (alan-agent): identity, link, reconciler, session holders, run log, uploader, local API",
@@ -58098,6 +58649,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;
@@ -58166,6 +58718,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));
     }
   };
 }
@@ -58757,15 +59336,15 @@ var BRANCH_LABEL_MAX_LENGTH = 256;
 var HASH_OBJECT_BATCH = 128;
 function countPorcelainEntries(output2) {
   const records = output2.split("\0");
-  let count = 0;
+  let count2 = 0;
   for (let index = 0; index < records.length; index += 1) {
     const record2 = records[index];
     if (!record2) continue;
-    count += 1;
+    count2 += 1;
     const status = record2.slice(0, 2);
     if (status.includes("R") || status.includes("C")) index += 1;
   }
-  return count;
+  return count2;
 }
 function sanitizeBranch(value2) {
   const printable = Array.from(value2.trim()).filter((character) => {
@@ -60730,6 +61309,7 @@ function runtimePaths(stateDir) {
 
 // src/platform/process-memory.ts
 var import_node_child_process4 = require("child_process");
+var import_node_fs7 = require("fs");
 var import_promises16 = require("fs/promises");
 var import_node_os2 = require("os");
 var import_node_util3 = require("util");
@@ -60797,12 +61377,52 @@ function readMemoryPressure() {
   if (process.platform === "linux") return linuxPressure();
   return Promise.resolve("normal");
 }
+function parseDarwinVmStat(output2) {
+  const pageSize = Number(/page size of (\d+) bytes/.exec(output2)?.[1]);
+  if (!Number.isFinite(pageSize) || pageSize <= 0) return null;
+  const pages = (name) => {
+    const match = new RegExp(`^Pages ${name}:\\s+(\\d+)\\.?$`, "m").exec(output2);
+    return match ? Number(match[1]) : null;
+  };
+  const free = pages("free");
+  if (free === null) return null;
+  return (free + (pages("inactive") ?? 0) + (pages("speculative") ?? 0)) * pageSize;
+}
+function parseLinuxMemInfo(output2) {
+  const kilobytes = /^MemAvailable:\s+(\d+)\s+kB$/m.exec(output2)?.[1];
+  return kilobytes === void 0 ? null : Number(kilobytes) * 1024;
+}
+var CAPACITY_PROBE_TTL_MS = 2e3;
+var AvailableMemoryProbe = class {
+  cached = null;
+  read(now) {
+    if (this.cached !== null && now - this.cached.at < CAPACITY_PROBE_TTL_MS) {
+      return this.cached.bytes;
+    }
+    let bytes = null;
+    try {
+      if (process.platform === "darwin") {
+        bytes = parseDarwinVmStat(
+          (0, import_node_child_process4.execFileSync)("vm_stat", { encoding: "utf8", timeout: PROBE_TIMEOUT_MS })
+        );
+      } else if (process.platform === "linux") {
+        bytes = parseLinuxMemInfo((0, import_node_fs7.readFileSync)("/proc/meminfo", "utf8"));
+      }
+    } catch {
+      bytes = null;
+    }
+    this.cached = { at: now, bytes };
+    return bytes;
+  }
+};
+var availableMemoryProbe = new AvailableMemoryProbe();
 function readMemoryCapacity() {
   const constrained = process.constrainedMemory();
-  return {
-    totalBytes: constrained > 0 ? Math.min((0, import_node_os2.totalmem)(), constrained) : (0, import_node_os2.totalmem)(),
-    availableBytes: typeof process.availableMemory === "function" ? process.availableMemory() : (0, import_node_os2.freemem)()
-  };
+  const totalBytes = constrained > 0 ? Math.min((0, import_node_os2.totalmem)(), constrained) : (0, import_node_os2.totalmem)();
+  const reported = typeof process.availableMemory === "function" ? process.availableMemory() : (0, import_node_os2.freemem)();
+  const probed = constrained > 0 && process.platform === "linux" ? null : availableMemoryProbe.read(Date.now());
+  const availableBytes = Math.min(totalBytes, Math.max(reported, probed ?? reported));
+  return { totalBytes, availableBytes };
 }
 async function processMemoryRows() {
   if (process.platform === "win32") {
@@ -61282,7 +61902,7 @@ var import_promises20 = require("fs/promises");
 var import_node_path17 = require("path");
 
 // src/platform/service/windows-service.ts
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_promises19 = require("fs/promises");
 var import_node_path16 = require("path");
 
@@ -61512,7 +62132,7 @@ function windowsManager(host, profile) {
     name: files.runValue,
     definitionPath: files.config,
     install: async (spec, { restart }) => {
-      if (process.platform === "win32" && !(0, import_node_fs7.existsSync)(files.helper)) {
+      if (process.platform === "win32" && !(0, import_node_fs8.existsSync)(files.helper)) {
         throw new RuntimeFault("io_failed", `Windows helper is missing: ${files.helper}`);
       }
       await (0, import_promises19.mkdir)((0, import_node_path16.dirname)(spec.logPath), { recursive: true });
@@ -62207,7 +62827,7 @@ function systemAssertionSpawner(log) {
 // src/platform/spawn-detached.ts
 var import_node_child_process8 = require("child_process");
 var import_node_crypto12 = require("crypto");
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path21 = require("path");
 var WINDOWS_UNSAFE_ENV = "NODE_PENDING_PIPE_INSTANCES";
 var SYSTEMD_RUN = "systemd-run";
@@ -62262,8 +62882,8 @@ function isolatedCommand(request2, isolation) {
   };
 }
 function spawnDetached(request2, isolation) {
-  (0, import_node_fs8.mkdirSync)((0, import_node_path21.dirname)(request2.outputPath), { recursive: true, mode: 448 });
-  const output2 = (0, import_node_fs8.openSync)(request2.outputPath, "a", 384);
+  (0, import_node_fs9.mkdirSync)((0, import_node_path21.dirname)(request2.outputPath), { recursive: true, mode: 448 });
+  const output2 = (0, import_node_fs9.openSync)(request2.outputPath, "a", 384);
   const { command, args } = isolatedCommand(request2, isolation);
   try {
     const child = (0, import_node_child_process8.spawn)(command, args, {
@@ -62279,7 +62899,7 @@ function spawnDetached(request2, isolation) {
     child.unref();
     return { pid: child.pid };
   } finally {
-    (0, import_node_fs8.closeSync)(output2);
+    (0, import_node_fs9.closeSync)(output2);
   }
 }
 
@@ -62319,7 +62939,7 @@ function createUpdateGate(deps) {
 
 // src/platform/wake-clock.ts
 var import_node_child_process9 = require("child_process");
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_readline = require("readline");
 var PTP_DEVICE = "/dev/ptp0";
 var RESPAWN_BASE_MS = 1e3;
@@ -62403,7 +63023,7 @@ function systemWakeClockSpawner(log) {
 function startWakeClock(options) {
   const { clock, log } = options;
   const platform3 = options.platform ?? process.platform;
-  const hasPtpDevice = options.hasPtpDevice ?? (() => (0, import_node_fs9.existsSync)(PTP_DEVICE));
+  const hasPtpDevice = options.hasPtpDevice ?? (() => (0, import_node_fs10.existsSync)(PTP_DEVICE));
   if (platform3 !== "linux" || !hasPtpDevice()) return { [Symbol.dispose]: () => {
   } };
   const spawner = options.spawner ?? systemWakeClockSpawner(log);
@@ -64537,7 +65157,7 @@ function fingerprintWholeText(fingerprint) {
 }
 
 // src/capabilities/native-ingest/hook-config.ts
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_path28 = require("path");
 
 // src/capabilities/native-ingest/provider-paths.ts
@@ -64615,9 +65235,9 @@ function hookHandler(provider4, event, options) {
   return { type: "command", command: posixCommand(argv, environment), timeout: 5 };
 }
 function readSettings(path4, backupWhenMalformed, now) {
-  if (!(0, import_node_fs10.existsSync)(path4)) return {};
+  if (!(0, import_node_fs11.existsSync)(path4)) return {};
   try {
-    const value2 = JSON.parse((0, import_node_fs10.readFileSync)(path4, "utf8"));
+    const value2 = JSON.parse((0, import_node_fs11.readFileSync)(path4, "utf8"));
     if (!isRecord4(value2)) throw new Error("settings root must be an object");
     if (value2.hooks !== void 0 && !isRecord4(value2.hooks)) {
       throw new Error("settings `hooks` must be an object");
@@ -64627,7 +65247,7 @@ function readSettings(path4, backupWhenMalformed, now) {
     const reason = error62 instanceof Error ? error62.message : String(error62);
     if (!backupWhenMalformed) throw new Error(`${path4} is malformed: ${reason}`);
     const backup = `${path4}.malformed-${now}.bak`;
-    (0, import_node_fs10.copyFileSync)(path4, backup);
+    (0, import_node_fs11.copyFileSync)(path4, backup);
     throw new Error(`${path4} is malformed and was copied to ${backup}: ${reason}`);
   }
 }
@@ -64635,14 +65255,14 @@ function hooksOf(settings2) {
   return isRecord4(settings2.hooks) ? settings2.hooks : {};
 }
 function writeSettings(path4, settings2) {
-  (0, import_node_fs10.mkdirSync)((0, import_node_path28.dirname)(path4), { recursive: true, mode: 448 });
+  (0, import_node_fs11.mkdirSync)((0, import_node_path28.dirname)(path4), { recursive: true, mode: 448 });
   const temporary = `${path4}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs10.writeFileSync)(temporary, `${JSON.stringify(settings2, null, 2)}
+    (0, import_node_fs11.writeFileSync)(temporary, `${JSON.stringify(settings2, null, 2)}
 `, { mode: 384 });
-    (0, import_node_fs10.renameSync)(temporary, path4);
+    (0, import_node_fs11.renameSync)(temporary, path4);
   } finally {
-    (0, import_node_fs10.rmSync)(temporary, { force: true });
+    (0, import_node_fs11.rmSync)(temporary, { force: true });
   }
 }
 function isIngestionHandler(handler) {
@@ -64687,7 +65307,7 @@ function installIngestionHooks(provider4, options, now) {
 }
 function removeIngestionHooks(provider4, where, now) {
   const path4 = providerHookSettingsPath(provider4, where);
-  if (!(0, import_node_fs10.existsSync)(path4)) return { provider: provider4, path: path4, changed: false };
+  if (!(0, import_node_fs11.existsSync)(path4)) return { provider: provider4, path: path4, changed: false };
   const settings2 = readSettings(path4, true, now);
   const hooks = hooksOf(settings2);
   const nextHooks = {};
@@ -64724,7 +65344,7 @@ function ingestionHookStatus(provider4, options) {
 }
 
 // src/capabilities/native-ingest/hook-input.ts
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_path29 = require("path");
 var ALAN_MANAGED_SESSION_ENV = "ALAN_MANAGED_SESSION";
 var MAX_HOOK_STDIN_BYTES = 256 * 1024 * 1024;
@@ -64754,17 +65374,17 @@ function codexSessionIdFromTranscriptPath(transcriptPath) {
   );
   return match?.[1] ?? null;
 }
-function lastBytes(chunks, count) {
+function lastBytes(chunks, count2) {
   const kept = [];
   let size = 0;
-  for (let index = chunks.length - 1; index >= 0 && size < count; index -= 1) {
+  for (let index = chunks.length - 1; index >= 0 && size < count2; index -= 1) {
     const chunk = chunks[index];
     if (chunk === void 0) continue;
     kept.unshift(chunk);
     size += chunk.length;
   }
   const joined = Buffer.concat(kept);
-  return joined.subarray(Math.max(0, joined.length - count));
+  return joined.subarray(Math.max(0, joined.length - count2));
 }
 async function readHookStdin(stream, maxBytes = MAX_HOOK_STDIN_BYTES) {
   const chunks = [];
@@ -64824,10 +65444,10 @@ function hookPayload(input2) {
 }
 function realpathOrSelf(path4) {
   try {
-    return (0, import_node_fs11.realpathSync)(path4);
+    return (0, import_node_fs12.realpathSync)(path4);
   } catch {
     try {
-      return (0, import_node_path29.join)((0, import_node_fs11.realpathSync)((0, import_node_path29.dirname)(path4)), (0, import_node_path29.basename)(path4));
+      return (0, import_node_path29.join)((0, import_node_fs12.realpathSync)((0, import_node_path29.dirname)(path4)), (0, import_node_path29.basename)(path4));
     } catch {
       return path4;
     }
@@ -64858,7 +65478,7 @@ function parseHookSignal(input2) {
 }
 
 // src/capabilities/native-ingest/ingest.ts
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 
 // ../shared/dist/types/native-agent-session.js
 var nativeAgentProviderBackendKinds = {
@@ -65628,7 +66248,7 @@ function workerKey(provider4, externalSessionId) {
   return `${provider4}\0${externalSessionId}`;
 }
 function holdFor(entry) {
-  const stats = (0, import_node_fs12.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
+  const stats = (0, import_node_fs13.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
   if (!stats) return [];
   return [
     {
@@ -65829,7 +66449,7 @@ async function startNativeIngest(deps) {
     return "accepted";
   };
   const hasUnreadBytes = (entry, now) => {
-    const stats = (0, import_node_fs12.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
+    const stats = (0, import_node_fs13.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
     if (!stats || now - Number(stats.mtimeMs) > timing.sweepRecencyMs) return false;
     const replaced = String(stats.dev) !== entry.device || String(stats.ino) !== entry.inode;
     return replaced || Number(stats.size) > entry.cursor.offset;
@@ -65873,7 +66493,7 @@ async function startNativeIngest(deps) {
   const recordAlanRun = async (hold, runId) => {
     const entry = store.get(hold.provider, hold.externalSessionId);
     if (!entry || entry.dead) return;
-    const stats = (0, import_node_fs12.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
+    const stats = (0, import_node_fs13.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
     if (!stats) return;
     const identity = { device: String(stats.dev), inode: String(stats.ino) };
     const size = Number(stats.size);
@@ -65947,7 +66567,7 @@ async function startNativeIngest(deps) {
 init_alan_code();
 
 // src/capabilities/providers/commands.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_promises35 = require("fs/promises");
 var import_node_path32 = require("path");
 var PROVIDER_COMMANDS = [
@@ -65985,7 +66605,7 @@ function pathDelimiter(platform3) {
 async function isRunnable(path4, platform3) {
   try {
     if (!(await (0, import_promises35.stat)(path4)).isFile()) return false;
-    if (platform3 !== "win32") await (0, import_promises35.access)(path4, import_node_fs13.constants.X_OK);
+    if (platform3 !== "win32") await (0, import_promises35.access)(path4, import_node_fs14.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -66168,7 +66788,7 @@ init_runtime_v2();
 
 // src/capabilities/providers/account-label.ts
 var import_node_child_process12 = require("child_process");
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_path33 = require("path");
 var import_node_url3 = require("url");
 var ACCOUNT_TIMEOUT_MS = 2e4;
@@ -66271,7 +66891,7 @@ async function claudeLabel(executable, env) {
     const childEnv = { ...env };
     delete childEnv.FORCE_CODE_TERMINAL;
     const bundledSdk = typeof __dirname === "string" ? (0, import_node_path33.join)(__dirname, "claude-sdk.mjs") : "";
-    const sdkSpecifier = (0, import_node_fs14.existsSync)(bundledSdk) ? (0, import_node_url3.pathToFileURL)(bundledSdk).href : "@anthropic-ai/claude-agent-sdk";
+    const sdkSpecifier = (0, import_node_fs15.existsSync)(bundledSdk) ? (0, import_node_url3.pathToFileURL)(bundledSdk).href : "@anthropic-ai/claude-agent-sdk";
     const { query } = await import(sdkSpecifier);
     const session = query({
       prompt: idlePrompt(abort.signal),
@@ -66681,7 +67301,7 @@ var import_node_path37 = require("path");
 // ../shared/dist/node/shell-environment.js
 var import_node_child_process13 = require("child_process");
 var import_node_crypto16 = require("crypto");
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_os6 = require("os");
 var import_node_path36 = require("path");
 
@@ -66690,7 +67310,7 @@ var import_node_os5 = require("os");
 var import_node_path35 = require("path");
 
 // ../shared/dist/node/version-manager-paths.js
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_path34 = require("path");
 function compareNodeVersionsDesc(a, b) {
   const parse7 = (value2) => value2.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -66705,19 +67325,19 @@ function compareNodeVersionsDesc(a, b) {
 }
 function resolveNvmDefaultBin(home) {
   const versionsDir = (0, import_node_path34.join)(home, ".nvm", "versions", "node");
-  if (!(0, import_node_fs15.existsSync)(versionsDir))
+  if (!(0, import_node_fs16.existsSync)(versionsDir))
     return null;
   let alias = null;
   try {
     const aliasFile = (0, import_node_path34.join)(home, ".nvm", "alias", "default");
-    if ((0, import_node_fs15.existsSync)(aliasFile))
-      alias = (0, import_node_fs15.readFileSync)(aliasFile, "utf8").trim();
+    if ((0, import_node_fs16.existsSync)(aliasFile))
+      alias = (0, import_node_fs16.readFileSync)(aliasFile, "utf8").trim();
   } catch {
     alias = null;
   }
   let installed;
   try {
-    installed = (0, import_node_fs15.readdirSync)(versionsDir).filter((entry) => entry.startsWith("v"));
+    installed = (0, import_node_fs16.readdirSync)(versionsDir).filter((entry) => entry.startsWith("v"));
   } catch {
     return null;
   }
@@ -66728,7 +67348,7 @@ function resolveNvmDefaultBin(home) {
   if (!chosen)
     return null;
   const bin = (0, import_node_path34.join)(versionsDir, chosen, "bin");
-  return (0, import_node_fs15.existsSync)(bin) ? bin : null;
+  return (0, import_node_fs16.existsSync)(bin) ? bin : null;
 }
 function resolveVersionManagerBinDirs(home, platform3 = process.platform) {
   if (platform3 === "win32")
@@ -66747,7 +67367,7 @@ function resolveVersionManagerBinDirs(home, platform3 = process.platform) {
     if (!dir || seen.has(dir))
       continue;
     seen.add(dir);
-    if ((0, import_node_fs15.existsSync)(dir))
+    if ((0, import_node_fs16.existsSync)(dir))
       resolved.push(dir);
   }
   return resolved;
@@ -66789,7 +67409,7 @@ function promoteUserBinDirs(path4, home, versionManagerDirs) {
 // ../shared/dist/node/shell-environment.js
 function isExecutableFile(path4) {
   try {
-    (0, import_node_fs16.accessSync)(path4, import_node_fs16.constants.X_OK);
+    (0, import_node_fs17.accessSync)(path4, import_node_fs17.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -68699,7 +69319,7 @@ async function publishLocalSkill(options) {
 
 // src/capabilities/skills/native-index.ts
 var import_node_crypto23 = require("crypto");
-var import_node_fs17 = require("fs");
+var import_node_fs18 = require("fs");
 var import_promises45 = require("fs/promises");
 var import_node_path45 = require("path");
 var ALAN_SKILLS_PLUGIN_NAME = "alan";
@@ -68850,7 +69470,7 @@ async function reconcileNativeIndex(layout, installed, options) {
   };
 }
 function installedSkillFolders(layout) {
-  return (0, import_node_fs17.existsSync)((0, import_node_path45.join)(layout.pluginDir, ".claude-plugin", "plugin.json")) ? { pluginDir: layout.pluginDir, skillsDir: layout.pluginSkillsDir } : null;
+  return (0, import_node_fs18.existsSync)((0, import_node_path45.join)(layout.pluginDir, ".claude-plugin", "plugin.json")) ? { pluginDir: layout.pluginDir, skillsDir: layout.pluginSkillsDir } : null;
 }
 
 // src/capabilities/skills/sync.ts
@@ -70739,10 +71359,10 @@ async function reapLeftoverEngines(path4, options) {
 }
 
 // src/holder/launch-command.ts
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_node_path53 = require("path");
 var HOLDER_BUNDLE = "alan-holder.cjs";
-function holderArguments(runtimeArgs, nodeFlags, exists6 = import_node_fs18.existsSync) {
+function holderArguments(runtimeArgs, nodeFlags, exists6 = import_node_fs19.existsSync) {
   const bundle = runtimeArgs.at(-1);
   const lean = bundle === void 0 ? void 0 : (0, import_node_path53.join)((0, import_node_path53.dirname)(bundle), HOLDER_BUNDLE);
   const script = lean !== void 0 && exists6(lean) ? [...runtimeArgs.slice(0, -1), lean] : runtimeArgs;
@@ -70831,6 +71451,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 () => {
@@ -70857,9 +71484,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
@@ -70872,20 +71501,20 @@ async function prepareRunInputs(spec, { source, tmpDir, signal, skills = [] }) {
 
 // src/holder/serve.ts
 var import_node_crypto30 = require("crypto");
-var import_node_fs23 = require("fs");
+var import_node_fs24 = require("fs");
 var import_node_net3 = require("net");
 var import_node_path66 = require("path");
 init_runtime_v2();
 
 // src/holder/admission.ts
-var import_node_fs20 = require("fs");
+var import_node_fs21 = require("fs");
 var import_promises61 = require("fs/promises");
 var import_node_os10 = require("os");
 var import_node_path60 = require("path");
 init_constants();
 
 // ../shared/dist/node/local-workspace.js
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_os9 = require("os");
 var import_node_path55 = require("path");
 function resolveAlanDefaultWorkspacePath(homeDirectory = (0, import_node_os9.homedir)()) {
@@ -71305,7 +71934,7 @@ async function inspectReadiness(path4) {
     if (!(await (0, import_promises61.stat)(path4)).isDirectory()) {
       return { ready: false, missing: true, message: MESSAGES.missing };
     }
-    await (0, import_promises61.access)(path4, import_node_fs20.constants.R_OK | import_node_fs20.constants.W_OK | import_node_fs20.constants.X_OK);
+    await (0, import_promises61.access)(path4, import_node_fs21.constants.R_OK | import_node_fs21.constants.W_OK | import_node_fs21.constants.X_OK);
     return { ready: true };
   } catch (error62) {
     const code = errnoCode(error62) ?? "";
@@ -71350,7 +71979,7 @@ async function admitDefaultWorkspace(spec, context, skills) {
   const path4 = resolveAlanDefaultWorkspacePath(env.HOME || env.USERPROFILE || (0, import_node_os10.homedir)());
   try {
     await (0, import_promises61.mkdir)(path4, { recursive: true, mode: 448 });
-    await (0, import_promises61.access)(path4, import_node_fs20.constants.R_OK | import_node_fs20.constants.W_OK | import_node_fs20.constants.X_OK);
+    await (0, import_promises61.access)(path4, import_node_fs21.constants.R_OK | import_node_fs21.constants.W_OK | import_node_fs21.constants.X_OK);
     return { kind: "admitted", spec: { ...spec, projectPath: path4 }, skills };
   } catch (error62) {
     const code = errnoCode(error62);
@@ -71599,7 +72228,7 @@ ${added.join("\n")}
 
 // src/run-log/complete.ts
 var import_node_crypto29 = require("crypto");
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_path63 = require("path");
 
 // src/run-log/directory.ts
@@ -71650,23 +72279,23 @@ async function isRunClaimed(runsDir, runId) {
 // src/run-log/complete.ts
 function writeLogFile(path4, dir, text3) {
   const temp = (0, import_node_path63.join)(dir, `.log.${(0, import_node_crypto29.randomUUID)()}.tmp`);
-  const fd = (0, import_node_fs21.openSync)(temp, "wx", 384);
+  const fd = (0, import_node_fs22.openSync)(temp, "wx", 384);
   try {
-    (0, import_node_fs21.writeSync)(fd, text3);
-    (0, import_node_fs21.fsyncSync)(fd);
+    (0, import_node_fs22.writeSync)(fd, text3);
+    (0, import_node_fs22.fsyncSync)(fd);
   } finally {
-    (0, import_node_fs21.closeSync)(fd);
+    (0, import_node_fs22.closeSync)(fd);
   }
   try {
-    (0, import_node_fs21.renameSync)(temp, path4);
+    (0, import_node_fs22.renameSync)(temp, path4);
   } finally {
-    (0, import_node_fs21.rmSync)(temp, { force: true });
+    (0, import_node_fs22.rmSync)(temp, { force: true });
   }
 }
 async function writeCompleteRunLog(runsDir, meta3, records) {
   const paths = runDirectory(runsDir, meta3.runId);
   if (!await isRunClaimed(runsDir, meta3.runId)) {
-    (0, import_node_fs21.mkdirSync)(paths.dir, { recursive: true, mode: 448 });
+    (0, import_node_fs22.mkdirSync)(paths.dir, { recursive: true, mode: 448 });
     const text3 = records.map((record2, index) => {
       const line = { seq: index + 1, at: record2.at, update: record2.update };
       return `${JSON.stringify(line)}
@@ -71923,13 +72552,13 @@ function runEnded(input2) {
 var decoder = new TextDecoder();
 
 // src/run-log/writer.ts
-var import_node_fs22 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_path65 = require("path");
 init_runtime_v2();
 function lastSeq(fd, size) {
   for (const length of tailWindows(size)) {
     const buffer = Buffer.alloc(length);
-    (0, import_node_fs22.readSync)(fd, buffer, 0, length, size - length);
+    (0, import_node_fs23.readSync)(fd, buffer, 0, length, size - length);
     const last = lastLine(buffer.toString("utf8").trimEnd(), length === size);
     if (last === void 0) continue;
     if (last.length === 0) return 0;
@@ -71940,13 +72569,13 @@ function lastSeq(fd, size) {
   throw new RuntimeFault("record_too_large", "Run log tail record is larger than any record");
 }
 function openRunLog(path4, clock) {
-  (0, import_node_fs22.mkdirSync)((0, import_node_path65.dirname)(path4), { recursive: true, mode: 448 });
-  const fd = (0, import_node_fs22.openSync)(path4, "a+", 384);
-  let size = (0, import_node_fs22.fstatSync)(fd).size;
+  (0, import_node_fs23.mkdirSync)((0, import_node_path65.dirname)(path4), { recursive: true, mode: 448 });
+  const fd = (0, import_node_fs23.openSync)(path4, "a+", 384);
+  let size = (0, import_node_fs23.fstatSync)(fd).size;
   let seq = lastSeq(fd, size);
   let dirty = false;
   const sync = () => {
-    (0, import_node_fs22.fsyncSync)(fd);
+    (0, import_node_fs23.fsyncSync)(fd);
     dirty = false;
   };
   return {
@@ -71960,7 +72589,7 @@ function openRunLog(path4, clock) {
       };
       const line = Buffer.from(`${JSON.stringify(record2)}
 `, "utf8");
-      (0, import_node_fs22.writeSync)(fd, line);
+      (0, import_node_fs23.writeSync)(fd, line);
       size += line.length;
       dirty = true;
       if (isRunLifecycleKind(update.sessionUpdate)) sync();
@@ -71972,7 +72601,7 @@ function openRunLog(path4, clock) {
     },
     [Symbol.dispose]: () => {
       if (dirty) sync();
-      (0, import_node_fs22.closeSync)(fd);
+      (0, import_node_fs23.closeSync)(fd);
     }
   };
 }
@@ -72416,7 +73045,7 @@ async function runHolder({
     for (const client of holder.clients) client.end();
     await new Promise((resolve13) => server.close(() => resolve13()));
     await statusWrites;
-    (0, import_node_fs23.rmSync)(launch.statusPath, { force: true });
+    (0, import_node_fs24.rmSync)(launch.statusPath, { force: true });
     log.info("holder.suspended", { conversationId: launch.conversationId });
   } catch (_) {
     var _error = _, _hasError = true;
@@ -72429,6 +73058,7 @@ async function runHolder({
 var GIB = 1024 ** 3;
 var MIN_RUN_BYTES = 1.25 * GIB;
 function memoryAllowsStart(capacity, activeRuns, pendingStarts = 0) {
+  if (activeRuns + pendingStarts === 0) return true;
   const headroom = Math.max(512 * 1024 ** 2, capacity.totalBytes * 0.2);
   const slots = Math.max(1, Math.floor((capacity.totalBytes - headroom) / MIN_RUN_BYTES));
   return activeRuns + pendingStarts < slots && capacity.availableBytes >= MIN_RUN_BYTES * (pendingStarts + 1);
@@ -72446,6 +73076,7 @@ function runOccupancy(held, reserved, exclude = null) {
 
 // src/sessions/suspend-policy.ts
 var GIB2 = 1024 ** 3;
+var SESSION_MEMORY_CEILING_BYTES = 2.5 * GIB2;
 var MEMORY_BUDGET_SHARE = 0.15;
 var MEMORY_BUDGET_MIN_BYTES = GIB2;
 var MEMORY_BUDGET_MAX_BYTES = 4 * GIB2;
@@ -72479,7 +73110,9 @@ function memoryOf(holder) {
 function ownReason({ holder, idleSinceMs }, policy, nowMs) {
   if (holder.facts.loginFailed) return "login_error";
   if (holder.facts.cliBinaryChanged) return "cli_changed";
-  if (memoryOf(holder) > Math.min(policy.memoryBudgetBytes, 1.25 * GIB2)) return "memory_budget";
+  if (memoryOf(holder) > Math.min(policy.memoryBudgetBytes, SESSION_MEMORY_CEILING_BYTES)) {
+    return "memory_budget";
+  }
   if (nowMs - idleSinceMs >= policy.idleMs) return "idle";
   if (nowMs - holder.facts.startedAtMs >= policy.maxAgeMs) return "age";
   return null;
@@ -72494,8 +73127,8 @@ function planSuspends(holders, policy, nowMs, pressure, opened = null) {
     if (reason === null) kept.push(entry);
     else decisions.push({ conversationId: entry.holder.conversationId, reason });
   }
-  const suspend = (count, reason) => {
-    for (const { holder } of kept.splice(0, Math.max(0, count))) {
+  const suspend = (count2, reason) => {
+    for (const { holder } of kept.splice(0, Math.max(0, count2))) {
       decisions.push({ conversationId: holder.conversationId, reason });
     }
   };
@@ -72868,7 +73501,20 @@ async function openSessions(deps) {
       return "started";
     }
     if (!await claimCapacity(run2.runId)) {
-      log.info("sessions.resource_wait", { runId: run2.runId });
+      const capacity = memoryCapacity();
+      const { active, pending } = runOccupancy(
+        await heldRuns(),
+        [...admitted, ...launched.keys()],
+        run2.runId
+      );
+      log.info("sessions.resource_wait", {
+        runId: run2.runId,
+        active,
+        pending,
+        maxActiveRuns,
+        totalMiB: Math.round(capacity.totalBytes / 2 ** 20),
+        availableMiB: Math.round(capacity.availableBytes / 2 ** 20)
+      });
       return "waiting";
     }
     try {
@@ -72991,7 +73637,8 @@ var envSchema = external_exports.object({
   ALAN_RUNTIME_LOG_LEVEL: external_exports.enum(["debug", "info", "warn", "error"]).default("info"),
   ALAN_RUNTIME_SUSPEND_IDLE_MS: external_exports.coerce.number().int().positive().optional(),
   ALAN_RUNTIME_SUSPEND_CHECK_MS: external_exports.coerce.number().int().positive().default(3e4),
-  ALAN_RUNTIME_DESIRED_RESYNC_MS: external_exports.coerce.number().int().positive().default(6e5),
+  // A two-minute conditional GET bounds recovery after a lost poke; unchanged state returns 304.
+  ALAN_RUNTIME_DESIRED_RESYNC_MS: external_exports.coerce.number().int().positive().default(12e4),
   ALAN_MAX_ACTIVE_RUNS: external_exports.coerce.number().int().optional(),
   ALAN_RUNTIME_API_URL: external_exports.url().optional(),
   ALAN_RUNTIME_CREDENTIAL_STORE: external_exports.enum(CREDENTIAL_STORE_KINDS).optional(),
@@ -74515,7 +75162,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(
@@ -75167,7 +75815,7 @@ async function runLogout(argv, signal) {
 }
 
 // src/cli/commands/run.ts
-var import_node_fs25 = require("fs");
+var import_node_fs26 = require("fs");
 var import_node_path82 = require("path");
 
 // src/local-api/app-attachments.ts
@@ -75722,7 +76370,7 @@ var machineFeatureRoutes = [
 ];
 
 // src/local-api/run-log-routes.ts
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 init_runtime_v2();
 var RUN_ENDED = "_alan/run.ended";
 var decoder2 = new TextDecoder();
@@ -75739,7 +76387,7 @@ async function openWhenWritten(deps, runId, res, signal) {
   const path4 = runDirectory(deps.runsDir, runId).log;
   while (!signal.aborted) {
     const appended = deps.appends.nextAppend(runId, signal);
-    if ((0, import_node_fs24.existsSync)(path4) || !await deps.isHeld(runId, signal)) return openReader(res, path4);
+    if ((0, import_node_fs25.existsSync)(path4) || !await deps.isHeld(runId, signal)) return openReader(res, path4);
     await appended;
   }
   return null;
@@ -76512,11 +77160,11 @@ var SEPARATOR = String.fromCharCode(30);
 var encodePayload = (packets, callback) => {
   const length = packets.length;
   const encodedPackets = new Array(length);
-  let count = 0;
+  let count2 = 0;
   packets.forEach((packet, i) => {
     encodePacket(packet, false, (encodedPacket) => {
       encodedPackets[i] = encodedPacket;
-      if (++count === length) {
+      if (++count2 === length) {
         callback(encodedPackets.join(SEPARATOR));
       }
     });
@@ -80646,6 +81294,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(),
@@ -80666,43 +81317,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);
@@ -80715,6 +81401,7 @@ function startUploader({
     switch (receipt.kind) {
       case "read": {
         receiptBackoff.delete(runId);
+        credentialPark = null;
         log.debug("upload.resumed", {
           runId,
           admittedOffset: receipt.receipt?.admittedOffset ?? 0
@@ -80724,7 +81411,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);
@@ -80736,6 +81423,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
@@ -80750,14 +81438,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 };
       }
@@ -80774,7 +81462,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;
@@ -80782,7 +81481,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") {
@@ -80791,13 +81490,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";
   };
@@ -80808,9 +81503,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);
@@ -80820,11 +81517,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 {
@@ -80832,20 +81530,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);
   };
@@ -80892,7 +81618,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(
@@ -81300,6 +82027,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();
@@ -81342,7 +82070,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),
@@ -81404,7 +82134,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(
@@ -81468,7 +82202,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 }));
@@ -82001,7 +82735,7 @@ function lockWaitMs(argv) {
 async function openManagedProviders(config2, paths) {
   const providerEnv = readCliEnvironment();
   const bundledNpm = (0, import_node_path82.join)((0, import_node_path82.dirname)(process.execPath), "npm", "bin", "npm-cli.js");
-  const providerToolchain = config2.providerToolchain ?? (process.platform === "win32" && (0, import_node_fs25.existsSync)(bundledNpm) ? { node: process.execPath, npmCli: bundledNpm } : null);
+  const providerToolchain = config2.providerToolchain ?? (process.platform === "win32" && (0, import_node_fs26.existsSync)(bundledNpm) ? { node: process.execPath, npmCli: bundledNpm } : null);
   const npmPath = providerToolchain?.node ?? await resolveCommandOnPath("npm", providerEnv, process.platform);
   const npmOptions = npmPath === null || process.platform === "win32" && providerToolchain === null ? null : {
     command: npmPath,