oh-my-opencode 4.5.12 → 4.6.0

package/dist/index.js

@@ -54030,7 +54030,7 @@ function buildTmuxAttachCommand(serverUrl, sessionId, directory = process.cwd())
 }
 function buildTmuxPlaceholderCommand(description) {
   const escapedDescription = shellEscapeForDoubleQuotedCommand(description);
-  return `${TMUX_COMMAND_SHELL} -c "printf '%s\\n%s\\n' "OMO subagent pane ready: ${escapedDescription}" "Focus this pane to attach."; exec tail -f /dev/null"`;
+  return `${TMUX_COMMAND_SHELL} -c "printf '%s\\n%s\\n' "OMO subagent pane ready: ${escapedDescription}" "Focus this pane to attach."; while :; do sleep 86400; done"`;
 }
 var TMUX_COMMAND_SHELL = "/bin/sh";
 var init_pane_command = () => {};
@@ -55033,7 +55033,7 @@ async function withDispatchTimeout(operation, dispatchTimeoutMs, operationName)
     }
   }
 }
-var DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS = 2000, DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS = 30000, DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, DEFAULT_PROMPT_QUEUE_RETRY_MS = 250, promptGateMessagesFetchTimeoutMsForTesting;
+var DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS = 2000, DEFAULT_PROMPT_SEMANTIC_DEDUPE_HOLD_MS = 15000, DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS = 30000, DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, DEFAULT_PROMPT_QUEUE_RETRY_MS = 250, promptGateMessagesFetchTimeoutMsForTesting;
 
 // src/shared/prompt-async-gate/pending-tool-turn.ts
 function getPromptQuery(input) {
@@ -55146,6 +55146,45 @@ var init_pending_tool_turn = __esm(() => {
   init_message_inspection_error();
 });
 
+// src/shared/prompt-async-gate/recent-dispatches.ts
+function recentDispatchKey(sessionID, dedupeKey) {
+  return `${sessionID}\x00${dedupeKey}`;
+}
+function pruneRecentPromptDispatches(now = Date.now()) {
+  for (const [key, dispatch] of recentPromptDispatches) {
+    if (dispatch.expiresAt <= now) {
+      recentPromptDispatches.delete(key);
+    }
+  }
+}
+function getRecentPromptDispatch(sessionID, dedupeKey) {
+  pruneRecentPromptDispatches();
+  return recentPromptDispatches.get(recentDispatchKey(sessionID, dedupeKey));
+}
+function rememberRecentPromptDispatch(args) {
+  pruneRecentPromptDispatches();
+  if (args.holdMs <= 0) {
+    return;
+  }
+  recentPromptDispatches.set(recentDispatchKey(args.sessionID, args.dedupeKey), {
+    source: args.source,
+    expiresAt: Date.now() + args.holdMs
+  });
+  log("[prompt-async-gate] remembered semantic prompt dispatch", {
+    sessionID: args.sessionID,
+    source: args.source,
+    holdMs: args.holdMs
+  });
+}
+function deleteRecentPromptDispatch(sessionID, dedupeKey) {
+  recentPromptDispatches.delete(recentDispatchKey(sessionID, dedupeKey));
+}
+var recentPromptDispatches;
+var init_recent_dispatches = __esm(() => {
+  init_logger();
+  recentPromptDispatches = new Map;
+});
+
 // src/shared/prompt-async-gate/reservations.ts
 function setExpiredReservationHandler(handler) {
   expiredReservationHandler = handler;
@@ -55227,6 +55266,7 @@ async function dispatchAfterSessionIdle(args) {
     dedupeKey,
     settleMs,
     postDispatchHoldMs,
+    semanticDedupeHoldMs,
     dispatchTimeoutMs,
     checkStatus,
     checkToolState,
@@ -55284,10 +55324,25 @@ async function dispatchAfterSessionIdle(args) {
     log(`[prompt-async-gate] ${sessionName} dispatching`, { sessionID, source });
     dispatchAttempted = true;
     const response = await withDispatchTimeout(dispatch(input), dispatchTimeoutMs, `[prompt-async-gate] ${sessionName} dispatch`);
+    rememberRecentPromptDispatch({
+      sessionID,
+      dedupeKey,
+      source,
+      holdMs: semanticDedupeHoldMs
+    });
     log(`[prompt-async-gate] ${sessionName} dispatched`, { sessionID, source });
     return { status: "dispatched", response };
   } catch (error) {
-    log(`[prompt-async-gate] ${sessionName} failed`, { sessionID, source, error: String(error) });
+    if (dispatchAttempted) {
+      rememberRecentPromptDispatch({
+        sessionID,
+        dedupeKey,
+        source,
+        holdMs: semanticDedupeHoldMs
+      });
+    }
+    const errorText = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    log(`[prompt-async-gate] ${sessionName} failed`, { sessionID, source, error: errorText });
     return { status: "failed", error, dispatchAttempted };
   } finally {
     finishPromptReservation(sessionID, reservation, dispatchAttempted, postDispatchHoldMs);
@@ -55297,6 +55352,7 @@ var init_session_idle_dispatch = __esm(() => {
   init_logger();
   init_session_idle_settle();
   init_pending_tool_turn();
+  init_recent_dispatches();
   init_reservations();
 });
 
@@ -55404,6 +55460,7 @@ async function drainPromptQueue(sessionID, awaitedEntry) {
         dedupeKey: entry.dedupeKey,
         settleMs: entry.settleMs,
         postDispatchHoldMs: entry.postDispatchHoldMs,
+        semanticDedupeHoldMs: entry.semanticDedupeHoldMs,
         dispatchTimeoutMs: entry.dispatchTimeoutMs,
         checkStatus: entry.checkStatus,
         checkToolState: entry.checkToolState,
@@ -55487,27 +55544,119 @@ var init_queue = __esm(() => {
   });
 });
 
-// src/shared/prompt-async-gate.ts
+// src/shared/prompt-async-gate/semantic-dedupe.ts
+import { createHash } from "crypto";
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function canonicalizePromptInputForDedupe(key, value, seen = new WeakSet, depth = 0) {
+  if (key === "signal") {
+    return "[AbortSignal]";
+  }
+  if (typeof value === "function") {
+    return `[Function:${value.name}]`;
+  }
+  if (depth > MAX_PROMPT_DEDUPE_DEPTH) {
+    return "[MaxDepth]";
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    try {
+      return value.map((entry) => canonicalizePromptInputForDedupe("", entry, seen, depth + 1));
+    } finally {
+      seen.delete(value);
+    }
+  }
+  if (!isPlainRecord(value)) {
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  try {
+    const canonicalEntries = [];
+    for (const entryKey of Object.keys(value).sort()) {
+      canonicalEntries.push([
+        entryKey,
+        canonicalizePromptInputForDedupe(entryKey, value[entryKey], seen, depth + 1)
+      ]);
+    }
+    return Object.fromEntries(canonicalEntries);
+  } finally {
+    seen.delete(value);
+  }
+}
+function isContinuationTextPartLike(value) {
+  if (!isPlainRecord(value)) {
+    return false;
+  }
+  if (value.type !== "text" || typeof value.text !== "string") {
+    return false;
+  }
+  if (!hasInternalInitiatorMarker(value.text)) {
+    return false;
+  }
+  if (!isPlainRecord(value.metadata)) {
+    return false;
+  }
+  return value.metadata.compaction_continue === true;
+}
+function hasContinuationPromptIntent(input) {
+  if (!isPlainRecord(input) || !isPlainRecord(input.body) || !Array.isArray(input.body.parts)) {
+    return false;
+  }
+  return input.body.parts.some((part) => isContinuationTextPartLike(part));
+}
+function normalizePromptInputForSemanticDedupe(input) {
+  if (hasContinuationPromptIntent(input)) {
+    return {
+      __omo_internal_intent: "continuation"
+    };
+  }
+  return canonicalizePromptInputForDedupe("", input);
+}
 function stringifyPromptInputForDedupe(input) {
   try {
-    const serialized = JSON.stringify(input, (key, value) => {
-      if (key === "signal") {
-        return "[AbortSignal]";
-      }
-      if (typeof value === "function") {
-        return `[Function:${value.name}]`;
-      }
-      return value;
-    });
+    const serialized = JSON.stringify(normalizePromptInputForSemanticDedupe(input));
     return serialized ?? String(input);
-  } catch {
-    return String(input);
+  } catch (error) {
+    const errorTag = error instanceof Error ? error.name : String(error);
+    return `${String(input)}:[unserializable:${errorTag}]`;
   }
 }
-function createDefaultDedupeKey(source, input) {
+function createSemanticPromptDedupeKey(input) {
   const fingerprint = stringifyPromptInputForDedupe(input);
-  return `${source}:${fingerprint.length}:${fingerprint.slice(0, 8192)}`;
+  const digest = createHash("sha256").update(fingerprint, "utf8").digest("hex");
+  return `semantic:${digest}`;
 }
+function coalesceRecentSemanticPromptDispatch(args) {
+  const recentDispatch = getRecentPromptDispatch(args.sessionID, args.dedupeKey);
+  if (!recentDispatch) {
+    return;
+  }
+  log("[prompt-async-gate] prompt coalesced with recent semantic dispatch", {
+    sessionID: args.sessionID,
+    source: args.source,
+    queuedBy: recentDispatch.source
+  });
+  return { status: "queued", queuedBy: recentDispatch.source, position: 0 };
+}
+var MAX_PROMPT_DEDUPE_DEPTH = 64;
+var init_semantic_dedupe = __esm(() => {
+  init_internal_initiator_marker();
+  init_logger();
+  init_recent_dispatches();
+});
+
+// src/shared/prompt-async-gate.ts
 function hasObjectSessionPath(input) {
   return typeof input === "object" && input !== null && "path" in input && typeof input.path === "object" && input.path !== null && "id" in input.path && typeof input.path.id === "string";
 }
@@ -55537,9 +55686,10 @@ async function dispatchInternalPrompt(args) {
     source,
     settleMs = DEFAULT_SESSION_IDLE_SETTLE_MS
   } = args;
-  const dedupeKey = args.dedupeKey ?? createDefaultDedupeKey(source, input);
+  const dedupeKey = args.dedupeKey ?? createSemanticPromptDedupeKey(input);
   const queueRetryMs = args.queueRetryMs ?? DEFAULT_PROMPT_QUEUE_RETRY_MS;
   const postDispatchHoldMs = args.postDispatchHoldMs ?? DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS;
+  const semanticDedupeHoldMs = args.semanticDedupeHoldMs ?? (postDispatchHoldMs > 0 ? DEFAULT_PROMPT_SEMANTIC_DEDUPE_HOLD_MS : 0);
   const dispatchTimeoutMs = args.dispatchTimeoutMs ?? DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS;
   const sessionName = args.mode === "async" ? "promptAsync" : "prompt";
   const dispatch = (() => {
@@ -55572,6 +55722,10 @@ async function dispatchInternalPrompt(args) {
     if (queuedBy !== undefined || isPromptQueueDraining(sessionID)) {
       return { status: "reserved", reservedBy: queuedBy ?? source };
     }
+    const recentDispatchResult2 = coalesceRecentSemanticPromptDispatch({ sessionID, dedupeKey, source });
+    if (recentDispatchResult2) {
+      return recentDispatchResult2;
+    }
     return dispatchAfterSessionIdle({
       sessionName,
       client,
@@ -55581,6 +55735,7 @@ async function dispatchInternalPrompt(args) {
       dedupeKey,
       settleMs,
       postDispatchHoldMs,
+      semanticDedupeHoldMs,
       dispatchTimeoutMs,
       checkStatus: args.checkStatus !== false,
       checkToolState: args.checkToolState !== false,
@@ -55588,6 +55743,10 @@ async function dispatchInternalPrompt(args) {
     });
   }
   if (args.queue !== false) {
+    const recentDispatchResult2 = coalesceRecentSemanticPromptDispatch({ sessionID, dedupeKey, source });
+    if (recentDispatchResult2) {
+      return recentDispatchResult2;
+    }
     return enqueueInternalPrompt({
       id: nextPromptQueueID(),
       sessionID,
@@ -55598,6 +55757,7 @@ async function dispatchInternalPrompt(args) {
       dedupeKey,
       settleMs,
       postDispatchHoldMs,
+      semanticDedupeHoldMs,
       dispatchTimeoutMs,
       queueRetryMs,
       checkStatus: args.checkStatus !== false,
@@ -55605,6 +55765,10 @@ async function dispatchInternalPrompt(args) {
       dispatch: async (_dispatchInput) => dispatchWithPathCompatibility(dispatch, input)
     });
   }
+  const recentDispatchResult = coalesceRecentSemanticPromptDispatch({ sessionID, dedupeKey, source });
+  if (recentDispatchResult) {
+    return recentDispatchResult;
+  }
   return dispatchAfterSessionIdle({
     sessionName,
     client,
@@ -55614,6 +55778,7 @@ async function dispatchInternalPrompt(args) {
     dedupeKey,
     settleMs,
     postDispatchHoldMs,
+    semanticDedupeHoldMs,
     dispatchTimeoutMs,
     checkStatus: args.checkStatus !== false,
     checkToolState: args.checkToolState !== false,
@@ -55638,6 +55803,7 @@ function releasePromptAsyncReservation(sessionID, source, options) {
     return false;
   }
   deletePromptReservation(sessionID);
+  deleteRecentPromptDispatch(sessionID, existing.dedupeKey);
   releaseInFlightPromptMatchingDedupe(sessionID, existing.dedupeKey);
   schedulePromptQueueDrain(sessionID, 0);
   log("[prompt-async-gate] promptAsync reservation released", {
@@ -55651,8 +55817,10 @@ var init_prompt_async_gate = __esm(() => {
   init_logger();
   init_session_idle_settle();
   init_queue();
+  init_recent_dispatches();
   init_reservations();
   init_session_idle_dispatch();
+  init_semantic_dedupe();
 });
 
 // src/shared/prompt-failure-classifier.ts
@@ -69458,80 +69626,6 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
     dispose: () => sessionStateStore.shutdown()
   };
 }
-// src/hooks/context-window-monitor.ts
-init_context_limit_resolver2();
-init_compaction_marker();
-init_event_session_id();
-init_system_directive();
-var CONTEXT_WARNING_THRESHOLD = 0.7;
-function createContextReminder(actualLimit) {
-  const limitTokens = actualLimit.toLocaleString();
-  return `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
-
-You are using a ${limitTokens}-token context window.
-You still have context remaining - do NOT rush or skip tasks.
-Complete your work thoroughly and methodically.`;
-}
-function createContextWindowMonitorHook(_ctx, modelCacheState) {
-  const remindedSessions = new Set;
-  const tokenCache = new Map;
-  const toolExecuteAfter = async (input, output) => {
-    const { sessionID } = input;
-    if (remindedSessions.has(sessionID))
-      return;
-    const cached2 = tokenCache.get(sessionID);
-    if (!cached2)
-      return;
-    const actualLimit = resolveActualContextLimit(cached2.providerID, cached2.modelID, modelCacheState);
-    if (!actualLimit)
-      return;
-    const lastTokens = cached2.tokens;
-    const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0);
-    const actualUsagePercentage = totalInputTokens / actualLimit;
-    if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD)
-      return;
-    remindedSessions.add(sessionID);
-    const clampedPercentage = Math.min(Math.max(actualUsagePercentage, 0), 1);
-    const usedPct = (clampedPercentage * 100).toFixed(1);
-    const remainingPct = ((1 - clampedPercentage) * 100).toFixed(1);
-    const usedTokens = totalInputTokens.toLocaleString();
-    const limitTokens = actualLimit.toLocaleString();
-    output.output += `
-
-${createContextReminder(actualLimit)}
-[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`;
-  };
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionID = resolveSessionEventID(props);
-      if (sessionID) {
-        remindedSessions.delete(sessionID);
-        tokenCache.delete(sessionID);
-      }
-    }
-    if (event.type === "message.updated") {
-      const info = props?.info;
-      const finish = info?.finish;
-      if (!info || info.role !== "assistant" || !finish)
-        return;
-      if (isCompactionAgent(info.agent))
-        return;
-      const sessionID = resolveMessageEventSessionID(props);
-      if (!sessionID || !info.providerID || !info.tokens)
-        return;
-      tokenCache.set(sessionID, {
-        providerID: info.providerID,
-        modelID: info.modelID ?? "",
-        tokens: info.tokens
-      });
-    }
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
 // src/hooks/session-notification-content.ts
 init_shared();
 function extractMessageText(message) {
@@ -72900,7 +72994,7 @@ function findClosingDelimiter(content, openingLength) {
 }
 // packages/rules-engine/src/matcher.ts
 var import_picomatch = __toESM(require_picomatch2(), 1);
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { basename as basename6, relative as relative8 } from "path";
 var matcherCache = new Map;
 var MAX_MATCHER_CACHE_ENTRIES = 256;
@@ -72929,7 +73023,7 @@ function shouldApplyRule(metadata, currentFilePath, projectRoot) {
   return { applies: false };
 }
 function createContentHash(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
 }
 function isDuplicateByRealPath(realPath, cache) {
   return cache.has(realPath);
@@ -91169,6 +91263,12 @@ var initDeepSkill = {
   template: loadSharedSkillTemplate("init-deep"),
   argumentHint: "[--create-new] [--max-depth=N]"
 };
+// src/features/builtin-skills/skills/debugging.ts
+var debuggingSkill = {
+  name: "debugging",
+  description: "MUST USE for any real runtime debugging across ANY language or binary \u2014 crashes, silent failures, wrong responses, stuck processes, memory leaks, async misbehavior, unexplained timing, reverse engineering. Runs a hypothesis-driven loop: form \u22653 hypotheses, investigate in parallel, after 2 failed rounds spawn Oracles from orthogonal angles, confirm root cause, lock with a failing test, fix minimally, QA by actually USING the system, scrub artifacts. The actual HOW lives in `references/` \u2014 READ THEM. Triggers: 'debug this', 'why is X not working', 'hanging', 'attach a debugger', 'reverse engineer', 'pwndbg', 'gdb', 'lldb', 'node inspect', 'tsx debug', 'pdb', 'dlv', 'delve', 'rust-gdb', 'set a breakpoint', 'context window exploded', 'why is the response empty', 'attach the debugger', 'debug it', 'why is this happening', 'trace this bug', 'reproduce and fix', 'silent failure', 'HTTP 200 but empty', 'why did it stop', 'inspect the binary', 'reverse engineering', 'playwright'.",
+  template: loadSharedSkillTemplate("debugging")
+};
 // src/features/builtin-skills/security-research/SKILL.md
 var SKILL_default = `# Security Research - Team Mode Vulnerability Audit
 
@@ -91604,6 +91704,7 @@ function createBuiltinSkills(options = {}) {
     reviewWorkSkill,
     removeAiSlopsSkill,
     initDeepSkill,
+    debuggingSkill,
     securityResearchSkill,
     securityReviewSkill
   ];
@@ -92008,7 +92109,6 @@ var GitMasterConfigSchema = z17.object({
 import { z as z18 } from "zod";
 var HookNameSchema = z18.enum([
   "todo-continuation-enforcer",
-  "context-window-monitor",
   "session-recovery",
   "session-notification",
   "comment-checker",
@@ -114387,7 +114487,6 @@ function createRuntimeTmuxConfig(pluginConfig) {
 function createSessionHooks(args) {
   const { ctx, pluginConfig, modelCacheState, backgroundManager, modelFallbackControllerAccessor, isHookEnabled, safeHookEnabled } = args;
   const safeHook = (hookName, factory) => safeCreateHook(hookName, factory, { enabled: safeHookEnabled });
-  const contextWindowMonitor = isHookEnabled("context-window-monitor") ? safeHook("context-window-monitor", () => createContextWindowMonitorHook(ctx, modelCacheState)) : null;
   const preemptiveCompaction = isHookEnabled("preemptive-compaction") && pluginConfig.experimental?.preemptive_compaction ? safeHook("preemptive-compaction", () => createPreemptiveCompactionHook(ctx, pluginConfig, modelCacheState)) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? safeHook("session-recovery", () => createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental })) : null;
   let sessionNotification = null;
@@ -114485,7 +114584,6 @@ function createSessionHooks(args) {
   })) : null;
   const legacyPluginToast = isHookEnabled("legacy-plugin-toast") ? safeHook("legacy-plugin-toast", () => createLegacyPluginToastHook(ctx)) : null;
   return {
-    contextWindowMonitor,
     preemptiveCompaction,
     sessionRecovery,
     sessionNotification,
@@ -116063,7 +116161,8 @@ class ParentWakeNotifier {
       const role = this.getParentWakeMessageRole(message);
       if (role === "assistant") {
         const waiting = this.getParentWakeMessageFinish(message) === "tool-calls" || message.parts?.some((part) => this.parentWakePartIsWaitingOnTool(part)) === true;
-        return waiting ? { waiting: true, activityAt: getParentWakeMessageActivityAt(message) } : { waiting: false };
+        const activityAt = getParentWakeMessageActivityAt(message);
+        return waiting ? { waiting: true, activityAt } : { waiting: false, activityAt };
       }
       if (role === "user") {
         if (isSyntheticOrInternalUserMessage(message)) {
@@ -116162,16 +116261,18 @@ class ParentWakeNotifier {
     }
     const latestToolWaitAgeMs = toolWaitState.activityAt === undefined ? 0 : now - toolWaitState.activityAt;
     const deferAge = now - wake.toolCallDeferralStartedAt;
+    const latestAssistantActivityAgeMs = toolWaitState.activityAt === undefined ? deferAge : now - toolWaitState.activityAt;
     if (wake.shouldReply && toolWaitState.waiting && deferAge >= this.options.toolCallDeferMaxMs && latestToolWaitAgeMs >= this.options.toolCallDeferMaxMs) {
       log("[background-agent] Sending parent wake after stale tool-call deferral window:", {
         sessionID
       });
       return { defer: false, skipPromptGateToolStateCheck: true };
     }
-    if (!toolWaitState.waiting && deferAge >= this.options.toolCallDeferMaxMs) {
+    if (!toolWaitState.waiting && deferAge >= this.options.toolCallDeferMaxMs && latestAssistantActivityAgeMs >= this.options.toolCallDeferMaxMs) {
       log("[background-agent] Sending parent wake after stale assistant-text deferral window:", {
         sessionID,
-        deferAgeMs: deferAge
+        deferAgeMs: deferAge,
+        latestAssistantActivityAgeMs
       });
       return { defer: false, skipPromptGateToolStateCheck: true };
     }
@@ -119692,13 +119793,13 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
 import { spawn as spawn3 } from "child_process";
-import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
 import { createServer as createServer2 } from "http";
 function generateCodeVerifier() {
   return randomBytes2(32).toString("base64url");
 }
 function generateCodeChallenge(verifier) {
-  return createHash2("sha256").update(verifier).digest("base64url");
+  return createHash3("sha256").update(verifier).digest("base64url");
 }
 function buildAuthorizationUrl(authorizationEndpoint, options) {
   const url = new URL(authorizationEndpoint);
@@ -140762,11 +140863,17 @@ init_model_normalization();
 var ASSISTANT_PREFILL_RECOVERY_TEXT = "[internal] Continue from the previous assistant state.";
 var ASSISTANT_PREFILL_UNSUPPORTED_PROVIDERS = new Set([
   "anthropic",
-  "google-vertex-anthropic"
+  "aws-bedrock-anthropic",
+  "github-copilot",
+  "github-copilot-enterprise",
+  "google-vertex-anthropic",
+  "opencode",
+  "opencode-go",
+  "opencode-zen-proxy",
+  "vercel"
 ]);
 var ASSISTANT_PREFILL_UNSUPPORTED_MODEL_PREFIXES = [
-  "claude-opus-4-7",
-  "claude-opus-4-6",
+  "claude-opus-4",
   "claude-sonnet-4-6",
   "claude-mythos"
 ];
@@ -140817,15 +140924,26 @@ function findLastUserModel(messages) {
   }
   return;
 }
+function normalizeAssistantPrefillModelID(modelID) {
+  const normalizedModelID = normalizeModelID(modelID.toLowerCase());
+  return normalizedModelID.split(/[/.~:@]+/).find((segment) => segment.startsWith("claude-")) ?? normalizedModelID;
+}
+function hasAnthropicModelNamespace(modelID) {
+  const normalizedModelID = normalizeModelID(modelID.toLowerCase());
+  return /(?:^|[/.~:@])anthropic(?:$|[/.~:@])/.test(normalizedModelID);
+}
+function providerCanExposeUnsupportedAssistantPrefill(providerID, modelID) {
+  return ASSISTANT_PREFILL_UNSUPPORTED_PROVIDERS.has(providerID) || hasAnthropicModelNamespace(modelID);
+}
 function shouldRepairAssistantPrefillForModel(model) {
   if (!model) {
     return false;
   }
   const providerID = model.providerID.toLowerCase();
-  if (!ASSISTANT_PREFILL_UNSUPPORTED_PROVIDERS.has(providerID)) {
+  if (!providerCanExposeUnsupportedAssistantPrefill(providerID, model.modelID)) {
     return false;
   }
-  const modelID = normalizeModelID(model.modelID.toLowerCase());
+  const modelID = normalizeAssistantPrefillModelID(model.modelID);
   return ASSISTANT_PREFILL_UNSUPPORTED_MODEL_PREFIXES.some((prefix) => modelID.startsWith(prefix));
 }
 function isCompactionContinuationPart(part) {
@@ -140886,9 +141004,10 @@ async function runMessagesTransformHookSafely(hookName, handler, input, output)
   try {
     await Promise.resolve(handler(input, output));
   } catch (error) {
+    const hookError = error instanceof Error ? error : new Error(String(error));
     log("[messages-transform] hook execution failed", {
       hook: hookName,
-      error
+      error: hookError
     });
   }
 }
@@ -141514,6 +141633,33 @@ function normalizeSessionStatusToIdle(input) {
 
 // src/plugin/event.ts
 init_event_session_id();
+
+// src/plugin/user-abort-interrupted-recovery-guard.ts
+var USER_ABORT_ERROR_NAMES = new Set(["MessageAbortedError", "AbortError"]);
+function createUserAbortInterruptedRecoveryGuard() {
+  const abortedSessions = new Set;
+  return {
+    noteSessionError(sessionID, errorName) {
+      if (!errorName || !USER_ABORT_ERROR_NAMES.has(errorName)) {
+        return false;
+      }
+      abortedSessions.add(sessionID);
+      return true;
+    },
+    shouldSkipRecovery(sessionID) {
+      const shouldSkip = abortedSessions.has(sessionID);
+      if (shouldSkip) {
+        abortedSessions.delete(sessionID);
+      }
+      return shouldSkip;
+    },
+    clear(sessionID) {
+      abortedSessions.delete(sessionID);
+    }
+  };
+}
+
+// src/plugin/event.ts
 function isRecord26(value) {
   return typeof value === "object" && value !== null;
 }
@@ -141598,6 +141744,7 @@ function createEventHandler2(args) {
   const lastKnownModelBySession = new Map;
   const modelFallbackContinuationsInFlight = new Set;
   const lastDispatchedModelFallbackContinuationKeys = new Map;
+  const userAbortInterruptedRecoveryGuard = createUserAbortInterruptedRecoveryGuard();
   const resolveFallbackProviderID = (sessionID, providerHint) => {
     const normalizedProviderHint = providerHint?.trim();
     if (normalizedProviderHint) {
@@ -141651,7 +141798,6 @@ function createEventHandler2(args) {
     await runEventHookSafely("sessionNotification", hooks2.sessionNotification, input);
     await runEventHookSafely("todoContinuationEnforcer", hooks2.todoContinuationEnforcer?.handler, input);
     await runEventHookSafely("unstableAgentBabysitter", hooks2.unstableAgentBabysitter?.event, input);
-    await runEventHookSafely("contextWindowMonitor", hooks2.contextWindowMonitor?.event, input);
     await runEventHookSafely("preemptiveCompaction", hooks2.preemptiveCompaction?.event, input);
     await runEventHookSafely("directoryAgentsInjector", hooks2.directoryAgentsInjector?.event, input);
     await runEventHookSafely("directoryReadmeInjector", hooks2.directoryReadmeInjector?.event, input);
@@ -141713,6 +141859,10 @@ function createEventHandler2(args) {
     if (!sessionID || !hooks2.sessionRecovery?.handleInterruptedToolResultsOnIdle) {
       return false;
     }
+    if (userAbortInterruptedRecoveryGuard.shouldSkipRecovery(sessionID)) {
+      log("[event] interrupted tool recovery skipped after user abort", { sessionID });
+      return false;
+    }
     return hooks2.sessionRecovery.handleInterruptedToolResultsOnIdle(sessionID);
   };
   const dispatchIdleOnlyHooks = async (input) => {
@@ -141872,10 +142022,6 @@ function createEventHandler2(args) {
         const emittedAt = recentSyntheticIdles.get(sessionID);
         if (emittedAt !== undefined && now - emittedAt < DEDUP_WINDOW_MS2) {
           recentSyntheticIdles.delete(sessionID);
-          const lastAnyIdleAt = recentAnyIdles.get(sessionID);
-          if (lastAnyIdleAt === emittedAt) {
-            recentAnyIdles.delete(sessionID);
-          }
         }
       }
       const recovered = await recoverInterruptedToolResultsOnIdleEvent(input);
@@ -141964,6 +142110,7 @@ function createEventHandler2(args) {
         lastKnownModelBySession.delete(sessionID);
         modelFallbackContinuationsInFlight.delete(sessionID);
         lastDispatchedModelFallbackContinuationKeys.delete(sessionID);
+        userAbortInterruptedRecoveryGuard.clear(sessionID);
         if (modelFallback) {
           clearPendingModelFallback(modelFallback, sessionID);
           clearSessionFallbackChain(modelFallback, sessionID);
@@ -142042,6 +142189,10 @@ function createEventHandler2(args) {
           lastKnownModelBySession.set(sessionID, { providerID, modelID });
           setSessionModel(sessionID, { providerID, modelID });
         }
+        userAbortInterruptedRecoveryGuard.clear(sessionID);
+      }
+      if (sessionID && role === "assistant") {
+        userAbortInterruptedRecoveryGuard.noteSessionError(sessionID, extractErrorName3(info?.error));
       }
       if (sessionID && role === "assistant" && !isRuntimeFallbackEnabled && isModelFallbackEnabled) {
         try {
@@ -142157,6 +142308,9 @@ function createEventHandler2(args) {
         const errorName = extractErrorName3(error);
         const errorMessage = extractErrorMessage3(error);
         const errorInfo = { name: errorName, message: errorMessage };
+        if (sessionID) {
+          userAbortInterruptedRecoveryGuard.noteSessionError(sessionID, errorName);
+        }
         if (hooks2.sessionRecovery?.isRecoverableError(error)) {
           const messageInfo = {
             id: props?.messageID,
@@ -142356,7 +142510,6 @@ function createToolExecuteAfterHandler3(args) {
       await hooks2.toolOutputTruncator?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.claudeCodeHooks?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.preemptiveCompaction?.["tool.execute.after"]?.(hookInput, output);
-      await hooks2.contextWindowMonitor?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.commentChecker?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.directoryAgentsInjector?.["tool.execute.after"]?.(hookInput, output);
       await hooks2.directoryReadmeInjector?.["tool.execute.after"]?.(hookInput, output);