@skaile/workspaces 4.20.0 → 4.21.1

package/dist/{chunk-OFC725VA.js → chunk-N5XNEKHC.js}

@@ -1,29 +1,29 @@
-import { WorkspacePlugin } from './chunk-P6L3CMKN.js';
-import { buildWorkspaceToolDefs } from './chunk-IDPHRLYV.js';
+import { WorkspacePlugin } from './chunk-OPSKLUB4.js';
+import { buildWorkspaceToolDefs } from './chunk-5FMWNSAQ.js';
 import { findAiAssetsRoot } from './chunk-7IH3RKKK.js';
 import { WebSocketServerTransport } from './chunk-73ZXUUL6.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { prepareNativePolicy, codexInstanceEnvironment, parseCodexCredential, parseCodexRefreshInput, parseCodexRefreshResult } from './chunk-PE3A6FFW.js';
-import { resolveFlowPath } from './chunk-QNC7VEBL.js';
+import { resolveFlowPath } from './chunk-SY2HSULI.js';
 import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-Q6NDQ6BH.js';
-import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, driveOrchestratorTurn, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-EC24QFGP.js';
+import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, driveOrchestratorTurn, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, buildSdkFlowTools } from './chunk-ZDSZGV5F.js';
 import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, isKnownSecretRef, deriveSingleMaterializedConnectorDeclaration } from './chunk-MC2MF4U5.js';
-import { EventNormalizer } from './chunk-4WBZC7UF.js';
+import { EventNormalizer } from './chunk-XBMCUMZT.js';
 import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-6S5KL76M.js';
 import { CodexNativeStateUnavailable } from './chunk-LOO5CB5M.js';
-import { dispatchCapability } from './chunk-56UHERYI.js';
+import { dispatchCapability } from './chunk-RLACUE4X.js';
 import { classifyClaudeSdkError } from './chunk-BGY4KTU6.js';
 import { agentExecRequested } from './chunk-YROR332M.js';
-import { createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS } from './chunk-TLOP6FLY.js';
+import { createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS } from './chunk-RTD5KAM4.js';
 import { loadFlow } from './chunk-KTCMBEEB.js';
 import { parseFlowDefinition } from './chunk-ALLCAFHQ.js';
 import { renderStimulusPrompt } from './chunk-RQLL7L72.js';
-import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION } from './chunk-PGQDBXS7.js';
+import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION } from './chunk-S5A5MVJN.js';
 import { resolveSettings, loadProviderRegistry } from './chunk-UWU572Q6.js';
 import { resolveRuntimeAssets } from './chunk-5RHPNNWP.js';
 import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
 import { resolveSkWorkspaceConfig, resolveAgentDir, loadMcpServerDeclarations, COMPACTION_DEFAULTS, resolveCompactionThresholdPercent, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration, stageMaterializedSkills, readSkillAllowList, isStagedSkillMarkerFor, unstageSkill } from './chunk-DF7C3KZK.js';
-import { withFsDeadline, FsDeadlineError, fsDeadlineMs, tryWithFsDeadline } from './chunk-2FBPAR2V.js';
+import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-2FBPAR2V.js';
 import { parseAssetRef } from './chunk-GEEW6SY2.js';
 import { resolveLogStoreConfig, createLogStoreFromConfig, OnLogBridgeSink, WsLogSink, resolveLogsRetention, enforceLogsRetention } from './chunk-JMKB7IB4.js';
 import { registryEntries, resolveEntryBaseUrl, parseModelRef, isEntryEnabled, parseCredentialRef } from './chunk-GZZPKAV5.js';
@@ -3563,6 +3563,19 @@ function resolveCapabilityResult(pending, cmd) {
   }
   return true;
 }
