@cnwenf/occ 2.1.336 → 2.1.338

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-globalThis.MACRO={"VERSION":"2.1.336","BINARY_NAME":"occ","BUILD_TIME":"2026-09-15T19:40:03.023Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
+globalThis.MACRO={"VERSION":"2.1.338","BINARY_NAME":"occ","BUILD_TIME":"2026-09-16T23:15:11.887Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -101874,6 +101874,62 @@ var init_model = __esm(() => {
   ];
 });
 
+// src/utils/agentSwarmsEnabled.ts
+function isAgentTeamsFlagSet() {
+  return process.argv.includes("--agent-teams");
+}
+function isAgentSwarmsEnabled() {
+  if (process.env.USER_TYPE === "ant") {
+    return true;
+  }
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS) && !isAgentTeamsFlagSet()) {
+    return false;
+  }
+  if (!getFeatureValue_CACHED_MAY_BE_STALE("tengu_amber_flint", true)) {
+    return false;
+  }
+  return true;
+}
+var init_agentSwarmsEnabled = __esm(() => {
+  init_growthbook();
+  init_envUtils();
+});
+
+// src/utils/agentContext.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+function getAgentContext() {
+  return agentContextStorage.getStore();
+}
+function runWithAgentContext(context, fn) {
+  return agentContextStorage.run(context, fn);
+}
+function isSubagentContext(context) {
+  return context?.agentType === "subagent";
+}
+function getSubagentLogName() {
+  const context = getAgentContext();
+  if (!isSubagentContext(context) || !context.subagentName) {
+    return;
+  }
+  return context.isBuiltIn ? context.subagentName : "user-defined";
+}
+function consumeInvokingRequestId() {
+  const context = getAgentContext();
+  if (!context?.invokingRequestId || context.invocationEmitted) {
+    return;
+  }
+  context.invocationEmitted = true;
+  return {
+    invokingRequestId: context.invokingRequestId,
+    invocationKind: context.invocationKind
+  };
+}
+var agentContextStorage;
+var init_agentContext = __esm(() => {
+  init_agentSwarmsEnabled();
+  agentContextStorage = new AsyncLocalStorage2;
+});
+
 // src/services/api/bedrockContentTypeGuard.ts
 function assertBedrockStreamingContentType(response, requestUrl, provider3) {
   if (provider3 !== "bedrock")
@@ -101909,6 +101965,160 @@ var init_bedrockContentTypeGuard = __esm(() => {
   };
 });
 
