@alan-ai-hq/agent-manager-linux-arm64 0.1.160 → 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) {
@@ -25521,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) => {
@@ -26093,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") : [];
@@ -26144,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;
@@ -27047,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 };
 }
@@ -27182,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)} @@`;
@@ -27194,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
   };
 }
@@ -27296,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();
@@ -27353,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;
 }
@@ -27537,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;
@@ -28097,7 +28106,7 @@ var init_chunk_ZCTKXKYY = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-WD7O4DYQ.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) {
@@ -28538,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_WD7O4DYQ = __esm({
-  "../agent-core/dist/chunk-WD7O4DYQ.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();
@@ -30644,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),
@@ -30655,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) {
@@ -31073,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;
@@ -31086,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 ?? ""));
   }
@@ -31113,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_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_TFIO37PI();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -31413,6 +31448,7 @@ var init_claude = __esm({
       #announced = /* @__PURE__ */ new Set();
       #awaitingAskDenialFallback = false;
       #iterations = 0;
+      #contextTokens;
       #providerErrorCode;
       #deferredOnAnswer = false;
       #deferredOnBackground = false;
@@ -31552,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));
@@ -31636,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);
@@ -31662,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;
@@ -32900,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() };
 }
@@ -33285,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(),
@@ -33707,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)) {
@@ -33824,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":
@@ -33972,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_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_TFIO37PI();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -33990,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();
@@ -34123,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;
@@ -34147,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. */
@@ -34164,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();
@@ -34265,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",
@@ -34311,6 +34455,7 @@ var init_codex = __esm({
       #end;
       #failFast;
       #lastError;
+      #tokens = new CodexTurnTokens();
       codexTurnId;
       constructor(memory, clock = systemClock2) {
         this.#memory = memory;
@@ -34405,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"
           )
         ];
@@ -34958,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();
       }
@@ -35025,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");
@@ -35175,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 {
@@ -35202,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,
@@ -35210,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: {
@@ -35528,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`);
@@ -35542,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 {
@@ -35552,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 }
   };
@@ -36190,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;
       }
     };
@@ -36297,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);
@@ -39256,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;
       }
       /**
@@ -39334,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}
@@ -39581,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, {
@@ -39601,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;
@@ -39663,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;
@@ -39687,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",
@@ -39704,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;
@@ -39716,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;
@@ -45389,8 +45631,8 @@ var require_tar_stream = __commonJS({
 var init_dist = __esm({
   "../agent-core/dist/index.js"() {
     "use strict";
-    init_chunk_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_YXWJW7I5();
@@ -45749,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) {
@@ -46136,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_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -46367,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() {
@@ -46399,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")
@@ -46524,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));
         });
@@ -46605,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;
@@ -46639,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,
@@ -46664,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 });
@@ -46910,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",
@@ -46940,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,
@@ -47777,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: [] };
@@ -48111,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_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -48298,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) => {
@@ -48529,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();
@@ -48538,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;
@@ -48552,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);
@@ -48560,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) {
@@ -48572,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":
@@ -48588,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 [];
@@ -48654,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;
@@ -48662,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" });
@@ -48868,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.`));
@@ -49073,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) => {
@@ -49481,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();
@@ -49519,6 +49881,7 @@ function createAlanCodeHolderDriver(options) {
             conversationId: spec.conversationId
           },
           engineRoot,
+          globalConfigDirectory,
           requestedModel: spec.model
         };
         const skills = options.installedSkills?.() ?? null;
@@ -50166,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_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -50212,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(
@@ -50222,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 [];
@@ -50296,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"
@@ -51104,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);
@@ -51275,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_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_TFIO37PI();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -51635,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;
@@ -51681,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 [
@@ -51696,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;
@@ -51713,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);
@@ -51721,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) {
@@ -51980,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_WD7O4DYQ();
-    init_chunk_OUEMTEUX();
+    init_chunk_N2M5D7RS();
+    init_chunk_RBQC7XZH();
     init_chunk_ZCTKXKYY();
     init_chunk_6VWVDJ2A();
     init_chunk_DLVRNIY5();
@@ -52346,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;
@@ -52388,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": {
@@ -52439,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;
@@ -57383,7 +57829,7 @@ var require_websocket_server = __commonJS({
 // package.json
 var package_default = {
   name: "@alan-ai-hq/agent-manager",
-  version: "0.1.160",
+  version: "0.1.161",
   private: true,
   type: "module",
   description: "Alan machine runtime (alan-agent): identity, link, reconciler, session holders, run log, uploader, local API",
@@ -58890,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) => {
@@ -60863,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");
@@ -60930,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") {
@@ -61415,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");
 
@@ -61645,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 });
@@ -62340,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";
@@ -62395,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, {
@@ -62412,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);
   }
 }
 
@@ -62452,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;
@@ -62536,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);
@@ -64670,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
@@ -64748,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");
@@ -64760,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}`);
   }
 }
@@ -64768,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) {
@@ -64820,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 = {};
@@ -64857,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;
@@ -64887,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 = [];
@@ -64957,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;
     }
@@ -64991,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 = {
@@ -65761,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 [
     {
@@ -65962,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;
@@ -66006,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);
@@ -66080,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 = [
@@ -66118,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;
@@ -66301,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;
@@ -66404,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),
@@ -66814,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");
 
@@ -66823,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);
@@ -66838,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;
   }
@@ -66861,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")
@@ -66880,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;
@@ -66922,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;
@@ -68832,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";
@@ -68983,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
@@ -70872,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;
@@ -71014,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)()) {
@@ -71447,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) ?? "";
@@ -71492,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);
@@ -71741,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
@@ -71792,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)}
@@ -72065,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;
@@ -72082,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 {
@@ -72102,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();
@@ -72114,7 +72601,7 @@ function openRunLog(path4, clock) {
     },
     [Symbol.dispose]: () => {
       if (dirty) sync();
-      (0, import_node_fs22.closeSync)(fd);
+      (0, import_node_fs23.closeSync)(fd);
     }
   };
 }
@@ -72558,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;
@@ -72571,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);
@@ -72588,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;
@@ -72621,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;
@@ -72636,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 });
     }
   };
@@ -73010,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 {
@@ -73133,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(),
@@ -75310,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
@@ -75865,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();
@@ -75882,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;
@@ -76655,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));
       }
     });
@@ -82230,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,