+function rejectPendingCapabilityCallsOnDisconnect(pending, keep = () => false) {
+  const entries = [...pending].filter(([callId]) => !keep(callId));
+  for (const [callId] of entries) pending.delete(callId);
+  for (const [callId, entry] of entries) {
+    clearTimeout(entry.timer);
+    entry.reject(
+      new Error(
+        `Platform connection dropped while capability call ${callId} was in flight (the platform backend may be restarting). Its outcome is unknown; retry once the platform is back if the call is safe to repeat.`
+      )
+    );
+  }
+  return entries.length;
+}
 function rejectCapabilityOnApprovalDeny(pending, callId, feedback) {
   const entry = pending.get(callId);
   if (!entry) return false;
@@ -4181,6 +4194,23 @@ var MINT_RETRY_MAX_DELAY_MS = 5e3;
 function isTransientMintFailure(code) {
   return code === "backend-error";
 }
+function aiMintPreconditionFailure(args) {
+  if (args.configId === void 0) {
+    return {
+      ok: false,
+      code: "not-configured",
+      message: "no aiProviderConfigId; standalone runner cannot mediate refresh"
+    };
+  }
+  if (!args.connected) {
+    return {
+      ok: false,
+      code: "backend-error",
+      message: "transport disconnected; the platform connection is down, refresh will be retried"
+    };
+  }
+  return null;
+}
 function mintRetryDelayMs(retryNumber) {
   const delay = MINT_RETRY_BASE_DELAY_MS * 2 ** Math.max(0, retryNumber - 1);
   return Math.min(delay, MINT_RETRY_MAX_DELAY_MS);
@@ -4874,6 +4904,105 @@ async function routeReply(deps) {
   return "fresh-turn";
 }
 
+// runner/src/event-gap-buffer.ts
+var EVENT_GAP_BUFFER_MAX_EVENTS = 1e4;
+var EVENT_GAP_BUFFER_MAX_BYTES = 16 * 1024 * 1024;
+var UNBUFFERED_TYPES = /* @__PURE__ */ new Set([
+  "session_init_ack",
+  "log_entry",
+  "capability_result"
+]);
+function measure(event) {
+  try {
+    const json = JSON.stringify(event);
+    return json === void 0 ? 0 : Buffer.byteLength(json, "utf8");
+  } catch {
+    return 0;
+  }
+}
+var EventGapBuffer = class _EventGapBuffer {
+  maxEvents;
+  maxBytes;
+  entries = [];
+  /** Index of the oldest live entry; eviction advances it instead of shifting the array. */
+  head = 0;
+  bytes = 0;
+  dropped = 0;
+  constructor(opts = {}) {
+    this.maxEvents = opts.maxEvents ?? EVENT_GAP_BUFFER_MAX_EVENTS;
+    this.maxBytes = opts.maxBytes ?? EVENT_GAP_BUFFER_MAX_BYTES;
+  }
+  /** Number of events currently held. */
+  get size() {
+    return this.entries.length - this.head;
+  }
+  /** Whether a drain would report anything (held events or drops). */
+  get hasPending() {
+    return this.size > 0 || this.dropped > 0;
+  }
+  /** The callIds of the `capability_invoked` events currently held. */
+  heldCapabilityCallIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (let i = this.head; i < this.entries.length; i++) {
+      const event = this.entries[i]?.event;
+      if (event?.type === "capability_invoked") ids.add(event.callId);
+    }
+    return ids;
+  }
+  /** Whether {@link push} would hold this event type at all. */
+  static accepts(event) {
+    return !UNBUFFERED_TYPES.has(event.type);
+  }
+  /**
+   * Append an event, evicting the oldest past either cap. An event larger than
+   * the byte cap on its own is counted as dropped and not held.
+   */
+  push(event, opts = {}) {
+    if (!_EventGapBuffer.accepts(event)) return;
+    const bytes = measure(event);
+    if (bytes > this.maxBytes) {
+      this.dropped += 1;
+      return;
+    }
+    this.entries.push({ event, bytes, ...opts.isStale ? { isStale: opts.isStale } : {} });
+    this.bytes += bytes;
+    while (this.size > this.maxEvents || this.bytes > this.maxBytes) {
+      const oldest = this.entries[this.head];
+      if (!oldest) break;
+      this.head += 1;
+      this.bytes -= oldest.bytes;
+      this.dropped += 1;
+    }
+    if (this.head > 1024 && this.head * 2 > this.entries.length) {
+      this.entries = this.entries.slice(this.head);
+      this.head = 0;
+    }
+  }
+  /** Hand back everything held, oldest first, and reset. */
+  drain() {
+    const events = [];
+    let stale = 0;
+    for (let i = this.head; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      if (!entry) continue;
+      if (entry.isStale?.()) stale += 1;
+      else events.push(entry.event);
+    }
+    const dropped = this.dropped;
+    this.clear();
+    return { events, dropped, stale };
+  }
+  /** Discard everything held. Returns how many events were discarded. */
+  clear() {
+    const discarded = this.size;
+    this.entries = [];
+    this.head = 0;
+    this.bytes = 0;
+    this.dropped = 0;
+    return discarded;
+  }
+};
+
 // runner/src/compaction/prompt.ts
 var DEFAULT_COMPACTION_PROMPT = `You are being asked to compact this conversation into a structured summary.
 This summary will replace the full conversation history when the session
@@ -5047,6 +5176,12 @@ function resolveContextWindow(driverWindow, model) {
   }
   return driverWindow || DEFAULT_CONTEXT_WINDOW;
 }
+function reportedContextWindow(driverWindow, model) {
+  if (model && ONE_MILLION_ALIAS_PATTERN.test(model)) {
+    return Math.max(driverWindow ?? 0, ONE_MILLION_CONTEXT_WINDOW);
+  }
+  return driverWindow && driverWindow > 0 ? driverWindow : null;
+}
 function detectRateLimitInSummary(text2) {
   if (text2.length > RATE_LIMIT_TEXT_MAX_CHARS) return false;
   return RATE_LIMIT_TEXT_PATTERNS.some((p) => p.test(text2));
@@ -5097,6 +5232,20 @@ var CompactionOrchestrator = class {
   contextFill(usage) {
     return this.driver.getContextTokens?.() ?? contextTokens(usage);
   }
+  /**
+   * The context fill, in tokens, at which auto-compaction triggers — the same
+   * window and tier {@link shouldCompact} uses. `null` when compaction is off.
+   */
+  compactAtTokens() {
+    if (!this.config.enabled) return null;
+    const contextWindow = resolveContextWindow(
+      this.driver.getContextWindow(),
+      this.driver.getModel() ?? null
+    );
+    return Math.round(
+      contextWindow * resolveCompactionThresholdPercent(contextWindow, this.config) / 100
+    );
+  }
   trackMessage(seq) {
     this.currentSeq = seq;
     this.messagesSinceCompaction++;
@@ -5784,6 +5933,517 @@ function readCurrentClaudeAccessToken(home) {
   return typeof raw === "string" && raw.length > 0 ? raw : null;
 }
 
+// runner/src/context-usage/estimator.ts
+var CHARS_PER_TEXT_TOKEN = 4;
+var CHARS_PER_JSON_TOKEN = 2;
+var defaultTokenEstimator = {
+  text(value) {
+    return value.length === 0 ? 0 : Math.ceil(value.length / CHARS_PER_TEXT_TOKEN);
+  },
+  json(value) {
+    if (value === void 0) return 0;
+    let serialized;
+    try {
+      serialized = typeof value === "string" ? value : JSON.stringify(value) ?? "";
+    } catch {
+      return 0;
+    }
+    return serialized.length === 0 ? 0 : Math.ceil(serialized.length / CHARS_PER_JSON_TOKEN);
+  }
+};
+
+// runner/src/context-usage/compose.ts
+var SKAILE_LABELS = /* @__PURE__ */ new Set([
+  "context",
+  "environment",
+  "resources",
+  "mcp-guidance",
+  "tool-activity",
+  "home"
+]);
+var BUCKET_ORDER = [
+  "provider-system",
+  "skaile-system",
+  "agent-prompt",
+  "memory",
+  "skills",
+  "mcp-tools",
+  "builtin-tools",
+  "subagents",
+  "content",
+  "free",
+  "compaction-buffer"
+];
+var MEASURED_DRIFT_TOLERANCE = 0.02;
+function composeContextUsageSnapshot(input) {
+  const estimator = input.estimator ?? defaultTokenEstimator;
+  const report = input.report;
+  const fresh = report !== null && input.reportFresh;
+  const driverFidelity = report?.breakdownFidelity ?? "measured";
+  const buckets = /* @__PURE__ */ new Map();
+  const sectionItems = input.systemPromptSections.map((s) => ({
+    label: s.label,
+    item: {
+      name: s.label,
+      tokens: estimator.text(s.value),
+      ...s.source ? { source: s.source } : {}
+    }
+  }));
+  const appended = report?.appendedSystemPromptTokens;
+  if (appended !== void 0) {
+    const shares = apportion(
+      sectionItems.map((s) => s.item.tokens),
+      appended
+    );
+    sectionItems.forEach((s, i) => {
+      s.item.tokens = shares[i] ?? 0;
+    });
+  }
+  const skaileItems = sectionItems.filter((s) => SKAILE_LABELS.has(s.label)).map((s) => s.item);
+  const agentItems = sectionItems.filter((s) => !SKAILE_LABELS.has(s.label)).map((s) => s.item);
+  buckets.set("skaile-system", itemBucket("skaile-system", skaileItems, "estimated"));
+  buckets.set("agent-prompt", itemBucket("agent-prompt", agentItems, "estimated"));
+  const runnerSectionTokens = sumTokens(skaileItems) + sumTokens(agentItems);
+  let providerPending = false;
+  if (report?.systemPromptTokens !== void 0) {
+    const isolated = appended !== void 0;
+    buckets.set("provider-system", {
+      id: "provider-system",
+      tokens: Math.max(0, report.systemPromptTokens - (isolated ? appended : runnerSectionTokens)),
+      fidelity: driverFidelity === "estimated" ? "estimated" : isolated ? "measured" : "derived",
+      ...report.systemPromptSections?.length ? { items: report.systemPromptSections } : {}
+    });
+  } else {
+    providerPending = true;
+  }
+  setStatic(buckets, "memory", report?.memory, null, driverFidelity);
+  setStatic(buckets, "skills", report?.skills, input.skills, driverFidelity);
+  setStatic(buckets, "mcp-tools", report?.mcpTools, input.mcpTools, driverFidelity);
+  setStatic(buckets, "builtin-tools", report?.builtinTools, null, driverFidelity);
+  setStatic(buckets, "subagents", report?.subagents, null, driverFidelity);
+  let contentPending = false;
+  if (fresh && report.content) {
+    buckets.set("content", reportBucket("content", report.content, driverFidelity));
+  } else if (input.content?.complete) {
+    buckets.set("content", itemBucket("content", input.content.items, "estimated"));
+  } else {
+    contentPending = true;
+  }
+  let used = null;
+  let totalFidelity = "estimated";
+  if (fresh && typeof report.usedTokens === "number") {
+    used = report.usedTokens;
+    totalFidelity = "measured";
+  } else if (input.contextTokens !== null && input.contextTokens > 0) {
+    used = input.contextTokens;
+    totalFidelity = "measured";
+  }
+  if (used !== null) {
+    const pinned = new Set(
+      appended !== void 0 ? ["skaile-system", "agent-prompt"] : []
+    );
+    fitEstimatesWithin(buckets, used, pinned);
+    const remaining = used - sumBuckets(buckets);
+    if (contentPending) {
+      buckets.set("content", {
+        id: "content",
+        tokens: Math.max(0, remaining),
+        fidelity: "derived"
+      });
+      if (providerPending) buckets.set("provider-system", unknownBucket("provider-system"));
+    } else if (providerPending) {
+      buckets.set("provider-system", {
+        id: "provider-system",
+        tokens: Math.max(0, remaining),
+        fidelity: "derived"
+      });
+    } else if (remaining !== 0) {
+      absorbDrift(buckets, remaining, used);
+    }
+  } else {
+    if (contentPending) buckets.set("content", unknownBucket("content"));
+    if (providerPending) buckets.set("provider-system", unknownBucket("provider-system"));
+    used = sumBuckets(buckets);
+    totalFidelity = used > 0 ? "estimated" : "unknown";
+  }
+  const window = input.contextWindow ?? (fresh ? report.contextWindow ?? null : null);
+  if (window !== null && window > 0) {
+    const threshold = input.autoCompactAt !== null ? Math.min(input.autoCompactAt, window) : window;
+    buckets.set("free", {
+      id: "free",
+      tokens: Math.max(0, threshold - used),
+      fidelity: totalFidelity
+    });
+    if (input.autoCompactAt !== null) {
+      buckets.set("compaction-buffer", {
+        id: "compaction-buffer",
+        tokens: Math.max(0, window - Math.max(used, threshold)),
+        fidelity: totalFidelity
+      });
+    }
+  }
+  return {
+    provider: input.provider,
+    model: input.model,
+    contextWindow: window !== null && window > 0 ? window : null,
+    usedTokens: used,
+    totalFidelity,
+    autoCompactAt: input.autoCompactAt,
+    buckets: BUCKET_ORDER.flatMap((id) => {
+      const bucket = buckets.get(id);
+      return bucket ? [bucket] : [];
+    }),
+    capturedAt: input.capturedAt,
+    trigger: input.trigger
+  };
+}
+function setStatic(buckets, id, reported, estimatedItems, reportedFidelity) {
+  if (reported) buckets.set(id, reportBucket(id, reported, reportedFidelity));
+  else if (estimatedItems) buckets.set(id, itemBucket(id, estimatedItems, "estimated"));
+  else buckets.set(id, unknownBucket(id));
+}
+function reportBucket(id, reported, fidelity) {
+  return {
+    id,
+    tokens: reported.tokens,
+    fidelity,
+    ...reported.items ? { items: reported.items } : {},
+    ...reported.deferredTokens ? { deferredTokens: reported.deferredTokens } : {}
+  };
+}
+function itemBucket(id, items, fidelity) {
+  const deferred = sumTokens(items.filter((i) => i.deferred));
+  return {
+    id,
+    tokens: sumTokens(items.filter((i) => !i.deferred)),
+    fidelity,
+    items,
+    ...deferred > 0 ? { deferredTokens: deferred } : {}
+  };
+}
+function unknownBucket(id) {
+  return { id, tokens: 0, fidelity: "unknown" };
+}
+function fitEstimatesWithin(buckets, used, pinned) {
+  const estimated = [...buckets.values()].filter(
+    (b) => b.fidelity === "estimated" && !pinned.has(b.id)
+  );
+  const estimatedTotal = sumTokens(estimated);
+  const fixedTotal = sumBuckets(buckets) - estimatedTotal;
+  if (estimatedTotal === 0 || fixedTotal + estimatedTotal <= used) return;
+  const budget = Math.max(0, used - fixedTotal);
+  const shares = apportion(
+    estimated.map((b) => b.tokens),
+    budget
+  );
+  estimated.forEach((bucket, i) => {
+    const target = shares[i] ?? 0;
+    if (bucket.items) {
+      const inWindow = bucket.items.filter((it) => !it.deferred);
+      const itemShares = apportion(
+        inWindow.map((it) => it.tokens),
+        target
+      );
+      const scaled = new Map(inWindow.map((it, j) => [it, itemShares[j] ?? 0]));
+      bucket.items = bucket.items.map(
+        (it) => scaled.has(it) ? { ...it, tokens: scaled.get(it) ?? 0 } : it
+      );
+    }
+    bucket.tokens = target;
+  });
+}
+function absorbDrift(buckets, remaining, used) {
+  const content = buckets.get("content");
+  if (!content) return;
+  content.tokens = Math.max(0, content.tokens + remaining);
+  if (content.fidelity === "measured" && Math.abs(remaining) > used * MEASURED_DRIFT_TOLERANCE) {
+    content.fidelity = "derived";
+    delete content.items;
+  }
+}
+function sumBuckets(buckets) {
+  let total = 0;
+  for (const b of buckets.values()) {
+    if (b.id !== "free" && b.id !== "compaction-buffer") total += b.tokens;
+  }
+  return total;
+}
+function sumTokens(items) {
+  return items.reduce((sum, i) => sum + i.tokens, 0);
+}
+function apportion(weights, total) {
+  if (weights.length === 0) return [];
+  const target = Math.max(0, Math.round(total));
+  const weightSum = weights.reduce((sum, w) => sum + Math.max(0, w), 0);
+  const raw = weights.map(
+    (w) => weightSum > 0 ? Math.max(0, w) / weightSum * target : target / weights.length
+  );
+  const parts = raw.map(Math.floor);
+  let leftover = target - parts.reduce((sum, p) => sum + p, 0);
+  const byRemainder = raw.map((r, i) => ({ i, rem: r - Math.floor(r) })).sort((a, b) => b.rem - a.rem);
+  for (const { i } of byRemainder) {
+    if (leftover <= 0) break;
+    parts[i] = (parts[i] ?? 0) + 1;
+    leftover--;
+  }
+  return parts;
+}
+
+// runner/src/context-usage/transcript-tracker.ts
+var USER = "User messages";
+var ASSISTANT = "Assistant messages";
+var SUMMARY = "Compaction summary";
+var TranscriptTokenTracker = class {
+  constructor(estimator = defaultTokenEstimator) {
+    this.estimator = estimator;
+  }
+  estimator;
+  // Keyed by group and name, so a tool called "User messages" cannot merge into the user line.
+  totals = /* @__PURE__ */ new Map();
+  complete = false;
+  /** Start over for a freshly built driver; `resuming` marks history we never saw. */
+  reset(opts) {
+    this.totals.clear();
+    this.complete = !opts.resuming;
+  }
+  /** A compaction replaced the conversation with its summary. */
+  resetToSummary(summary) {
+    this.totals.clear();
+    this.add(SUMMARY, "messages", this.estimator.text(summary));
+    this.complete = true;
+  }
+  observeUserPrompt(text2) {
+    this.add(USER, "messages", this.estimator.text(text2));
+  }
+  observe(event) {
+    switch (event.type) {
+      case "text":
+        this.add(ASSISTANT, "messages", this.estimator.text(event.content));
+        break;
+      case "text_retract":
+        this.add(ASSISTANT, "messages", -this.estimator.text(event.content));
+        break;
+      case "tool_call":
+        if (event.parentToolUseId) return;
+        this.add(event.tool, "tools", this.estimator.json(event.input));
+        break;
+      case "tool_result":
+        if (event.parentToolUseId) return;
+        this.add(
+          event.tool,
+          "tools",
+          typeof event.output === "string" ? this.estimator.text(event.output) : this.estimator.json(event.output)
+        );
+        break;
+    }
+  }
+  estimate() {
+    const items = [...this.totals.values()].filter((v) => v.tokens > 0).map((v) => ({ name: v.name, tokens: v.tokens, group: v.group })).sort((a, b) => b.tokens - a.tokens);
+    return {
+      tokens: items.reduce((sum, i) => sum + i.tokens, 0),
+      items,
+      complete: this.complete
+    };
+  }
+  add(name, group, tokens) {
+    if (tokens === 0) return;
+    const key = `${group}\0${name}`;
+    const current = this.totals.get(key);
+    this.totals.set(key, { name, group, tokens: Math.max(0, (current?.tokens ?? 0) + tokens) });
+  }
+};
+
+// runner/src/context-usage/collector.ts
+var DEFAULT_MEASURE_TIMEOUT_MS = 3e4;
+var SKILL_READ_TIMEOUT_MS = 5e3;
+var ContextUsageCollector = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.estimator = deps.estimator ?? defaultTokenEstimator;
+    this.tracker = new TranscriptTokenTracker(this.estimator);
+  }
+  deps;
+  tracker;
+  estimator;
+  lastReport = null;
+  inflight = /* @__PURE__ */ new Map();
+  skills = null;
+  capabilityMemo = null;
+  /** A driver was (re)built; everything measured or cached about the old one is void. */
+  onDriverBuilt(opts) {
+    this.tracker.reset(opts);
+    this.lastReport = null;
+    this.skills = null;
+    this.inflight.clear();
+  }
+  onCompaction(summary) {
+    this.tracker.resetToSummary(summary);
+  }
+  observeUserPrompt(text2) {
+    this.tracker.observeUserPrompt(text2);
+  }
+  observeEvent(event) {
+    this.tracker.observe(event);
+  }
+  async collect(opts) {
+    try {
+      return await this.collectUnsafe(opts);
+    } catch (err) {
+      return {
+        snapshot: {
+          provider: safeCall(() => this.deps.provider(), "unknown"),
+          model: safeCall(() => this.deps.driver()?.getModel?.() ?? "", ""),
+          contextWindow: null,
+          usedTokens: 0,
+          totalFidelity: "unknown",
+          autoCompactAt: null,
+          buckets: [],
+          capturedAt: (this.deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+          trigger: opts.trigger
+        },
+        error: `context usage unavailable: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  async collectUnsafe(opts) {
+    const driver = this.deps.driver();
+    let error;
+    let report = null;
+    let reportFresh = false;
+    if (opts.measure && driver?.getContextUsageReport) {
+      try {
+        const detail = opts.measure;
+        const measure2 = driver.getContextUsageReport.bind(driver);
+        report = await this.sharedMeasurement(detail, () => measure2({ detail }));
+        if (report) {
+          this.lastReport = report;
+          reportFresh = true;
+        }
+      } catch (err) {
+        error = `measurement failed: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    report ??= this.lastReport;
+    const model = driver?.getModel?.() ?? "";
+    const usage = driver?.getTokenUsage() ?? null;
+    const perCall = driver?.getContextTokens?.() ?? null;
+    const fill = opts.trigger === "compaction" ? null : perCall ?? (usage ? contextTokens(usage) : null);
+    const snapshot = composeContextUsageSnapshot({
+      provider: this.deps.provider(),
+      model,
+      trigger: opts.trigger,
+      capturedAt: (this.deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+      contextTokens: fill,
+      contextWindow: driver ? reportedContextWindow(driver.getContextWindow(), model || null) : null,
+      autoCompactAt: this.deps.autoCompactAt(),
+      systemPromptSections: this.deps.systemPromptSections(),
+      report,
+      reportFresh,
+      skills: report?.skills ? null : await this.skillItems(),
+      mcpTools: report?.mcpTools ? null : this.capabilityItems(),
+      content: this.tracker.estimate(),
+      estimator: this.estimator
+    });
+    return error ? { snapshot, error } : { snapshot };
+  }
+  /**
+   * One driver measurement per detail level at a time: a second request that
+   * lands while a `full` count is running (two panels, a double click) shares
+   * it instead of paying for another round of `count_tokens` calls.
+   */
+  sharedMeasurement(detail, measure2) {
+    const running = this.inflight.get(detail);
+    if (running) return running;
+    const measurement = withTimeout(
+      measure2(),
+      this.deps.measureTimeoutMs ?? DEFAULT_MEASURE_TIMEOUT_MS
+    ).finally(() => {
+      if (this.inflight.get(detail) === measurement) this.inflight.delete(detail);
+    });
+    this.inflight.set(detail, measurement);
+    return measurement;
+  }
+  skillItems() {
+    this.skills ??= withTimeout(this.deps.readSkills(), SKILL_READ_TIMEOUT_MS).then(
+      (skills) => skills.map((s) => ({
+        name: s.name,
+        tokens: this.estimator.text(s.frontmatter),
+        ...s.source ? { source: s.source } : {}
+      })),
+      () => null
+    );
+    return this.skills;
+  }
+  capabilityItems() {
+    const caps = this.deps.modelCapabilities();
+    const key = caps.map((c) => c.name).join("\n");
+    if (this.capabilityMemo?.key === key) return this.capabilityMemo.items;
+    const items = caps.map((c) => ({
+      name: c.name,
+      tokens: this.estimator.text(c.name) + this.estimator.text(c.description) + this.estimator.json(c.inputSchema),
+      group: capabilityGroup(c.origin)
+    }));
+    this.capabilityMemo = { key, items };
+    return items;
+  }
+};
+function capabilityGroup(origin) {
+  switch (origin.kind) {
+    case "mcp":
+      return origin.serverId;
+    case "connector":
+      return origin.connectorId;
+    case "mount":
+      return origin.mountId;
+    case "skill":
+      return origin.skillId;
+    case "flow":
+      return origin.flowId;
+    case "app":
+      return origin.appId;
+    default:
+      return origin.kind;
+  }
+}
+function safeCall(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function withTimeout(promise, ms) {
+  let timer;
+  const timeout2 = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`timed out after ${ms} ms`)), ms);
+    timer.unref?.();
+  });
+  return Promise.race([promise, timeout2]).finally(() => clearTimeout(timer));
+}
+var MAX_SKILLS = 500;
+async function readSkillListings(skillsDir) {
+  let entries;
+  try {
+    entries = (await readdir(skillsDir, { withFileTypes: true })).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name).slice(0, MAX_SKILLS);
+  } catch {
+    return [];
+  }
+  const listings = await Promise.all(
+    entries.map(async (dir) => {
+      const path6 = join(skillsDir, dir, "SKILL.md");
+      try {
+        const { data } = parseFrontmatter(await readFile(path6, "utf8"));
+        const name = typeof data.name === "string" ? data.name : dir;
+        const description = typeof data.description === "string" ? data.description : "";
+        return { name, frontmatter: `${name}: ${description}`, source: path6 };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return listings.filter((l) => l !== null);
+}
+
 // runner/src/lifecycle-handler.ts
 function raiseHookFailures(phase, results, log) {
   const failed = results.filter((r) => !r.ok);
@@ -7283,11 +7943,21 @@ async function startAgentServer(opts) {
     })
   );
   const turnStatus = new TurnStatusTracker();
+  const eventGapBuffer = new EventGapBuffer();
   function sendEvent(event) {
     turnStatus.observe(event);
     if (transport.connected) {
       transport.send(event);
+      return;
     }
+    if (!initAcknowledged) return;
+    eventGapBuffer.push(event, { isStale: settledCapabilityCallCheck(event) });
+  }
+  function settledCapabilityCallCheck(event) {
+    if (event.type !== "capability_invoked") return void 0;
+    const { callId } = event;
+    if (!pendingCapabilityCalls.has(callId)) return void 0;
+    return () => !pendingCapabilityCalls.has(callId);
   }
   let initAcknowledged = false;
   let initGeneration = 0;
@@ -7305,6 +7975,20 @@ async function startAgentServer(opts) {
   bootstrapCapabilityRegistry(capabilityRegistry);
   const hostRuntimeCapabilities = /* @__PURE__ */ new Set();
   const pendingCapabilityCalls = /* @__PURE__ */ new Map();
+  function rejectCallsSentToPreviousPeer(trigger) {
+    const unsent = eventGapBuffer.heldCapabilityCallIds();
+    const rejected = rejectPendingCapabilityCallsOnDisconnect(
+      pendingCapabilityCalls,
+      (callId) => unsent.has(callId)
+    );
+    if (rejected > 0) {
+      serverLog.warn(
+        `[serve] platform connection dropped (${trigger}); rejected ${rejected} in-flight capability call(s)`
+      );
+    }
+  }
+  transport.onDisconnect(() => rejectCallsSentToPreviousPeer("disconnect"));
+  transport.onConnect(() => rejectCallsSentToPreviousPeer("replaced connection"));
   const remoteCapabilityInvoker = (name, input, timeoutMs, signal) => {
     const callId = typeof crypto?.randomUUID === "function" ? crypto.randomUUID() : `rcap-${Date.now()}-${Math.floor(Math.random() * 1e9)}`;
     return new Promise((resolve4, reject) => {
@@ -7347,13 +8031,11 @@ async function startAgentServer(opts) {
     t.unref?.();
   });
   async function mintAndPersistAiCredential(args) {
-    if (!transport.connected || aiProviderConfigId === void 0) {
-      return {
-        ok: false,
-        code: "not-configured",
-        message: "no transport or aiProviderConfigId; standalone runner cannot mediate refresh"
-      };
-    }
+    const precondition = aiMintPreconditionFailure({
+      connected: transport.connected,
+      configId: aiProviderConfigId
+    });
+    if (precondition) return precondition;
     const targetConfigId = args.configId || aiProviderConfigId;
     try {
       const home = process.env.HOME || homedir();
@@ -7650,6 +8332,19 @@ async function startAgentServer(opts) {
   });
   let sessionConfig;
   let agentSession;
+  const contextUsage = new ContextUsageCollector({
+    driver: () => driver,
+    provider: () => agentSession?.driverType ?? "unknown",
+    systemPromptSections: () => agentSession?.systemPromptSections ?? [],
+    modelCapabilities: () => capabilityRegistry.list().filter(
+      (cap) => (cap.audience ?? ["llm", "user"]).includes("llm") && !cap.name.startsWith("host.") && !cap.name.startsWith("runner.")
+    ),
+    readSkills: () => readSkillListings(join(opts.projectDir, activeSkillsDir())),
+    autoCompactAt: () => compactionOrchestrator?.compactAtTokens() ?? null
+  });
+  function noteAgentSessionBuilt(resumeSessionId2) {
+    contextUsage.onDriverBuilt({ resuming: !!resumeSessionId2 || !!managedCodex });
+  }
   let flowToolsBaked = false;
   let secretProvider;
   let runtimeIdentity;
@@ -7729,6 +8424,7 @@ async function startAgentServer(opts) {
     sessionConfig = buildSessionConfig();
     agentSession = await createAgentSession(sessionConfig);
     emitSystemPromptComposed(agentSession, sendEvent);
+    noteAgentSessionBuilt(sessionConfig.resumeSessionId);
     registerSessionComposition(agentSession);
     resolveSessionReady();
     captureBakedMcpServers();
@@ -7818,12 +8514,14 @@ async function startAgentServer(opts) {
   const normalizer = new EventNormalizer();
   function forwardNormalizedEvent(event) {
     if (compacting) return;
+    contextUsage.observeEvent(event);
     const isTransient = event.type === "status" || event.type === "sync_status" || event.type === "resources_available" || event.type === "resource_response" || event.type === "commands_available";
     if (!isTransient) {
       eventSeq++;
       compactionOrchestrator?.trackMessage(eventSeq);
     }
     if (event.type === "finished") {
+      scheduleContextUsageEmit("turn-end");
       if (!compacting && compactionOrchestrator?.shouldCompact()) {
         const compactionTimer = setTimeout(() => {
           if (compacting || !compactionOrchestrator?.shouldCompact()) return;
@@ -7894,6 +8592,16 @@ async function startAgentServer(opts) {
   let suppressedBy = null;
   let compactionOrchestrator = null;
   const compactionConfig = wsConfig.compaction;
+  function scheduleContextUsageEmit(trigger) {
+    const timer = setTimeout(() => {
+      void contextUsage.collect({ trigger, measure: trigger === "turn-end" ? "summary" : false }).then(({ snapshot, error }) => {
+        sendEvent({ type: "context_usage", snapshot, ...error ? { error } : {} });
+      }).catch((err) => {
+        serverLog.debug(`[serve] context_usage emit failed: ${String(err)}`);
+      });
+    }, 0);
+    timer.unref?.();
+  }
   function rebuildCompactionOrchestrator() {
     if (!driver) return;
     let gateHold = null;
@@ -7909,6 +8617,8 @@ async function startAgentServer(opts) {
       },
       onSnapshot: (snapshot) => {
         sendEvent(snapshot);
+        contextUsage.onCompaction(snapshot.summary);
+        scheduleContextUsageEmit("compaction");
       },
       onCompactionAttempt: (event) => {
         sendEvent(event);
@@ -8265,6 +8975,7 @@ async function startAgentServer(opts) {
   async function cleanup() {
     if (managedHost) managedBootstrapClosed = true;
     initAcknowledged = false;
+    eventGapBuffer.clear();
     try {
       await Promise.race([
         sessionReady,
@@ -8397,6 +9108,7 @@ async function startAgentServer(opts) {
         throw new Error("CODEX_RUNTIME_UNSUPPORTED");
       }
       emitSystemPromptComposed(agentSession, sendEvent);
+      noteAgentSessionBuilt(sessionConfig.resumeSessionId);
       resourceManager = agentSession.resourceManager;
       driver = agentSession.driver;
       rebuildCompactionOrchestrator();
@@ -8471,6 +9183,7 @@ async function startAgentServer(opts) {
       resuming: !!overrides.resumeSessionId
     });
     emitSystemPromptComposed(agentSession, sendEvent);
+    noteAgentSessionBuilt({ ...sessionConfig, ...overrides }.resumeSessionId);
     swapDriver();
     rebuildCompactionOrchestrator();
     captureBakedMcpServers();
@@ -9009,6 +9722,7 @@ async function startAgentServer(opts) {
       return;
     }
     log(`[serve] prompt: ${cmd.prompt.slice(0, 80)}...`);
+    contextUsage.observeUserPrompt(cmd.prompt);
     await driverSwapGate.awaitSwap();
     if (!await awaitCompactionIdle("prompt")) return;
     await restageMaterializedSkills(true);
@@ -9250,6 +9964,22 @@ async function startAgentServer(opts) {
     }
     sendEvent({ type: "debug_result", query: cmd.query, data: result });
   }
+  async function handleGetContextUsage(cmd) {
+    try {
+      await sessionReady;
+    } catch {
+    }
+    const { snapshot, error } = await contextUsage.collect({
+      trigger: "request",
+      measure: cmd.detail === "estimated" ? "summary" : "full"
+    });
+    sendEvent({
+      type: "context_usage",
+      requestId: cmd.requestId,
+      snapshot,
+      ...error ? { error } : {}
+    });
+  }
   async function handleShutdown() {
     log("[serve] shutdown requested");
     await cleanup();
@@ -9370,6 +10100,9 @@ async function startAgentServer(opts) {
       case "debug":
         await handleDebug(cmd);
         break;
+      case "get_context_usage":
+        await handleGetContextUsage(cmd);
+        break;
       // -----------------------------------------------------------------------
       // -----------------------------------------------------------------------
       // v3: add_resource, remove_resource, remount_mount, set_log_level,
@@ -9413,9 +10146,28 @@ async function startAgentServer(opts) {
       replayed: true
     });
   });
+  transport.onConnect(() => {
+    if (!eventGapBuffer.hasPending) return;
+    if (!initAcknowledged || sessionReadyOutcome === "rejected") {
+      const discarded = eventGapBuffer.clear();
+      serverLog.warn(
+        `[serve] discarded ${discarded} event(s) buffered while disconnected: the init they belong to is no longer acknowledged`
+      );
+      return;
+    }
+    const { events, dropped, stale } = eventGapBuffer.drain();
+    for (const event of events) transport.send(event);
+    serverLog.warn(
+      `[serve] flushed ${events.length} event(s) buffered while the platform was disconnected; dropped ${dropped} over the buffer cap, withheld ${stale} settled capability call(s)`
+    );
+  });
   transport.onConnect(() => {
     sendEvent(turnStatus.snapshot());
   });
+  transport.onConnect(() => {
+    if (!initAcknowledged || managedCodex || aiProviderConfigId === void 0) return;
+    aiCredentialRefreshScheduler.ensureArmed();
+  });
   transport.onConnect(() => {
     if (managedHost && !managedBootstrapClosed)
       sendEvent({
@@ -9630,6 +10382,6 @@ function touchSession(state) {
   return { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-OFC725VA.js.map
-//# sourceMappingURL=chunk-OFC725VA.js.map
+export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
+//# sourceMappingURL=chunk-N5XNEKHC.js.map
+//# sourceMappingURL=chunk-N5XNEKHC.js.map