+// src/services/api/gatewayHints.ts
+function isFirstPartyAnthropicGateway() {
+  return getAPIProvider() === "firstParty" && isFirstPartyAnthropicBaseUrl();
+}
+function isGatewayHintHeadersEnabled() {
+  const envOverride = parseTriBool(process.env.CLAUDE_CODE_GATEWAY_HINT_HEADERS);
+  if (envOverride !== undefined) {
+    return envOverride;
+  }
+  if (isFirstPartyAnthropicGateway()) {
+    return true;
+  }
+  if (getAPIProvider() !== "firstParty") {
+    return false;
+  }
+  return false;
+}
+function parseTriBool(value) {
+  if (value === undefined) {
+    return;
+  }
+  if (isEnvTruthy(value)) {
+    return true;
+  }
+  if (isEnvDefinedFalsy(value)) {
+    return false;
+  }
+  return;
+}
+function toWellFormedString(value) {
+  if (typeof String.prototype.toWellFormed === "function") {
+    return value.toWellFormed();
+  }
+  return value.replace(LONE_SURROGATE_RE, "\uFFFD");
+}
+function sanitizeToolNameForHeader(toolName) {
+  return toWellFormedString(toolName).replace(/%|[;=, ]|[^\x20-\x7e]/gu, encodeURIComponent);
+}
+function sanitizeHeaderValue(value) {
+  return value.replace(/%|[^\x20-\x7e]/gu, encodeURIComponent);
+}
+function buildPrevToolDurationsHeader(entries) {
+  const parts = [];
+  let length = 0;
+  for (const { toolName, durationMs } of entries) {
+    if (parts.length >= MAX_TOOL_DURATION_ENTRIES) {
+      break;
+    }
+    if (!Number.isFinite(durationMs)) {
+      continue;
+    }
+    const ms = Math.max(0, Math.round(durationMs));
+    const entry = `${sanitizeToolNameForHeader(toolName)}=${ms}`;
+    const separatorLength = parts.length > 0 ? 1 : 0;
+    if (length + separatorLength + entry.length > MAX_TOOL_DURATION_HEADER_BYTES) {
+      break;
+    }
+    length += separatorLength + entry.length;
+    parts.push(entry);
+  }
+  return parts.length > 0 ? parts.join(";") : undefined;
+}
+function classifyQuerySource(querySource) {
+  if (querySource === undefined) {
+    return;
+  }
+  if (querySource.startsWith("repl_main_thread") || querySource === "sdk") {
+    return "main";
+  }
+  if (querySource.startsWith("agent:") || querySource === "hook_agent") {
+    return "subagent";
+  }
+  return "auxiliary";
+}
+function isMainThreadQuerySource(querySource) {
+  return querySource === undefined || classifyQuerySource(querySource) === "main";
+}
+function shouldSendContextCompactedHeader(querySource, agentId) {
+  return agentId === undefined && isMainThreadQuerySource(querySource);
+}
+function getRequestClassHeader(querySource, agentContext) {
+  if (querySource === undefined) {
+    return;
+  }
+  if (querySource === "compact") {
+    return "compaction";
+  }
+  const querySourceClass = classifyQuerySource(querySource);
+  if (querySourceClass === "subagent" && agentContext?.agentType === "subagent" && agentContext.workflowRunId) {
+    return "workflow";
+  }
+  return querySourceClass;
+}
+function getAgentTypeHeader(querySource, agentContext) {
+  if (querySource === undefined || !querySource.startsWith("agent:")) {
+    return;
+  }
+  if (agentContext?.agentType === "teammate") {
+    return "teammate";
+  }
+  if (querySource.startsWith(BUILTIN_AGENT_QUERY_SOURCE_PREFIX)) {
+    return querySource.slice(BUILTIN_AGENT_QUERY_SOURCE_PREFIX.length) || undefined;
+  }
+  if (querySource.startsWith("agent:custom")) {
+    return "custom";
+  }
+  return;
+}
+function getCompactionKind(trigger, definednessProbe) {
+  return trigger === "manual" ? "manual" : definednessProbe !== undefined ? "auto" : "reactive";
+}
+function armPendingContextCompacted(kind) {
+  pendingContextCompacted = kind;
+}
+function consumePendingContextCompacted() {
+  const kind = pendingContextCompacted;
+  pendingContextCompacted = undefined;
+  return kind;
+}
+function applyContextCompactedHeaders(headers, contextCompactedKind, compactionRequestKind) {
+  if (contextCompactedKind === undefined && compactionRequestKind === undefined) {
+    return;
+  }
+  const firstPartyGateway = isFirstPartyAnthropicGateway();
+  const hintsEnabled = isGatewayHintHeadersEnabled();
+  if (contextCompactedKind !== undefined) {
+    if (firstPartyGateway) {
+      headers[CONTEXT_COMPACTED_GATEWAY_HEADER] = contextCompactedKind;
+    }
+    if (hintsEnabled) {
+      headers[CONTEXT_COMPACTED_HEADER] = contextCompactedKind;
+    }
+  }
+  if (compactionRequestKind !== undefined) {
+    if (firstPartyGateway) {
+      headers[COMPACTION_REQUEST_GATEWAY_HEADER] = compactionRequestKind;
+    }
+    if (hintsEnabled) {
+      headers[COMPACTION_HEADER] = compactionRequestKind;
+    }
+  }
+}
+function applyPrevToolDurationsHeader(headers, prevToolDurationsHeader) {
+  if (prevToolDurationsHeader !== undefined && isGatewayHintHeadersEnabled()) {
+    headers[PREV_TOOL_DURATIONS_HEADER] = prevToolDurationsHeader;
+  }
+}
+var CONTEXT_COMPACTED_GATEWAY_HEADER = "x-cc-context-compacted", COMPACTION_REQUEST_GATEWAY_HEADER = "x-cc-compaction-request", COMPACTION_HEADER = "x-claude-code-compaction", CONTEXT_COMPACTED_HEADER = "x-claude-code-context-compacted", PREV_TOOL_DURATIONS_HEADER = "x-claude-code-prev-tool-durations", REQUEST_CLASS_HEADER = "x-claude-code-request-class", AGENT_TYPE_HEADER = "x-claude-code-agent-type", MAX_TOOL_DURATION_ENTRIES = 32, MAX_TOOL_DURATION_HEADER_BYTES = 4096, BUILTIN_AGENT_QUERY_SOURCE_PREFIX = "agent:builtin:", LONE_SURROGATE_RE, pendingContextCompacted;
+var init_gatewayHints = __esm(() => {
+  init_envUtils();
+  init_providers();
+  LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+});
+
 // node_modules/.bun/tslib@1.14.1/node_modules/tslib/tslib.js
 var require_tslib2 = __commonJS((exports, module) => {
   /*! *****************************************************************************
@@ -139857,6 +140067,17 @@ async function getAnthropicClient({
     ...remoteSessionId ? { "x-claude-remote-session-id": remoteSessionId } : {},
     ...clientApp ? { "x-client-app": clientApp } : {}
   };
+  if (isGatewayHintHeadersEnabled()) {
+    const agentContext = getAgentContext();
+    const requestClass = getRequestClassHeader(source, agentContext);
+    if (requestClass) {
+      defaultHeaders[REQUEST_CLASS_HEADER] = requestClass;
+    }
+    const agentType = getAgentTypeHeader(source, agentContext);
+    if (agentType) {
+      defaultHeaders[AGENT_TYPE_HEADER] = sanitizeHeaderValue(agentType);
+    }
+  }
   logForDebugging(`[API:request] Creating client, ANTHROPIC_CUSTOM_HEADERS present: ${!!process.env.ANTHROPIC_CUSTOM_HEADERS}, has Authorization header: ${!!customHeaders["Authorization"]}`);
   const additionalProtectionEnabled = isEnvTruthy(process.env.CLAUDE_CODE_ADDITIONAL_PROTECTION);
   if (additionalProtectionEnabled) {
@@ -140064,7 +140285,9 @@ var init_client9 = __esm(() => {
   init_oauth();
   init_debug();
   init_envUtils();
+  init_agentContext();
   init_bedrockContentTypeGuard();
+  init_gatewayHints();
 });
 
 // src/utils/model/modelCapabilities.ts
@@ -143744,7 +143967,7 @@ function getClaudeCodeUserAgent() {
 }
 
 // src/utils/workloadContext.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 function getWorkload() {
   return workloadStorage.getStore()?.workload;
 }
@@ -143753,7 +143976,7 @@ function runWithWorkload(workload, fn) {
 }
 var WORKLOAD_CRON = "cron", workloadStorage;
 var init_workloadContext = __esm(() => {
-  workloadStorage = new AsyncLocalStorage2;
+  workloadStorage = new AsyncLocalStorage3;
 });
 
 // src/utils/http.ts
@@ -150712,62 +150935,6 @@ var init_officialRegistry = __esm(() => {
   init_errors();
 });
 
-// src/utils/agentSwarmsEnabled.ts
-function isAgentTeamsFlagSet() {
-  return process.argv.includes("--agent-teams");
-}
-function isAgentSwarmsEnabled() {
-  if (process.env.USER_TYPE === "ant") {
-    return true;
-  }
-  if (!isEnvTruthy(process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS) && !isAgentTeamsFlagSet()) {
-    return false;
-  }
-  if (!getFeatureValue_CACHED_MAY_BE_STALE("tengu_amber_flint", true)) {
-    return false;
-  }
-  return true;
-}
-var init_agentSwarmsEnabled = __esm(() => {
-  init_growthbook();
-  init_envUtils();
-});
-
-// src/utils/agentContext.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-function getAgentContext() {
-  return agentContextStorage.getStore();
-}
-function runWithAgentContext(context4, fn) {
-  return agentContextStorage.run(context4, fn);
-}
-function isSubagentContext(context4) {
-  return context4?.agentType === "subagent";
-}
-function getSubagentLogName() {
-  const context4 = getAgentContext();
-  if (!isSubagentContext(context4) || !context4.subagentName) {
-    return;
-  }
-  return context4.isBuiltIn ? context4.subagentName : "user-defined";
-}
-function consumeInvokingRequestId() {
-  const context4 = getAgentContext();
-  if (!context4?.invokingRequestId || context4.invocationEmitted) {
-    return;
-  }
-  context4.invocationEmitted = true;
-  return {
-    invokingRequestId: context4.invokingRequestId,
-    invocationKind: context4.invocationKind
-  };
-}
-var agentContextStorage;
-var init_agentContext = __esm(() => {
-  init_agentSwarmsEnabled();
-  agentContextStorage = new AsyncLocalStorage3;
-});
-
 // src/utils/teammateContext.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
 function getTeammateContext() {
@@ -232750,6 +232917,7 @@ function parseAgentFromJson(name3, definition, source = "flagSettings") {
       ...parsed.skills && parsed.skills.length > 0 ? { skills: parsed.skills } : {},
       ...parsed.initialPrompt ? { initialPrompt: parsed.initialPrompt } : {},
       ...parsed.background ? { background: parsed.background } : {},
+      ...parsed.omitClaudeMd ? { omitClaudeMd: parsed.omitClaudeMd } : {},
       ...parsed.memory ? { memory: parsed.memory } : {},
       ...parsed.isolation ? { isolation: parsed.isolation } : {}
     };
@@ -232809,6 +232977,8 @@ function parseAgentFromMarkdown(filePath, baseDir, frontmatter, content, source)
       logForDebugging(`Agent file ${filePath} has invalid background value '${backgroundRaw}'. Must be 'true', 'false', or omitted.`);
     }
     const background = backgroundRaw === "true" || backgroundRaw === true ? true : undefined;
+    const omitClaudeMdRaw = frontmatter["omitClaudeMd"];
+    const omitClaudeMd = omitClaudeMdRaw === "true" || omitClaudeMdRaw === true ? true : undefined;
     const VALID_MEMORY_SCOPES2 = ["user", "project", "local"];
     const memoryRaw = frontmatter["memory"];
     let memory;
@@ -232906,6 +233076,7 @@ function parseAgentFromMarkdown(filePath, baseDir, frontmatter, content, source)
       ...isValidPermissionMode ? { permissionMode: permissionModeRaw } : {},
       ...maxTurns !== undefined ? { maxTurns } : {},
       ...background ? { background } : {},
+      ...omitClaudeMd ? { omitClaudeMd } : {},
       ...memory ? { memory } : {},
       ...isolation ? { isolation } : {},
       ...cacheTtl !== undefined ? { cacheTtl } : {}
@@ -232964,6 +233135,7 @@ var init_loadAgentsDir = __esm(() => {
     initialPrompt: exports_external.string().optional(),
     memory: exports_external.enum(["user", "project", "local"]).optional(),
     background: exports_external.boolean().optional(),
+    omitClaudeMd: exports_external.boolean().optional(),
     isolation: (process.env.USER_TYPE === "ant" ? exports_external.enum(["worktree", "remote"]) : exports_external.enum(["worktree"])).optional()
   }));
   AgentsJsonSchema = lazySchema(() => exports_external.record(exports_external.string(), AgentJsonSchema()));
@@ -266498,29 +266670,39 @@ async function* withRetry(getClient2, operation, options) {
     } catch (error52) {
       lastError = error52;
       logForDebugging(`API error (attempt ${attempt}/${maxRetries + 1}): ${error52 instanceof APIError ? `${error52.status} ${error52.message}` : errorMessage(error52)}`, { level: "error" });
+      const watchdogRetryEnabled = isRetryWatchdogEnabled();
       if (wasFastModeActive && !isPersistentRetryEnabled() && error52 instanceof APIError && (error52.status === 429 || is529Error(error52))) {
         const overageReason = error52.headers?.get("anthropic-ratelimit-unified-overage-disabled-reason");
         if (overageReason !== null && overageReason !== undefined) {
           handleFastModeOverageRejection(overageReason);
           retryContext.fastMode = false;
+          if (watchdogRetryEnabled && attempt >= maxRetries)
+            attempt = maxRetries;
           continue;
         }
         const retryAfterMs = getRetryAfterMs(error52);
-        if (retryAfterMs !== null && retryAfterMs < SHORT_RETRY_THRESHOLD_MS) {
+        const isShortRetry = retryAfterMs !== null && retryAfterMs < SHORT_RETRY_THRESHOLD_MS;
+        if (isShortRetry && !watchdogRetryEnabled) {
           await sleep2(retryAfterMs, options.signal, { abortError });
           continue;
         }
-        const cooldownMs = Math.max(retryAfterMs ?? DEFAULT_FAST_MODE_FALLBACK_HOLD_MS, MIN_COOLDOWN_MS);
-        const cooldownReason = is529Error(error52) ? "overloaded" : "rate_limit";
-        triggerFastModeCooldown(Date.now() + cooldownMs, cooldownReason);
-        if (isFastModeEnabled()) {
-          retryContext.fastMode = false;
+        if (!isShortRetry) {
+          const cooldownMs = Math.max(retryAfterMs ?? DEFAULT_FAST_MODE_FALLBACK_HOLD_MS, MIN_COOLDOWN_MS);
+          const cooldownReason = is529Error(error52) ? "overloaded" : "rate_limit";
+          triggerFastModeCooldown(Date.now() + cooldownMs, cooldownReason);
+          if (isFastModeEnabled()) {
+            retryContext.fastMode = false;
+          }
+          if (watchdogRetryEnabled && attempt >= maxRetries)
+            attempt = maxRetries;
+          continue;
         }
-        continue;
       }
       if (wasFastModeActive && isFastModeNotEnabledError(error52)) {
         handleFastModeRejectedByAPI();
         retryContext.fastMode = false;
+        if (watchdogRetryEnabled && attempt >= maxRetries)
+          attempt = maxRetries;
         continue;
       }
       if (is529Error(error52) && !shouldRetry529(options.querySource) && !isRetryWatchdogEnabled()) {
@@ -361041,10 +361223,17 @@ function collectCommands(node, commands7, varScope) {
           const arg = walkArgument(child, commands7, varScope);
           if (typeof arg !== "string")
             return arg;
-          if ((argv[0] === "declare" || argv[0] === "typeset" || argv[0] === "local") && /^-[a-zA-Z]*[niaA]/.test(arg)) {
+          if ((argv[0] === "declare" || argv[0] === "typeset" || argv[0] === "local") && /^[+-].*[nialuAEFLRZ]/.test(arg)) {
+            return {
+              kind: "too-complex",
+              reason: `declare flag ${arg} changes assignment semantics (nameref/integer/float/array/width-truncation/case-conversion)`,
+              nodeType: "declaration_command"
+            };
+          }
+          if ((argv[0] === "export" || argv[0] === "readonly") && /^[+-].*[iluEFLRZ]/.test(arg)) {
             return {
               kind: "too-complex",
-              reason: `declare flag ${arg} changes assignment semantics (nameref/integer/array)`,
+              reason: `${argv[0]} flag ${arg} \u2014 zsh bin_typeset mathevals (-i/-E/-F), width-truncates (-L/-R/-Z), or case-converts (-l/-u) the assigned value`,
               nodeType: "declaration_command"
             };
           }
@@ -380838,10 +381027,32 @@ function parsePatternCommand(args, flagsWithArgs, defaults2 = []) {
   }
   return paths2.length > 0 ? paths2 : defaults2;
 }
+function globCharIndex(arg) {
+  for (let i6 = 0;i6 < arg.length; i6++) {
+    const c9 = arg[i6];
+    if (c9 === "*" || c9 === "?")
+      return i6;
+    if (c9 === "[" && arg.indexOf("]", i6 + 1) !== -1)
+      return i6;
+  }
+  return -1;
+}
+function collectUnextractedGlobArgs(args, extractedPaths) {
+  const seen = new Set(extractedPaths);
+  const out = [];
+  for (const arg of args) {
+    if (globCharIndex(arg) !== -1 && !seen.has(arg)) {
+      seen.add(arg);
+      out.push(arg);
+    }
+  }
+  return out;
+}
 function validateCommandPaths(command4, args, cwd2, toolPermissionContext, compoundCommandHasCd, operationTypeOverride) {
   const extractor = PATH_EXTRACTORS[command4];
-  const paths2 = extractor(args);
+  const extractedPaths = extractor(args);
   const operationType = operationTypeOverride ?? COMMAND_OPERATION_TYPE[command4];
+  const paths2 = operationType === "read" ? [...extractedPaths, ...collectUnextractedGlobArgs(args, extractedPaths)] : extractedPaths;
   const validator = COMMAND_VALIDATOR[command4];
   if (validator && !validator(args)) {
     return {
@@ -385036,8 +385247,8 @@ function findCatastrophicSubstitutionBlock(command4) {
     }
     return null;
   }
-  for (const body of [command4, ...subs]) {
-    let c9 = body.trim();
+  const analyzeText = (text2) => {
+    let c9 = text2.trim();
     if (c9.startsWith("{") && /;?\s*\}$/.test(c9) || c9.startsWith("(") && c9.endsWith(")")) {
       c9 = c9.slice(1).replace(/;?\s*[)}]$/, "").trim();
     }
@@ -385054,6 +385265,18 @@ function findCatastrophicSubstitutionBlock(command4) {
         reason: "rm -rf targeting the root or home directory detected inside command substitution"
       };
     }
+    return null;
+  };
+  for (const body of [command4, ...subs]) {
+    for (const text2 of [body, ...splitCommand_DEPRECATED(body)]) {
+      if (text2.trim() === "") {
+        continue;
+      }
+      const block = analyzeText(text2);
+      if (block !== null) {
+        return block;
+      }
+    }
   }
   return null;
 }
@@ -453731,9 +453954,13 @@ function computeTodoLabel(todo) {
 function computeSpinnerVerbWidth(columns) {
   return Math.max(40, columns - 8);
 }
-var THINKING_AMBER_DELAY_MS = 1e4, THINKING_AMBER_RAMP_MS = 1e4, RGB_CACHE;
+function appendSpinnerEllipsis(verb) {
+  return SPINNER_ELLIPSIS_RE.test(verb) ? verb : verb + "\u2026";
+}
+var THINKING_AMBER_DELAY_MS = 1e4, THINKING_AMBER_RAMP_MS = 1e4, RGB_CACHE, SPINNER_ELLIPSIS_RE;
 var init_utils10 = __esm(() => {
   RGB_CACHE = new Map;
+  SPINNER_ELLIPSIS_RE = /(\u2026|\.\.\.)$/;
 });
 
 // src/components/Spinner/FlashingChar.tsx
@@ -460536,7 +460763,7 @@ function SpinnerWithVerbInner({
   const leaderTodoLabel = currentTodo ? computeTodoLabel(currentTodo) : undefined;
   const leaderVerb = overrideMessage ?? (leaderTodoLabel === undefined ? undefined : truncateToWidthNoEllipsis(leaderTodoLabel, computeSpinnerVerbWidth(columns))) ?? randomVerb;
   const effectiveVerb = foregroundedTeammate && !foregroundedTeammate.isIdle ? foregroundedTeammate.spinnerVerb ?? randomVerb : leaderVerb;
-  const message = effectiveVerb + "\u2026";
+  const message = appendSpinnerEllipsis(effectiveVerb);
   import_react64.useEffect(() => {
     const operationId = "spinner-" + mode;
     activityManager.startCLIActivity(operationId);
@@ -584823,10 +585050,117 @@ ${output2.json}`
 var exports_MonitorTool = {};
 __export(exports_MonitorTool, {
   stopMonitor: () => stopMonitor,
+  normalizeMonitorInput: () => normalizeMonitorInput,
+  monitorExpiredNotice: () => monitorExpiredNotice,
+  fireMonitorDeadline: () => fireMonitorDeadline,
   MonitorTool: () => MonitorTool,
   MONITOR_TOOL_NAME: () => MONITOR_TOOL_NAME
 });
 import { randomUUID as randomUUID22 } from "crypto";
+function monitorDeadlineCap() {
+  return getIsNonInteractiveSession() ? MONITOR_DEADLINE_CAP_PRINT_MS : MONITOR_DEADLINE_CAP_MS;
+}
+function formatMonitorMinutes(ms) {
+  return `${Math.round(ms / 60000)} minutes`;
+}
+function normalizeMonitorInput(input2) {
+  return {
+    timeoutMs: Math.min(input2.timeout_ms ?? DEFAULT_TIMEOUT_MS2, monitorDeadlineCap()),
+    persistent: false
+  };
+}
+function monitorExpiredNotice(timeoutMs, eventCount) {
+  const duration3 = formatDuration(timeoutMs, { hideTrailingZeros: true });
+  if (eventCount === 0) {
+    return `[Monitor expired after ${duration3} with no events delivered. Re-arm it if you still need the watch \u2014 and widen the filter if silence was unexpected.]`;
+  }
+  return `[Monitor expired after ${duration3} with ${eventCount} ${pluralize2(eventCount, "event")} delivered. Re-arm it if you still need the watch.]`;
+}
+function deadlineSection() {
+  return `Every monitor expires after \`timeout_ms\` (default ${formatMonitorMinutes(DEFAULT_TIMEOUT_MS2)}, at most ${formatMonitorMinutes(monitorDeadlineCap())}): it is killed and you get one notice with the event count. Re-arm it if you still need the watch; for a long watch (PR monitoring, log tails) set \`timeout_ms\` to the maximum and re-arm on each expiry, and widen the filter if an expiry with no events was unexpected.`;
+}
+function buildDescription2() {
+  return `**OCC build note (event delivery not yet wired):** in this build, Monitor events and the expiry notice are recorded internally but are NOT delivered to the chat \u2014 the notification consumer is a tracked follow-up (occ127). The deadline itself IS enforced: every monitor is killed and deregistered at \`timeout_ms\`. Until delivery lands, use Bash \`run_in_background\` when you need a delivered completion notification, and read the delivery-dependent statements below ("notifications arrive in the chat", the expiry notice) as describing not-yet-available behavior.
+
+Start a background monitor that streams events from a long-running script. Each stdout line is an event \u2014 you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you're waiting for the user to answer a question.
+
+Pick by how many notifications you need:
+- **One** ("tell me when the server is ready / the build finishes") \u2192 use **Bash with \`run_in_background\`** and a command that exits when the condition is true, e.g. \`until grep -q "Ready in" dev.log; do sleep 0.5; done\`. You get a single completion notification when it exits.
+- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") \u2192 Monitor with an unbounded command (\`tail -f\`, \`inotifywait -m\`, \`while true\`).
+- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") \u2192 Monitor with a command that emits lines and then exits.
+
+Your script's stdout is the event stream. Each line becomes a notification. Exit ends the watch.
+
+  # Each matching log line is an event
+  tail -f /var/log/app.log | grep --line-buffered "ERROR"
+
+  # Each file change is an event
+  inotifywait -m --format '%e %f' /watched/dir
+
+  # Poll GitHub for new PR comments and emit one line per new comment
+  last=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  while true; do
+    now=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+    gh api "repos/owner/repo/issues/123/comments?since=$last" --jq '.[] | "\\(.user.login): \\(.body)"'
+    last=$now; sleep 30
+  done
+
+  # Node script that emits events as they arrive (e.g. WebSocket listener)
+  node watch-for-events.js
+
+  # Per-occurrence with a natural end: emit each CI check as it lands, exit when the run completes
+  prev=""
+  while true; do
+    s=$(gh pr checks 123 --json name,bucket)
+    cur=$(jq -r '.[] | select(.bucket!="pending") | "\\(.name): \\(.bucket)"' <<<"$s" | sort)
+    comm -13 <(echo "$prev") <(echo "$cur")
+    prev=$cur
+    jq -e 'all(.bucket!="pending")' <<<"$s" >/dev/null && break
+    sleep 30
+  done
+
+**Don't use an unbounded command for a single notification.** \`tail -f\`, \`inotifywait -m\`, and \`while true\` never exit on their own, so the monitor stays armed until timeout even after the event has fired. For "tell me when X is ready," use Bash \`run_in_background\` with an \`until\` loop instead (one notification, ends in seconds). Note that \`tail -f log | grep -m 1 ...\` does *not* fix this: if the log goes quiet after the match, \`tail\` never receives SIGPIPE and the pipeline hangs anyway.
+
+**Script quality:**
+- Every pipe stage must flush per line or matches sit in its buffer unseen: \`grep\` needs \`--line-buffered\`, \`awk\` needs \`fflush()\`. \`head\` cannot flush at all \u2014 \`| head -N\` delivers nothing until N matches accumulate, then ends the stream.
+- In poll loops, handle transient failures (\`curl ... || true\`) \u2014 one failed request shouldn't kill the monitor.
+- Poll intervals: 30s+ for remote APIs (rate limits), 0.5-1s for local checks.
+- Write a specific \`description\` \u2014 it appears in every notification ("errors in deploy.log" not "watching logs").
+- Only stdout is the event stream. Stderr goes to the output file (readable via Read) but does not trigger notifications \u2014 for a command you run directly (e.g. \`python train.py 2>&1 | grep --line-buffered ...\`), merge stderr with \`2>&1\` so its failures reach your filter. (No effect on \`tail -f\` of an existing log \u2014 that file only contains what its writer redirected.)
+
+**Coverage \u2014 silence is not success.** When watching a job or process for an outcome, your filter must match every terminal state, not just the happy path. A monitor that greps only for the success marker stays silent through a crashloop, a hung process, or an unexpected exit \u2014 and silence looks identical to "still running." Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.
+
+  # Wrong \u2014 silent on crash, hang, or any non-success exit
+  tail -f run.log | grep --line-buffered "elapsed_steps="
+
+  # Right \u2014 one alternation covering progress + the failure signatures you'd act on
+  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"
+
+For poll loops checking job state, emit on every terminal status (\`succeeded|failed|cancelled|timeout\`), not just success. If you cannot confidently enumerate the failure signatures, broaden the grep alternation rather than narrow it \u2014 some extra noise is better than missing a crashloop.
+
+**Output volume**: Every stdout line is a conversation message, so the filter should be selective \u2014 but selective means "the lines you'd act on," not "only good news." Never pipe raw logs; filter to exactly the success and failure signals you care about. Monitors that produce too many events are automatically stopped; restart with a tighter filter if this happens.
+
+Stdout lines within 200ms are batched into a single notification, so multiline output from a single event groups naturally.
+
+The script runs in the same shell environment as Bash. Exit ends the watch (exit code is reported). ${deadlineSection()} Use TaskStop to cancel early.
+**ws source** \u2014 open a WebSocket and stream each incoming text frame as an event. No shell, no polling: the server pushes, you get notified.
+  Monitor({
+    ws: {url: 'wss://events.example.com/stream', protocols: ['v1']},
+    description: 'deploy events',
+  })
+Each text frame becomes one notification (multiline frames stay as one event). Binary frames are reported as \`[binary frame, N bytes]\` rather than passed through. Socket close ends the watch with the close code surfaced; errors are surfaced before close. Same rate limiting as bash \u2014 a firehose will be suppressed and eventually stopped, so subscribe to a filtered feed where one exists.
+Prefer this over \`command: 'websocat wss://\u2026'\` \u2014 it avoids the extra process and line-buffering pitfalls. Use bash when you need to transform or filter frames with shell tools before they become events.`;
+}
+function fireMonitorDeadline(deps) {
+  const registry2 = deps.registry ?? activeMonitors;
+  const h5 = registry2.get(deps.taskId);
+  if (!h5)
+    return false;
+  deps.emit(monitorExpiredNotice(deps.timeoutMs, deps.eventCount));
+  h5.kill();
+  registry2.delete(deps.taskId);
+  return true;
+}
 function shellPath() {
   return process.env.SHELL || "/bin/sh";
 }
@@ -584919,77 +585253,13 @@ function stopMonitor(taskId) {
   activeMonitors.delete(taskId);
   return true;
 }
-var MONITOR_TOOL_NAME = "Monitor", DEFAULT_TIMEOUT_MS2 = 300000, MAX_TIMEOUT_MS2 = 3600000, COMMAND_DESC = "Shell command or script. Each stdout line is an event; exit ends the watch.", DESCRIPTION19 = `Start a background monitor that streams events from a long-running script. Each stdout line is an event \u2014 you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you're waiting for the user to answer a question.
-
-Pick by how many notifications you need:
-- **One** ("tell me when the server is ready / the build finishes") \u2192 use **Bash with \`run_in_background\`** and a command that exits when the condition is true, e.g. \`until grep -q "Ready in" dev.log; do sleep 0.5; done\`. You get a single completion notification when it exits.
-- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") \u2192 Monitor with an unbounded command (\`tail -f\`, \`inotifywait -m\`, \`while true\`).
-- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") \u2192 Monitor with a command that emits lines and then exits.
-
-Your script's stdout is the event stream. Each line becomes a notification. Exit ends the watch.
-
-  # Each matching log line is an event
-  tail -f /var/log/app.log | grep --line-buffered "ERROR"
-
-  # Each file change is an event
-  inotifywait -m --format '%e %f' /watched/dir
-
-  # Poll GitHub for new PR comments and emit one line per new comment
-  last=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-  while true; do
-    now=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-    gh api "repos/owner/repo/issues/123/comments?since=$last" --jq '.[] | "\\(.user.login): \\(.body)"'
-    last=$now; sleep 30
-  done
-
-  # Node script that emits events as they arrive (e.g. WebSocket listener)
-  node watch-for-events.js
-
-  # Per-occurrence with a natural end: emit each CI check as it lands, exit when the run completes
-  prev=""
-  while true; do
-    s=$(gh pr checks 123 --json name,bucket)
-    cur=$(jq -r '.[] | select(.bucket!="pending") | "\\(.name): \\(.bucket)"' <<<"$s" | sort)
-    comm -13 <(echo "$prev") <(echo "$cur")
-    prev=$cur
-    jq -e 'all(.bucket!="pending")' <<<"$s" >/dev/null && break
-    sleep 30
-  done
-
-**Don't use an unbounded command for a single notification.** \`tail -f\`, \`inotifywait -m\`, and \`while true\` never exit on their own, so the monitor stays armed until timeout even after the event has fired. For "tell me when X is ready," use Bash \`run_in_background\` with an \`until\` loop instead (one notification, ends in seconds). Note that \`tail -f log | grep -m 1 ...\` does *not* fix this: if the log goes quiet after the match, \`tail\` never receives SIGPIPE and the pipeline hangs anyway.
-
-**Script quality:**
-- Every pipe stage must flush per line or matches sit in its buffer unseen: \`grep\` needs \`--line-buffered\`, \`awk\` needs \`fflush()\`. \`head\` cannot flush at all \u2014 \`| head -N\` delivers nothing until N matches accumulate, then ends the stream.
-- In poll loops, handle transient failures (\`curl ... || true\`) \u2014 one failed request shouldn't kill the monitor.
-- Poll intervals: 30s+ for remote APIs (rate limits), 0.5-1s for local checks.
-- Write a specific \`description\` \u2014 it appears in every notification ("errors in deploy.log" not "watching logs").
-- Only stdout is the event stream. Stderr goes to the output file (readable via Read) but does not trigger notifications \u2014 for a command you run directly (e.g. \`python train.py 2>&1 | grep --line-buffered ...\`), merge stderr with \`2>&1\` so its failures reach your filter. (No effect on \`tail -f\` of an existing log \u2014 that file only contains what its writer redirected.)
-
-**Coverage \u2014 silence is not success.** When watching a job or process for an outcome, your filter must match every terminal state, not just the happy path. A monitor that greps only for the success marker stays silent through a crashloop, a hung process, or an unexpected exit \u2014 and silence looks identical to "still running." Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.
-
-  # Wrong \u2014 silent on crash, hang, or any non-success exit
-  tail -f run.log | grep --line-buffered "elapsed_steps="
-
-  # Right \u2014 one alternation covering progress + the failure signatures you'd act on
-  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"
-
-For poll loops checking job state, emit on every terminal status (\`succeeded|failed|cancelled|timeout\`), not just success. If you cannot confidently enumerate the failure signatures, broaden the grep alternation rather than narrow it \u2014 some extra noise is better than missing a crashloop.
-
-**Output volume**: Every stdout line is a conversation message, so the filter should be selective \u2014 but selective means "the lines you'd act on," not "only good news." Never pipe raw logs; filter to exactly the success and failure signals you care about. Monitors that produce too many events are automatically stopped; restart with a tighter filter if this happens.
-
-Stdout lines within 200ms are batched into a single notification, so multiline output from a single event groups naturally.
-
-The script runs in the same shell environment as Bash. Exit ends the watch (exit code is reported). Timeout \u2192 killed. Set \`persistent: true\` for session-length watches (PR monitoring, log tails) \u2014 the monitor runs until you call TaskStop or the session ends. Use TaskStop to cancel early.
-**ws source** \u2014 open a WebSocket and stream each incoming text frame as an event. No shell, no polling: the server pushes, you get notified.
-  Monitor({
-    ws: {url: 'wss://events.example.com/stream', protocols: ['v1']},
-    description: 'deploy events',
-  })
-Each text frame becomes one notification (multiline frames stay as one event). Binary frames are reported as \`[binary frame, N bytes]\` rather than passed through. Socket close ends the watch with the close code surfaced; errors are surfaced before close. Same rate limiting as bash \u2014 a firehose will be suppressed and eventually stopped, so subscribe to a filtered feed where one exists.
-Prefer this over \`command: 'websocat wss://\u2026'\` \u2014 it avoids the extra process and line-buffering pitfalls. Use bash when you need to transform or filter frames with shell tools before they become events.`, inputSchema38, outputSchema35, activeMonitors, MonitorTool;
+var MONITOR_TOOL_NAME = "Monitor", DEFAULT_TIMEOUT_MS2 = 300000, MAX_TIMEOUT_MS2 = 3600000, MONITOR_DEADLINE_CAP_MS = 1800000, MONITOR_DEADLINE_CAP_PRINT_MS = 600000, COMMAND_DESC = "Shell command or script. Each stdout line is an event; exit ends the watch.", inputSchema38, outputSchema35, activeMonitors, MonitorTool;
 var init_MonitorTool = __esm(() => {
   init_v4();
   init_Tool();
+  init_state();
+  init_format();
+  init_oauthLoginExpiry();
   inputSchema38 = lazySchema(() => exports_external.strictObject({
     command: exports_external.string().min(1).describe(COMMAND_DESC).optional(),
     ws: exports_external.object({
@@ -585013,10 +585283,10 @@ var init_MonitorTool = __esm(() => {
     maxResultSizeChars: 1e5,
     shouldDefer: true,
     async description() {
-      return DESCRIPTION19;
+      return buildDescription2();
     },
     async prompt() {
-      return DESCRIPTION19;
+      return buildDescription2();
     },
     get inputSchema() {
       return inputSchema38();
@@ -585038,8 +585308,7 @@ var init_MonitorTool = __esm(() => {
     },
     async call(input2, _context) {
       const taskId = `monitor-${randomUUID22()}`;
-      const persistent = input2.persistent ?? false;
-      const timeoutMs = persistent ? 0 : input2.timeout_ms ?? DEFAULT_TIMEOUT_MS2;
+      const { timeoutMs, persistent } = normalizeMonitorInput(input2);
       const events2 = [];
       const emit2 = (line) => {
         events2.push(line);
@@ -585049,17 +585318,16 @@ var init_MonitorTool = __esm(() => {
       } else if (input2.ws) {
         streamWs(input2.ws.url, input2.ws.protocols, taskId, emit2).catch(() => {});
       }
-      if (timeoutMs > 0) {
-        const timer2 = setTimeout(() => {
-          const h5 = activeMonitors.get(taskId);
-          if (h5) {
-            h5.kill();
-            activeMonitors.delete(taskId);
-          }
-        }, timeoutMs);
-        if (typeof timer2 === "object" && timer2 && "unref" in timer2) {
-          timer2.unref();
-        }
+      const timer2 = setTimeout(() => {
+        fireMonitorDeadline({
+          taskId,
+          timeoutMs,
+          eventCount: events2.length,
+          emit: emit2
+        });
+      }, timeoutMs);
+      if (typeof timer2 === "object" && timer2 && "unref" in timer2) {
+        timer2.unref();
       }
       return {
         data: {
@@ -585099,7 +585367,7 @@ function isPushDisabled() {
     return true;
   }
 }
-var PUSH_NOTIFICATION_TOOL_NAME = "PushNotification", DESCRIPTION20 = "Send a notification to the user via their terminal and, when Remote Control is connected, also push to their mobile device", inputSchema39, outputSchema36, noopTerminal, PushNotificationTool;
+var PUSH_NOTIFICATION_TOOL_NAME = "PushNotification", DESCRIPTION19 = "Send a notification to the user via their terminal and, when Remote Control is connected, also push to their mobile device", inputSchema39, outputSchema36, noopTerminal, PushNotificationTool;
 var init_PushNotificationTool = __esm(() => {
   init_v4();
   init_Tool();
@@ -585127,10 +585395,10 @@ var init_PushNotificationTool = __esm(() => {
     maxResultSizeChars: 1000,
     shouldDefer: true,
     async description() {
-      return DESCRIPTION20;
+      return DESCRIPTION19;
     },
     async prompt() {
-      return DESCRIPTION20;
+      return DESCRIPTION19;
     },
     get inputSchema() {
       return inputSchema39();
@@ -585451,7 +585719,7 @@ If you receive a JSON message with \`type: "shutdown_request"\` or \`type: "plan
 Approving shutdown terminates your process. Rejecting plan sends the teammate back to revise. Don't originate \`shutdown_request\` unless asked. Don't send structured JSON status messages \u2014 use TaskUpdate.
 `.trim();
 }
-var DESCRIPTION21 = "Send a message to another agent";
+var DESCRIPTION20 = "Send a message to another agent";
 var init_prompt24 = __esm(() => {
   init_featureFlags();
 });
@@ -585972,7 +586240,7 @@ var init_SendMessageTool = __esm(() => {
       return { result: true };
     },
     async description() {
-      return DESCRIPTION21;
+      return DESCRIPTION20;
     },
     async prompt() {
       return getPrompt6();
@@ -586220,7 +586488,7 @@ async function listCloudSessions() {
 async function listRemoteBridgeSessions() {
   return [];
 }
-var LIST_AGENTS_TOOL_NAME = "ListAgents", DESCRIPTION22 = `Lists agents you can SendMessage to \u2014 in-process subagents you spawned, other local Claude sessions on this machine, your Claude sessions running in the cloud (when this session has cloud access), and (when Remote Control is connected) remote bridge sessions, which you can only reply to. Names are the address: send with \`SendMessage({to: "<name>", message: "..."})\`, copying the name exactly as a row prints it. Append a row's \` [ref]\` only when the bare name is not enough \u2014 two rows share it, or an error asks you to disambiguate.`, inputSchema41, AgentTypeSchema, outputSchema37, ListPeersTool;
+var LIST_AGENTS_TOOL_NAME = "ListAgents", DESCRIPTION21 = `Lists agents you can SendMessage to \u2014 in-process subagents you spawned, other local Claude sessions on this machine, your Claude sessions running in the cloud (when this session has cloud access), and (when Remote Control is connected) remote bridge sessions, which you can only reply to. Names are the address: send with \`SendMessage({to: "<name>", message: "..."})\`, copying the name exactly as a row prints it. Append a row's \` [ref]\` only when the bare name is not enough \u2014 two rows share it, or an error asks you to disambiguate.`, inputSchema41, AgentTypeSchema, outputSchema37, ListPeersTool;
 var init_ListPeersTool = __esm(() => {
   init_v4();
   init_Tool();
@@ -586246,10 +586514,10 @@ var init_ListPeersTool = __esm(() => {
     maxResultSizeChars: 50000,
     shouldDefer: true,
     async description() {
-      return DESCRIPTION22;
+      return DESCRIPTION21;
     },
     async prompt() {
-      return DESCRIPTION22;
+      return DESCRIPTION21;
     },
     get inputSchema() {
       return inputSchema41();
@@ -587070,9 +587338,20 @@ You MUST call the ${SYNTHETIC_OUTPUT_TOOL_NAME} tool exactly once at the end of
       model: agentModel,
       startTime: agentStartTime
     });
+    const workflowAgentContext = {
+      agentId,
+      parentSessionId: getParentSessionId2(),
+      agentType: "subagent",
+      subagentName: agentDef.agentType,
+      isBuiltIn: isBuiltInAgent(agentDef),
+      workflowRunId: ctx.runId,
+      workflowName: ctx.workflowName,
+      invocationKind: "spawn",
+      invocationEmitted: false
+    };
     let messages;
     try {
-      messages = await drainGenerator(gen);
+      messages = await runWithAgentContext(workflowAgentContext, () => drainGenerator(gen));
     } catch (e4) {
       const msg = `Agent "${opts.label ?? prompt.slice(0, 40)}" failed: ${e4.message}`;
       ctx.counters.failures.push(msg);
@@ -587358,6 +587637,9 @@ var WORKFLOW_AGENT_LIFETIME_CAP = 1000, WORKFLOW_PARALLEL_MAX_ITEMS = 4096, WORK
 var init_primitives = __esm(() => {
   init_runAgent();
   init_generalPurposeAgent();
+  init_loadAgentsDir();
+  init_agentContext();
+  init_teammate();
   init_worktree();
   init_messages3();
   init_tokens();
@@ -588030,7 +588312,7 @@ function buildWorkflowProgressHandler(runId, seedPhases, emit2, onAgentEvent) {
     });
   };
 }
-var import_react86, inputSchema42, outputSchema38, DESCRIPTION23 = `Run a multi-step workflow from a self-contained JavaScript script. The script runs in a sandboxed vm with access to primitives: agent(prompt, opts?) to spawn a subagent, parallel(items) for concurrent execution (max 4096 items, ~10 concurrent), pipeline(items, ...stages) for streaming, phase(title, fn?) to group agents (optional callback form: phase('title', async () => { ...parallel/agent... }) runs fn within the phase and returns its result), log(...args) for workflow-scoped logging, budget {total, remaining(), spent()} for token caps, and workflow(nameOrRef) / resolveWorkflow(name) for sub-workflows. Scripts are deterministic for resume (no Date/Math.random/import). Use the Workflow tool on substantive multi-agent tasks.
+var import_react86, inputSchema42, outputSchema38, DESCRIPTION22 = `Run a multi-step workflow from a self-contained JavaScript script. The script runs in a sandboxed vm with access to primitives: agent(prompt, opts?) to spawn a subagent, parallel(items) for concurrent execution (max 4096 items, ~10 concurrent), pipeline(items, ...stages) for streaming, phase(title, fn?) to group agents (optional callback form: phase('title', async () => { ...parallel/agent... }) runs fn within the phase and returns its result), log(...args) for workflow-scoped logging, budget {total, remaining(), spent()} for token caps, and workflow(nameOrRef) / resolveWorkflow(name) for sub-workflows. Scripts are deterministic for resume (no Date/Math.random/import). Use the Workflow tool on substantive multi-agent tasks.
 
 - Ultracode is on for the session (a system-reminder confirms it) \u2014 see **Ultracode** below.
 
@@ -588089,10 +588371,10 @@ var init_WorkflowTool = __esm(() => {
     async description() {
       const size = getInitialSettings()?.dynamicWorkflowSize ?? "medium";
       const sizeHint = size === "small" ? "When creating a dynamic workflow, prefer a small number of agents (~3)." : size === "large" ? "When creating a dynamic workflow, prefer a large number of agents (~12)." : "When creating a dynamic workflow, prefer a medium number of agents (~6).";
-      return `${DESCRIPTION23} ${sizeHint} (Per the dynamicWorkflowSize setting \u2014 advisory, not a cap.)`;
+      return `${DESCRIPTION22} ${sizeHint} (Per the dynamicWorkflowSize setting \u2014 advisory, not a cap.)`;
     },
     async prompt() {
-      return `${DESCRIPTION23}
+      return `${DESCRIPTION22}
 
 Use this tool to run a workflow script. The script must start with \`export const meta = { name, description, phases }\` and export a default async function: \`export default async ({ agent, parallel, pipeline, phase, log, budget, workflow, resolveWorkflow, args }) => { ... }\`.`;
     },
@@ -596448,7 +596730,8 @@ async function checkPermissionsAndCallTool(tool, toolUseID, input2, toolUseConte
         contextModifier: toolContextModifier ? {
           toolUseID,
           modifyContext: toolContextModifier
-        } : undefined
+        } : undefined,
+        toolDuration: { toolName: tool.name, durationMs }
       });
     }
     if (!isMcpTool(tool)) {
@@ -596615,7 +596898,8 @@ async function checkPermissionsAndCallTool(tool, toolUseID, input2, toolUseConte
           toolUseResult: `Error: ${content}`,
           mcpMeta: toolUseContext.agentId ? undefined : error52 instanceof McpToolCallError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS ? error52.mcpMeta : undefined,
           sourceToolAssistantUUID: assistantMessage.uuid
-        })
+        }),
+        toolDuration: { toolName: tool.name, durationMs }
       },
       ...hookMessages
     ];
@@ -596876,6 +597160,9 @@ class StreamingToolExecutor {
         if (update.contextModifier) {
           contextModifiers.push(update.contextModifier.modifyContext);
         }
+        if (update.toolDuration) {
+          tool.toolDuration = update.toolDuration;
+        }
       }
       tool.results = messages;
       tool.contextModifiers = contextModifiers;
@@ -596907,8 +597194,10 @@ class StreamingToolExecutor {
       }
       if (tool.status === "completed" && tool.results) {
         tool.status = "yielded";
+        let toolDuration = tool.toolDuration;
         for (const message of tool.results) {
-          yield { message, newContext: this.toolUseContext };
+          yield { message, newContext: this.toolUseContext, toolDuration };
+          toolDuration = undefined;
         }
         markToolUseAsComplete(this.toolUseContext, tool.id);
       } else if (tool.status === "executing" && !tool.isConcurrencySafe) {
@@ -597168,7 +597457,8 @@ async function* runTools(toolUseMessages, assistantMessages, canUseTool, toolUse
         }
         yield {
           message: update.message,
-          newContext: currentContext
+          newContext: currentContext,
+          ...update.toolDuration && { toolDuration: update.toolDuration }
         };
       }
       for (const block of blocks) {
@@ -597188,7 +597478,8 @@ async function* runTools(toolUseMessages, assistantMessages, canUseTool, toolUse
         }
         yield {
           message: update.message,
-          newContext: currentContext
+          newContext: currentContext,
+          ...update.toolDuration && { toolDuration: update.toolDuration }
         };
       }
     }
@@ -597223,7 +597514,8 @@ async function* runToolsSerially(toolUseMessages, assistantMessages, canUseTool,
       }
       yield {
         message: update.message,
-        newContext: currentContext
+        newContext: currentContext,
+        ...update.toolDuration && { toolDuration: update.toolDuration }
       };
     }
     markToolUseAsComplete2(toolUseContext, toolUse.id);
@@ -599744,7 +600036,8 @@ async function* queryLoop(params, consumedCommandUuids) {
     querySource,
     maxTurns,
     skipCacheWrite,
-    agentCacheTtlOverride
+    agentCacheTtlOverride,
+    compactionRequestKind
   } = params;
   const deps = params.deps ?? productionDeps();
   let state3 = {
@@ -599762,6 +600055,7 @@ async function* queryLoop(params, consumedCommandUuids) {
   };
   const budgetTracker = feature("TOKEN_BUDGET") ? createBudgetTracker() : null;
   let taskBudgetRemaining;
+  let prevToolDurations;
   const config7 = buildQueryConfig();
   const pendingMemoryPrefetch = startRelevantMemoryPrefetch(state3.messages, state3.toolUseContext);
   while (true) {
@@ -599878,6 +600172,7 @@ async function* queryLoop(params, consumedCommandUuids) {
     const toolResults = [];
     const toolUseBlocks = [];
     let needsFollowUp = false;
+    const toolDurations = [];
     queryCheckpoint("query_setup_start");
     const useStreamingToolExecution = config7.gates.streamingToolExecution;
     let streamingToolExecutor = useStreamingToolExecution ? new StreamingToolExecutor(toolUseContext.options.tools, canUseTool, toolUseContext) : null;
@@ -599960,6 +600255,10 @@ async function* queryLoop(params, consumedCommandUuids) {
               agentCacheTtlOverride,
               agentId: toolUseContext.agentId,
               addNotification: toolUseContext.addNotification,
+              ...prevToolDurations !== undefined && { prevToolDurations },
+              ...compactionRequestKind !== undefined && {
+                compactionRequestKind
+              },
               ...params.taskBudget && {
                 taskBudget: {
                   total: params.taskBudget.total,
@@ -600050,6 +600349,9 @@ async function* queryLoop(params, consumedCommandUuids) {
             }
             if (streamingToolExecutor && !toolUseContext.abortController.signal.aborted) {
               for (const result of streamingToolExecutor.getCompletedResults()) {
+                if (result.toolDuration) {
+                  toolDurations.push(result.toolDuration);
+                }
                 if (result.message) {
                   yield result.message;
                   toolResults.push(...normalizeMessagesForAPI([result.message], toolUseContext.options.tools).filter((_4) => _4.type === "user"));
@@ -600397,6 +600699,9 @@ ${stopHookAdditionalContexts.join(`
     }
     const toolUpdates = streamingToolExecutor ? streamingToolExecutor.getRemainingResults() : runTools(toolUseBlocks, assistantMessages, canUseTool, toolUseContext);
     for await (const update of toolUpdates) {
+      if (update.toolDuration) {
+        toolDurations.push(update.toolDuration);
+      }
       if (update.message) {
         yield update.message;
         if (update.message.type === "attachment" && update.message.attachment.type === "hook_stopped_continuation") {
@@ -600412,6 +600717,7 @@ ${stopHookAdditionalContexts.join(`
       }
     }
     queryCheckpoint("query_tool_execution_end");
+    prevToolDurations = toolDurations.length > 0 ? [...toolDurations] : undefined;
     let nextPendingToolUseSummary;
     if (config7.gates.emitToolUseSummaries && toolUseBlocks.length > 0 && !toolUseContext.abortController.signal.aborted && !toolUseContext.agentId) {
       const lastAssistantMessage = assistantMessages.at(-1);
@@ -601418,7 +601724,8 @@ async function runForkedAgent({
   maxTurns,
   onMessage: onMessage2,
   skipTranscript,
-  skipCacheWrite
+  skipCacheWrite,
+  compactionRequestKind
 }) {
   const startTime2 = Date.now();
   const outputMessages = [];
@@ -601451,7 +601758,8 @@ async function runForkedAgent({
       maxOutputTokensOverride: maxOutputTokens,
       maxTurns,
       skipCacheWrite,
-      agentCacheTtlOverride
+      agentCacheTtlOverride,
+      compactionRequestKind
     })) {
       if (message.type === "stream_event") {
         if ("event" in message && message.event?.type === "message_delta" && message.event.usage) {
@@ -606471,7 +606779,8 @@ function mergeHookInstructions(userInstructions, hookInstructions) {
 
 ${hookInstructions}`;
 }
-async function compactConversation(messages, context7, cacheSafeParams, suppressFollowUpQuestions, customInstructions, isAutoCompact = false, recompactionInfo) {
+async function compactConversation(messages, context7, cacheSafeParams, suppressFollowUpQuestions, customInstructions, isAutoCompact = false, recompactionInfo, thresholdSource) {
+  const compactionRequestKind = getCompactionKind(isAutoCompact ? "auto" : "manual", thresholdSource);
   try {
     if (messages.length === 0) {
       throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES);
@@ -606513,7 +606822,8 @@ async function compactConversation(messages, context7, cacheSafeParams, suppress
         appState,
         context: context7,
         preCompactTokenCount,
-        cacheSafeParams: retryCacheSafeParams
+        cacheSafeParams: retryCacheSafeParams,
+        compactionRequestKind
       });
       summary = getAssistantMessageText(summaryResponse);
       if (!summary?.startsWith(PROMPT_TOO_LONG_ERROR_MESSAGE))
@@ -606670,6 +606980,9 @@ async function compactConversation(messages, context7, cacheSafeParams, suppress
       postCompactHookResult.userDisplayMessage
     ].filter(Boolean).join(`
 `);
+    if (shouldSendContextCompactedHeader(recompactionInfo?.querySource ?? context7.options.querySource, context7.agentId)) {
+      armPendingContextCompacted(getCompactionKind(isAutoCompact ? "auto" : "manual", getLastMainRequestId()));
+    }
     return {
       boundaryMarker,
       summaryMessages,
@@ -606927,7 +607240,8 @@ async function streamCompactSummary({
   appState,
   context: context7,
   preCompactTokenCount,
-  cacheSafeParams
+  cacheSafeParams,
+  compactionRequestKind
 }) {
   const promptCacheSharingEnabled = getFeatureValue_CACHED_MAY_BE_STALE("tengu_compact_cache_prefix", true);
   const activityInterval = isSessionActivityTrackingActive() ? setInterval((statusSetter) => {
@@ -606945,7 +607259,8 @@ async function streamCompactSummary({
           forkLabel: "compact",
           maxTurns: 1,
           skipCacheWrite: true,
-          overrides: { abortController: context7.abortController }
+          overrides: { abortController: context7.abortController },
+          ...compactionRequestKind !== undefined && { compactionRequestKind }
         });
         const assistantMsg = getLastAssistantMessage(result.messages);
         const assistantText = assistantMsg ? getAssistantMessageText(assistantMsg) : null;
@@ -607008,6 +607323,7 @@ async function streamCompactSummary({
           hasAppendSystemPrompt: !!context7.options.appendSystemPrompt,
           maxOutputTokensOverride: Math.min(COMPACT_MAX_OUTPUT_TOKENS, getMaxOutputTokensForModel(context7.options.mainLoopModel)),
           querySource: "compact",
+          ...compactionRequestKind !== undefined && { compactionRequestKind },
           agents: context7.options.agentDefinitions.activeAgents,
           mcpTools: [],
           effortValue: appState.effortValue
@@ -607219,6 +607535,7 @@ var init_compact = __esm(() => {
   init_uniqBy();
   init_sdk();
   init_state();
+  init_gatewayHints();
   init_state();
   init_FileReadTool();
   init_prompt3();
@@ -607954,7 +608271,7 @@ async function autoCompactIfNeeded(messages, toolUseContext, cacheSafeParams, qu
     };
   }
   try {
-    const compactionResult = await compactConversation(messages, toolUseContext, cacheSafeParams, true, undefined, true, recompactionInfo);
+    const compactionResult = await compactConversation(messages, toolUseContext, cacheSafeParams, true, undefined, true, recompactionInfo, "auto-compact-threshold");
     setLastSummarizedMessageId(undefined);
     runPostCompactCleanup(querySource);
     return {
@@ -624080,7 +624397,7 @@ var init_p_map = __esm(() => {
 });
 
 // src/tools/MCPTool/prompt.ts
-var PROMPT10 = "", DESCRIPTION24 = "";
+var PROMPT10 = "", DESCRIPTION23 = "";
 
 // src/components/design-system/ProgressBar.tsx
 function ProgressBar(t0) {
@@ -624749,7 +625066,7 @@ var init_MCPTool = __esm(() => {
     name: "mcp",
     maxResultSizeChars: 1e5,
     async description() {
-      return DESCRIPTION24;
+      return DESCRIPTION23;
     },
     async prompt() {
       return PROMPT10;
@@ -633798,7 +634115,7 @@ function getCacheControl({
 function querySourceMatchesPatterns(querySource, patterns) {
   return querySource !== undefined && patterns.some((pattern) => pattern.endsWith("*") ? querySource.startsWith(pattern.slice(0, -1)) : querySource === pattern);
 }
-function isMainThreadQuerySource(querySource) {
+function isMainThreadQuerySource2(querySource) {
   return querySourceMatchesPatterns(querySource, MAIN_THREAD_QUERY_SOURCES);
 }
 function parsePromptCacheTtlEnv(value) {
@@ -633808,7 +634125,7 @@ function resolvePromptCacheTtlOverride(querySource, agentCacheTtlOverride, isUsi
   if (isEnvTruthy(process.env.FORCE_PROMPT_CACHING_5M)) {
     return { ttl: "5m", reason: "force_5m_env" };
   }
-  const isMainThread = isMainThreadQuerySource(querySource);
+  const isMainThread = isMainThreadQuerySource2(querySource);
   const envTtl = parsePromptCacheTtlEnv(isMainThread ? process.env.CLAUDE_CODE_PROMPT_CACHE_TTL : process.env.CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL);
   if (envTtl !== undefined)
     return { ttl: envTtl, reason: "env" };
@@ -634065,7 +634382,7 @@ function getApiForceIdleTimeout() {
   const ms = parseInt(raw, 10);
   return Number.isFinite(ms) && ms > 0 ? ms : undefined;
 }
-async function* executeNonStreamingRequest(clientOptions, retryOptions, paramsFromContext, onAttempt, captureRequest, originatingRequestId) {
+async function* executeNonStreamingRequest(clientOptions, retryOptions, paramsFromContext, onAttempt, captureRequest, originatingRequestId, gatewayHintWireValues) {
   const fallbackTimeoutMs = getNonstreamingFallbackTimeoutMs();
   const generator = withRetry(() => getAnthropicClient({
     maxRetries: 0,
@@ -634079,12 +634396,16 @@ async function* executeNonStreamingRequest(clientOptions, retryOptions, paramsFr
     onAttempt(attempt, start, retryParams.max_tokens);
     const adjustedParams = adjustParamsForNonStreaming(retryParams, MAX_NON_STREAMING_TOKENS);
     try {
+      const hintHeaders = {};
+      applyContextCompactedHeaders(hintHeaders, gatewayHintWireValues?.contextCompactedKindForWire, gatewayHintWireValues?.compactionRequestKindForWire);
+      applyPrevToolDurationsHeader(hintHeaders, gatewayHintWireValues?.prevToolDurationsForWire);
       return await anthropic.beta.messages.create({
         ...adjustedParams,
         model: normalizeModelStringForAPI(adjustedParams.model)
       }, {
         signal: retryOptions.signal,
-        timeout: fallbackTimeoutMs
+        timeout: fallbackTimeoutMs,
+        ...Object.keys(hintHeaders).length > 0 ? { headers: hintHeaders } : {}
       });
     } catch (err2) {
       if (err2 instanceof APIUserAbortError)
@@ -634587,6 +634908,9 @@ ${deferredToolList}
   let research;
   let isFastModeRequest = isFastMode;
   let isAdvisorInProgress = false;
+  const contextCompactedKindForWire = classifyQuerySource(options.querySource) === "main" && options.agentId === undefined ? consumePendingContextCompacted() : undefined;
+  const compactionRequestKindForWire = options.compactionRequestKind;
+  const prevToolDurationsForWire = options.prevToolDurations !== undefined ? buildPrevToolDurationsHeader(options.prevToolDurations) : undefined;
   try {
     let clearStreamIdleTimers = function() {
       if (streamIdleWarningTimer !== null) {
@@ -634643,20 +634967,23 @@ ${deferredToolList}
       }
       clientRequestId = getAPIProvider() === "firstParty" && isFirstPartyAnthropicBaseUrl() ? randomUUID33() : undefined;
       const incomingTrace = shouldPropagateTraceparent() ? getIncomingTraceContext() : undefined;
+      const attemptHeaders = {
+        ...clientRequestId && {
+          [CLIENT_REQUEST_ID_HEADER]: clientRequestId
+        },
+        ...incomingTrace?.traceparent && {
+          traceparent: incomingTrace.traceparent
+        },
+        ...incomingTrace?.tracestate && {
+          tracestate: incomingTrace.tracestate
+        }
+      };
+      applyContextCompactedHeaders(attemptHeaders, contextCompactedKindForWire, compactionRequestKindForWire);
+      applyPrevToolDurationsHeader(attemptHeaders, prevToolDurationsForWire);
       const result = await anthropic.beta.messages.create({ ...params, stream: true }, {
         signal,
         ...getApiForceIdleTimeout() !== undefined ? { timeout: false } : {},
-        headers: {
-          ...clientRequestId && {
-            [CLIENT_REQUEST_ID_HEADER]: clientRequestId
-          },
-          ...incomingTrace?.traceparent && {
-            traceparent: incomingTrace.traceparent
-          },
-          ...incomingTrace?.tracestate && {
-            tracestate: incomingTrace.tracestate
-          }
-        }
+        headers: attemptHeaders
       }).withResponse();
       queryCheckpoint("query_response_headers_received");
       streamRequestId = result.request_id;
@@ -635110,7 +635437,11 @@ ${deferredToolList}
       }, paramsFromContext, (attempt, _startTime, tokens) => {
         attemptNumber = attempt;
         maxOutputTokens = tokens;
-      }, (params) => captureAPIRequest(params, options.querySource), streamRequestId);
+      }, (params) => captureAPIRequest(params, options.querySource), streamRequestId, {
+        contextCompactedKindForWire,
+        compactionRequestKindForWire,
+        prevToolDurationsForWire
+      });
       const m5 = {
         message: {
           ...result,
@@ -635167,7 +635498,11 @@ ${deferredToolList}
         }, paramsFromContext, (attempt, _startTime, tokens) => {
           attemptNumber = attempt;
           maxOutputTokens = tokens;
-        }, (params) => captureAPIRequest(params, options.querySource), failedRequestId);
+        }, (params) => captureAPIRequest(params, options.querySource), failedRequestId, {
+          contextCompactedKindForWire,
+          compactionRequestKindForWire,
+          prevToolDurationsForWire
+        });
         const m5 = {
           message: {
             ...result,
@@ -635658,6 +635993,7 @@ var init_claude = __esm(() => {
   init_utils9();
   init_vcr();
   init_client9();
+  init_gatewayHints();
   init_errors10();
   init_logging2();
   init_rawApiBodies();
@@ -638903,6 +639239,9 @@ function getValueFromInput(input2) {
 function isInputModeCharacter(input2) {
   return input2 === "!";
 }
+function shouldTriggerModeSwitch(keystroke, isAtStart, currentMode) {
+  return currentMode !== undefined && isAtStart && isInputModeCharacter(keystroke) && currentMode !== getModeFromInput(keystroke);
+}
 
 // src/projectOnboardingState.ts
 import { join as join128 } from "path";
@@ -641087,7 +641426,8 @@ function useTextInput({
   onOffsetChange,
   inputFilter,
   inlineGhostText,
-  dim: dim2
+  dim: dim2,
+  getInputMode
 }) {
   if (env4.terminal === "Apple_Terminal") {
     prewarmModifiers();
@@ -641347,7 +641687,7 @@ function useTextInput({
                 if (echo !== null)
                   pushScreenReaderAnnouncement(echo);
               }
-              if (cursor.isAtStart() && isInputModeCharacter(input2)) {
+              if (shouldTriggerModeSwitch(input2, cursor.isAtStart(), getInputMode?.())) {
                 return cursor.insert(text2).left();
               }
               return cursor.insert(text2);
@@ -642114,6 +642454,7 @@ function TextInput(props) {
     onOffsetChange: props.onChangeCursorOffset,
     inputFilter: props.inputFilter,
     inlineGhostText: props.inlineGhostText,
+    getInputMode: props.getInputMode,
     dim: source_default.dim
   });
   return /* @__PURE__ */ jsx_runtime167.jsx(ThemedBox_default, {
@@ -709120,7 +709461,7 @@ function _temp148(s4) {
 }
 async function handleFastModeShortcut(enable2, getAppState, setAppState) {
   const unavailableReason = getFastModeUnavailableReason();
-  if (unavailableReason) {
+  if (enable2 && unavailableReason) {
     return `Fast mode unavailable: ${unavailableReason}`;
   }
   if (enable2) {
@@ -730529,7 +730870,7 @@ function urlMatchesPattern2(url3, pattern) {
   const regexStr = escaped.replace(/\*/g, ".*");
   return new RegExp(`^${regexStr}$`).test(url3);
 }
-function sanitizeHeaderValue(value) {
+function sanitizeHeaderValue2(value) {
   return value.replace(/[\r\n\x00]/g, "");
 }
 function interpolateEnvVars(value, allowedEnvVars) {
@@ -730541,7 +730882,7 @@ function interpolateEnvVars(value, allowedEnvVars) {
     }
     return process.env[varName] ?? "";
   });
-  return sanitizeHeaderValue(interpolated);
+  return sanitizeHeaderValue2(interpolated);
 }
 async function execHttpHook(hook, _hookEvent, jsonInput, signal) {
   const policy = getHttpHookPolicy();
@@ -776925,7 +777266,7 @@ var init_PromptInputStashNotice = __esm(() => {
 function stripLoneSurrogates2(text2) {
   if (isWellFormed && isWellFormed(text2))
     return text2;
-  return text2.replace(LONE_SURROGATE_RE, "");
+  return text2.replace(LONE_SURROGATE_RE2, "");
 }
 function stripAnsiSequences(text2) {
   let result = text2;
@@ -776949,11 +777290,11 @@ function clampBannerTextWidth(maxWidth) {
 function sanitizeAndClampBannerText(text2, maxWidth) {
   return truncateToWidth(sanitizeBannerText(text2), clampBannerTextWidth(maxWidth));
 }
-var BANNER_TEXT_MAX_WIDTH = 24, ANSI_STRIP_PASSES = 4, ANSI_SEQUENCE_RE, LONE_SURROGATE_RE, CONTROL_FORMAT_RE, isWellFormed;
+var BANNER_TEXT_MAX_WIDTH = 24, ANSI_STRIP_PASSES = 4, ANSI_SEQUENCE_RE, LONE_SURROGATE_RE2, CONTROL_FORMAT_RE, isWellFormed;
 var init_sanitizeBannerText = __esm(() => {
   init_truncate();
   ANSI_SEQUENCE_RE = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]|\x1b[\]PX^_][^\x1b\x07]*(?:\x07|\x1b\\)/g;
-  LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+  LONE_SURROGATE_RE2 = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
   CONTROL_FORMAT_RE = /[\p{Cc}\p{Cf}\u2028\u2029]+/gu;
   isWellFormed = typeof String.prototype.isWellFormed === "function" ? Function.prototype.call.bind(String.prototype.isWellFormed) : undefined;
 });
@@ -777919,14 +778260,14 @@ function PromptInput({
     abortSpeculation(setAppState);
     const isSingleCharInsertion = value.length === input2.length + 1;
     const insertedAtStart = cursorOffset === 0;
-    const mode2 = getModeFromInput(value);
-    if (insertedAtStart && mode2 !== "prompt") {
+    const detectedMode = getModeFromInput(value);
+    if (insertedAtStart && detectedMode !== "prompt" && detectedMode !== mode) {
       if (isSingleCharInsertion) {
-        onModeChange(mode2);
+        onModeChange(detectedMode);
         return;
       }
       if (input2.length === 0) {
-        onModeChange(mode2);
+        onModeChange(detectedMode);
         const valueWithoutMode = getValueFromInput(value).replaceAll("\t", "    ");
         pushToBuffer(input2, cursorOffset, pastedContents);
         trackAndSetInput(valueWithoutMode);
@@ -777943,7 +778284,7 @@ function PromptInput({
       footerSelection: null
     });
     trackAndSetInput(processedValue);
-  }, [trackAndSetInput, onModeChange, input2, cursorOffset, pushToBuffer, pastedContents, dismissStashHint, setAppState]);
+  }, [trackAndSetInput, onModeChange, input2, cursorOffset, mode, pushToBuffer, pastedContents, dismissStashHint, setAppState]);
   const {
     resetHistory,
     onHistoryUp,
@@ -779041,7 +779382,8 @@ function PromptInput({
     } : undefined,
     highlights: combinedHighlights,
     inlineGhostText,
-    inputFilter: lazySpaceInputFilter
+    inputFilter: lazySpaceInputFilter,
+    getInputMode: () => mode
   };
   const getBorderColor = () => {
     const modeColors = {
@@ -816520,7 +816862,7 @@ var init_verifyContent = __esm(() => {
 function registerVerifySkill() {
   registerBundledSkill({
     name: "verify",
-    description: DESCRIPTION25,
+    description: DESCRIPTION24,
     userInvocable: true,
     files: SKILL_FILES,
     async getPromptForCommand(args) {
@@ -816536,13 +816878,13 @@ ${args}`);
     }
   });
 }
-var frontmatter, SKILL_BODY, DESCRIPTION25;
+var frontmatter, SKILL_BODY, DESCRIPTION24;
 var init_verify = __esm(() => {
   init_frontmatterParser();
   init_bundledSkills();
   init_verifyContent();
   ({ frontmatter, content: SKILL_BODY } = parseFrontmatter(SKILL_MD));
-  DESCRIPTION25 = typeof frontmatter.description === "string" ? frontmatter.description : "Verify a code change does what it should by running the app.";
+  DESCRIPTION24 = typeof frontmatter.description === "string" ? frontmatter.description : "Verify a code change does what it should by running the app.";
 });
 
 // src/skills/bundled/dream.js
@@ -831528,7 +831870,7 @@ var _FEATURE_ALLOWLIST = new Set([
 var feature2 = (name3) => _FEATURE_ALLOWLIST.has(name3);
 if (typeof globalThis.MACRO === "undefined") {
   globalThis.MACRO = {
-    VERSION: "2.1.270",
+    VERSION: "2.1.273",
     BINARY_NAME: "occ",
     BUILD_TIME: new Date().toISOString(),
     FEEDBACK_CHANNEL: "",