@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/hooks/think-mode/index.ts

@@ -1,5 +0,0 @@
-export * from "./detector"
-export * from "./switcher"
-export * from "./types"
-
-export { clearThinkModeState, createThinkModeHook } from "./hook"

package/src/hooks/think-mode/switcher.ts

@@ -1,100 +0,0 @@
-/**
- * Think Mode Switcher
- *
- * This module handles "thinking mode" activation for reasoning-capable models.
- * When a user includes "think" keywords in their prompt, models are upgraded to
- * their high-reasoning variants with extended thinking budgets.
- *
- * PROVIDER ALIASING:
- * GitHub Copilot acts as a proxy provider that routes to underlying providers
- * (Anthropic, Google, OpenAI). We resolve the proxy to the actual provider
- * based on model name patterns, allowing GitHub Copilot to inherit thinking
- * configurations without duplication.
- *
- * NORMALIZATION:
- * Model IDs are normalized (dots → hyphens in version numbers) to handle API
- * inconsistencies defensively while maintaining backwards compatibility.
- */
-
-import { normalizeModelID } from "../../shared"
-
-/**
- * Extracts provider-specific prefix from model ID (if present).
- * Custom providers may use prefixes for routing (e.g., vertex_ai/, openai/).
- *
- * @example
- * extractModelPrefix("vertex_ai/claude-sonnet-4-6") // { prefix: "vertex_ai/", base: "claude-sonnet-4-6" }
- * extractModelPrefix("claude-sonnet-4-6") // { prefix: "", base: "claude-sonnet-4-6" }
- * extractModelPrefix("openai/gpt-5.4") // { prefix: "openai/", base: "gpt-5.4" }
- * extractModelPrefix("aws/anthropic/claude-sonnet-4") // { prefix: "aws/anthropic/", base: "claude-sonnet-4" }
- */
-function extractModelPrefix(modelID: string): { prefix: string; base: string } {
-  const slashIndex = modelID.lastIndexOf("/")
-  if (slashIndex === -1) {
-    return { prefix: "", base: modelID }
-  }
-  return {
-    prefix: modelID.slice(0, slashIndex + 1),
-    base: modelID.slice(slashIndex + 1),
-  }
-}
-
-
-// Maps model IDs to their "high reasoning" variant (internal convention)
-// For OpenAI models, this signals that reasoning_effort should be set to "high"
-const HIGH_VARIANT_MAP: Record<string, string> = {
-  // Claude
-  "claude-sonnet-4-6": "claude-sonnet-4-6-high",
-  "claude-opus-4-6": "claude-opus-4-6-high",
-   // Gemini
-   "gemini-3-1-pro": "gemini-3-1-pro-high",
-   "gemini-3-1-pro-low": "gemini-3-1-pro-high",
-   "gemini-3-flash": "gemini-3-flash-high",
-  // GPT-5
-  "gpt-5": "gpt-5-high",
-  "gpt-5-mini": "gpt-5-mini-high",
-  "gpt-5-nano": "gpt-5-nano-high",
-  "gpt-5-pro": "gpt-5-pro-high",
-  "gpt-5-chat-latest": "gpt-5-chat-latest-high",
-  // GPT-5.1
-  "gpt-5-1": "gpt-5-1-high",
-  "gpt-5-1-chat-latest": "gpt-5-1-chat-latest-high",
-  "gpt-5-1-codex": "gpt-5-1-codex-high",
-  "gpt-5-1-codex-mini": "gpt-5-1-codex-mini-high",
-  "gpt-5-1-codex-max": "gpt-5-1-codex-max-high",
-  // GPT-5.4
-  "gpt-5-4": "gpt-5-4-high",
-  "gpt-5-4-chat-latest": "gpt-5-4-chat-latest-high",
-  "gpt-5-4-pro": "gpt-5-4-pro-high",
-  // Antigravity (Google)
-  "antigravity-gemini-3-1-pro": "antigravity-gemini-3-1-pro-high",
-  "antigravity-gemini-3-flash": "antigravity-gemini-3-flash-high",
-}
-
-const ALREADY_HIGH: Set<string> = new Set(Object.values(HIGH_VARIANT_MAP))
-
-
-export function getHighVariant(modelID: string): string | null {
-  const normalized = normalizeModelID(modelID)
-  const { prefix, base } = extractModelPrefix(normalized)
-
-  // Check if already high variant (with or without prefix)
-  if (ALREADY_HIGH.has(base) || base.endsWith("-high")) {
-    return null
-  }
-
-  // Look up high variant for base model
-  const highBase = HIGH_VARIANT_MAP[base]
-  if (!highBase) {
-    return null
-  }
-
-  // Preserve prefix in the high variant
-  return prefix + highBase
-}
-
-export function isAlreadyHighVariant(modelID: string): boolean {
-  const normalized = normalizeModelID(modelID)
-  const { base } = extractModelPrefix(normalized)
-  return ALREADY_HIGH.has(base) || base.endsWith("-high")
-}

package/src/hooks/think-mode/types.ts

@@ -1,16 +0,0 @@
-export interface ThinkModeState {
-  requested: boolean
-  modelSwitched: boolean
-  variantSet: boolean
-  providerID?: string
-  modelID?: string
-}
-
-interface ModelRef {
-  providerID: string
-  modelID: string
-}
-
-interface MessageWithModel {
-  model?: ModelRef
-}

package/src/hooks/thinking-block-validator/hook.ts

@@ -1,181 +0,0 @@
-/**
- * Proactive Thinking Block Validator Hook
- *
- * Prevents "Expected thinking/redacted_thinking but found tool_use" errors
- * by validating and fixing message structure BEFORE sending to Anthropic API.
- *
- * This hook runs on the "experimental.chat.messages.transform" hook point,
- * which is called before messages are converted to ModelMessage format and
- * sent to the API.
- *
- * Key differences from session-recovery hook:
- * - PROACTIVE (prevents error) vs REACTIVE (fixes after error)
- * - Runs BEFORE API call vs AFTER API error
- * - User never sees the error vs User sees error then recovery
- */
-
-import type { Message, Part } from "@opencode-ai/sdk"
-
-interface MessageWithParts {
-  info: Message
-  parts: Part[]
-}
-
-type MessagesTransformHook = {
-  "experimental.chat.messages.transform"?: (
-    input: Record<string, never>,
-    output: { messages: MessageWithParts[] }
-  ) => Promise<void>
-}
-
-type SignedThinkingPart = Part & {
-  type: "thinking" | "redacted_thinking"
-  thinking?: string
-  signature: string
-  synthetic?: boolean
-}
-
-function isSignedThinkingPart(part: Part): part is SignedThinkingPart {
-  const type = part.type as string
-  if (type !== "thinking" && type !== "redacted_thinking") {
-    return false
-  }
-
-  const signature = (part as { signature?: unknown }).signature
-  const synthetic = (part as { synthetic?: unknown }).synthetic
-  return typeof signature === "string" && signature.length > 0 && synthetic !== true
-}
-
-/**
- * Check if there are any Anthropic-signed thinking blocks in the message history.
- *
- * Only returns true for real `type: "thinking"` blocks with a valid `signature`.
- * GPT reasoning blocks (`type: "reasoning"`) are intentionally excluded - they
- * have no Anthropic signature and must never be forwarded to the Anthropic API.
- *
- * Model-name checks are unreliable (miss GPT+thinking, custom model IDs, etc.)
- * so we inspect the messages themselves.
- */
-function hasSignedThinkingBlocksInHistory(messages: MessageWithParts[]): boolean {
-  return messages.some(
-    m =>
-      m.info.role === "assistant" &&
-      m.parts?.some((p: Part) => isSignedThinkingPart(p)),
-  )
-}
-
-/**
- * Check if a message has any content parts (tool_use, text, or other non-thinking content)
- */
-function hasContentParts(parts: Part[]): boolean {
-  if (!parts || parts.length === 0) return false
-
-  return parts.some((part: Part) => {
-    const type = part.type as string
-    // Include tool parts and text parts (anything that's not thinking/reasoning)
-    return type === "tool" || type === "tool_use" || type === "text"
-  })
-}
-
-/**
- * Check if a message starts with a thinking/reasoning block
- */
-function startsWithThinkingBlock(parts: Part[]): boolean {
-  if (!parts || parts.length === 0) return false
-
-  const firstPart = parts[0]
-  const type = firstPart.type as string
-  return type === "thinking" || type === "redacted_thinking" || type === "reasoning"
-}
-
-/**
- * Find the most recent Anthropic-signed thinking part from previous assistant messages.
- *
- * Returns the original Part object (including its `signature` field) so it can
- * be reused verbatim in another message.  Only `type: "thinking"` blocks with
- * both a `signature` and `thinking` field are returned - GPT `type: "reasoning"`
- * blocks are excluded because they lack an Anthropic signature and would be
- * rejected by the API with "Invalid `signature` in `thinking` block".
- * Synthetic parts injected by a previous run of this hook are also skipped.
- */
-function findPreviousThinkingPart(messages: MessageWithParts[], currentIndex: number): SignedThinkingPart | null {
-  // Search backwards from current message
-  for (let i = currentIndex - 1; i >= 0; i--) {
-    const msg = messages[i]
-    if (msg.info.role !== "assistant") continue
-    if (!msg.parts) continue
-
-    for (const part of msg.parts) {
-      // Only Anthropic thinking blocks - type must be "thinking", not "reasoning"
-      if (!isSignedThinkingPart(part)) continue
-
-      return part
-    }
-  }
-
-  return null
-}
-
-/**
- * Prepend an existing thinking block (with its original signature) to a
- * message's parts array.
- *
- * We reuse the original Part verbatim instead of creating a new one, because
- * the Anthropic API validates the `signature` field against the thinking
- * content.  Any synthetic block we create ourselves would fail that check.
- */
-function prependThinkingBlock(message: MessageWithParts, thinkingPart: SignedThinkingPart): void {
-  if (!message.parts) {
-    message.parts = []
-  }
-
-  message.parts.unshift(thinkingPart)
-}
-
-/**
- * Validate and fix assistant messages that have tool_use but no thinking block
- */
-export function createThinkingBlockValidatorHook(): MessagesTransformHook {
-  return {
-    "experimental.chat.messages.transform": async (_input, output) => {
-      const { messages } = output
-
-      if (!messages || messages.length === 0) {
-        return
-      }
-
-      // Skip if there are no Anthropic-signed thinking blocks in history.
-      // This is more reliable than checking model names - works for Claude,
-      // GPT with thinking variants, or any future model.  Crucially, GPT
-      // reasoning blocks (type="reasoning", no signature) do NOT trigger this
-      // hook - only real Anthropic thinking blocks do.
-      if (!hasSignedThinkingBlocksInHistory(messages)) {
-        return
-      }
-
-      // Process all assistant messages
-      for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i]
-
-        // Only check assistant messages
-        if (msg.info.role !== "assistant") continue
-
-        // Check if message has content parts but doesn't start with thinking
-        if (hasContentParts(msg.parts) && !startsWithThinkingBlock(msg.parts)) {
-          // Find the most recent real thinking part (with valid signature) from
-          // previous turns.  If none exists we cannot safely inject a thinking
-          // block - a synthetic block without a signature would cause the API
-          // to reject the request with "Invalid `signature` in `thinking` block".
-          const previousThinkingPart = findPreviousThinkingPart(messages, i)
-
-          if (previousThinkingPart) {
-            prependThinkingBlock(msg, previousThinkingPart)
-          }
-          // If no real thinking part is available, skip injection entirely.
-          // The downstream error (if any) is preferable to a guaranteed API
-          // rejection caused by a signature-less synthetic thinking block.
-        }
-      }
-    },
-  }
-}

package/src/hooks/thinking-block-validator/index.ts

@@ -1 +0,0 @@
-export { createThinkingBlockValidatorHook } from "./hook"

package/src/hooks/todo-continuation-enforcer/AGENTS.md

@@ -1,65 +0,0 @@
-# src/hooks/todo-continuation-enforcer/ — Boulder Continuation Mechanism
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-14 files (~2061 LOC). The "boulder" — Continuation Tier hook that forces Bob to keep rolling when incomplete todos remain. Fires on `session.idle`, injects continuation prompt after 2s countdown toast.
-
-## HOW IT WORKS
-
-```
-session.idle
-  → Is main session (not strategist/compaction)? (DEFAULT_SKIP_AGENTS)
-  → No abort detected recently? (ABORT_WINDOW_MS = 3s)
-  → Todos still incomplete? (todo.ts)
-  → No background tasks running?
-  → Cooldown passed? (CONTINUATION_COOLDOWN_MS = 30s)
-  → Failure count < max? (MAX_CONSECUTIVE_FAILURES = 5)
-  → Start 2s countdown toast → inject CONTINUATION_PROMPT
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `handler.ts` | `createTodoContinuationHandler()` — event router, delegates to idle/non-idle handlers |
-| `idle-event.ts` | `handleSessionIdle()` — main decision gate for session.idle |
-| `non-idle-events.ts` | `handleNonIdleEvent()` — handles session.error (abort detection) |
-| `session-state.ts` | `SessionStateStore` — per-session failure/abort/cooldown state |
-| `todo.ts` | Check todo completion status via session store |
-| `countdown.ts` | 2s countdown toast before injection |
-| `abort-detection.ts` | Detect MessageAbortedError / AbortError |
-| `continuation-injection.ts` | Build + inject CONTINUATION_PROMPT into session |
-| `message-directory.ts` | Temp dir for message injection exchange |
-| `constants.ts` | Timing constants, CONTINUATION_PROMPT, skip agents |
-| `types.ts` | `SessionState`, handler argument types |
-
-## CONSTANTS
-
-```typescript
-DEFAULT_SKIP_AGENTS = ["strategist", "compaction", "plan"]
-CONTINUATION_COOLDOWN_MS = 30_000     // 30s between injections
-MAX_CONSECUTIVE_FAILURES = 5          // Then 5min pause (exponential backoff)
-FAILURE_RESET_WINDOW_MS = 5 * 60_000  // 5min window for failure reset
-COUNTDOWN_SECONDS = 2
-ABORT_WINDOW_MS = 3000                // Grace after abort signal
-```
-
-## STATE PER SESSION
-
-```typescript
-interface SessionState {
-  failureCount: number       // Consecutive failures
-  lastFailureAt?: number     // Timestamp
-  abortDetectedAt?: number   // Reset after ABORT_WINDOW_MS
-  cooldownUntil?: number     // Next injection allowed after
-  countdownTimer?: Timer     // Active countdown reference
-}
-```
-
-## RELATIONSHIP TO ATLAS
-
-`todoContinuationEnforcer` handles **main Bob sessions** only.
-`guardHook` handles **boulder/ralph/subagent sessions** with a different decision gate.
-Both fire on `session.idle` but check session type first.

package/src/hooks/todo-continuation-enforcer/abort-detection.ts

@@ -1,17 +0,0 @@
-import type { MessageInfo } from "./types"
-
-export function isLastAssistantMessageAborted(
-  messages: Array<{ info?: MessageInfo }>
-): boolean {
-  if (!messages || messages.length === 0) return false
-
-  const assistantMessages = messages.filter((message) => message.info?.role === "assistant")
-  if (assistantMessages.length === 0) return false
-
-  const lastAssistant = assistantMessages[assistantMessages.length - 1]
-  const errorName = lastAssistant.info?.error?.name
-
-  if (!errorName) return false
-
-  return errorName === "MessageAbortedError" || errorName === "AbortError"
-}

package/src/hooks/todo-continuation-enforcer/compaction-guard.ts

@@ -1,39 +0,0 @@
-import { COMPACTION_GUARD_MS } from "./constants"
-import type { SessionState } from "./types"
-
-export function armCompactionGuard(state: SessionState, now: number): number {
-  const nextEpoch = (state.recentCompactionEpoch ?? 0) + 1
-
-  state.recentCompactionAt = now
-  state.recentCompactionEpoch = nextEpoch
-
-  return nextEpoch
-}
-
-export function acknowledgeCompactionGuard(
-  state: SessionState,
-  compactionEpoch: number | undefined
-): boolean {
-  if (compactionEpoch === undefined) {
-    return false
-  }
-
-  if (state.recentCompactionEpoch !== compactionEpoch) {
-    return false
-  }
-
-  state.acknowledgedCompactionEpoch = compactionEpoch
-  return true
-}
-
-export function isCompactionGuardActive(state: SessionState, now: number): boolean {
-  if (state.recentCompactionAt === undefined || state.recentCompactionEpoch === undefined) {
-    return false
-  }
-
-  if (state.acknowledgedCompactionEpoch === state.recentCompactionEpoch) {
-    return false
-  }
-
-  return now - state.recentCompactionAt < COMPACTION_GUARD_MS
-}

package/src/hooks/todo-continuation-enforcer/constants.ts

@@ -1,25 +0,0 @@
-import { createSystemDirective, SystemDirectiveTypes } from "../../shared/system-directive"
-
-export const HOOK_NAME = "todo-continuation-enforcer"
-
-export const DEFAULT_SKIP_AGENTS = ["strategist", "compaction", "plan"]
-
-export const CONTINUATION_PROMPT = `${createSystemDirective(SystemDirectiveTypes.TODO_CONTINUATION)}
-
-Incomplete tasks remain in your todo list. Continue working on the next pending task.
-
-- Proceed without asking for permission
-- Mark each task complete when finished
-- Do not stop until all tasks are done
-- If you believe all work is already complete, the system is questioning your completion claim. Critically re-examine each todo item from a skeptical perspective, verify the work was actually done correctly, and update the todo list accordingly.`
-
-export const COUNTDOWN_SECONDS = 2
-export const TOAST_DURATION_MS = 900
-export const COUNTDOWN_GRACE_PERIOD_MS = 500
-
-export const ABORT_WINDOW_MS = 3000
-export const COMPACTION_GUARD_MS = 60_000
-export const CONTINUATION_COOLDOWN_MS = 5_000
-export const MAX_STAGNATION_COUNT = 3
-export const MAX_CONSECUTIVE_FAILURES = 5
-export const FAILURE_RESET_WINDOW_MS = 5 * 60 * 1000

package/src/hooks/todo-continuation-enforcer/continuation-injection.ts

@@ -1,222 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-import type { BackgroundManager } from "../../features/background-agent"
-import {
-  getSessionAgent,
-  resolveRegisteredAgentName,
-} from "../../features/claude-code-session-state"
-import {
-  createInternalAgentTextPart,
-  normalizeSDKResponse,
-  resolveInheritedPromptTools,
-} from "../../shared"
-import {
-  findNearestMessageWithFields,
-  findNearestMessageWithFieldsFromSDK,
-  type ToolPermission,
-} from "../../features/hook-message-injector"
-import { log } from "../../shared/logger"
-import { isSqliteBackend } from "../../shared/opencode-storage-detection"
-import {
-  getAgentConfigKey,
-  normalizeAgentForPromptKey,
-} from "../../shared/agent-display-names"
-
-import {
-  CONTINUATION_PROMPT,
-  DEFAULT_SKIP_AGENTS,
-  HOOK_NAME,
-} from "./constants"
-import { isCompactionGuardActive } from "./compaction-guard"
-import { getMessageDir } from "./message-directory"
-import { isTokenLimitError } from "./token-limit-detection"
-import { getIncompleteCount } from "./todo"
-import type { ResolvedMessageInfo, Todo } from "./types"
-import type { SessionStateStore } from "./session-state"
-
-function hasWritePermission(tools: Record<string, ToolPermission> | undefined): boolean {
-  const editPermission = tools?.edit
-  const writePermission = tools?.write
-  return (
-    !tools ||
-    (editPermission !== false && editPermission !== "deny" && writePermission !== false && writePermission !== "deny")
-  )
-}
-
-export async function injectContinuation(args: {
-  ctx: PluginInput
-  sessionID: string
-  backgroundManager?: BackgroundManager
-  skipAgents?: string[]
-  resolvedInfo?: ResolvedMessageInfo
-  sessionStateStore: SessionStateStore
-  isContinuationStopped?: (sessionID: string) => boolean
-}): Promise<void> {
-  const {
-    ctx,
-    sessionID,
-    backgroundManager,
-    skipAgents = DEFAULT_SKIP_AGENTS,
-    resolvedInfo,
-    sessionStateStore,
-    isContinuationStopped,
-  } = args
-
-  const state = sessionStateStore.getExistingState(sessionID)
-  if (state?.isRecovering) {
-    log(`[${HOOK_NAME}] Skipped injection: in recovery`, { sessionID })
-    return
-  }
-
-  if (state?.wasCancelled) {
-    log(`[${HOOK_NAME}] Skipped injection: session was cancelled`, { sessionID })
-    return
-  }
-
-  if (isContinuationStopped?.(sessionID)) {
-    log(`[${HOOK_NAME}] Skipped injection: continuation stopped for session`, { sessionID })
-    return
-  }
-
-  const hasRunningBgTasks = backgroundManager
-    ? backgroundManager.getTasksByParentSession(sessionID).some((task: { status: string }) => task.status === "running")
-    : false
-
-  if (hasRunningBgTasks) {
-    log(`[${HOOK_NAME}] Skipped injection: background tasks running`, { sessionID })
-    return
-  }
-
-  let todos: Todo[] = []
-  try {
-    const response = await ctx.client.session.todo({ path: { id: sessionID } })
-    todos = normalizeSDKResponse(response, [] as Todo[], { preferResponseOnMissingData: true })
-  } catch (error) {
-    log(`[${HOOK_NAME}] Failed to fetch todos`, { sessionID, error: String(error) })
-    return
-  }
-
-  const freshIncompleteCount = getIncompleteCount(todos)
-  if (freshIncompleteCount === 0) {
-    log(`[${HOOK_NAME}] Skipped injection: no incomplete todos`, { sessionID })
-    return
-  }
-
-  let agentName = resolvedInfo?.agent ?? getSessionAgent(sessionID)
-  let model = resolvedInfo?.model
-  let tools = resolvedInfo?.tools
-
-  if (!agentName || !model) {
-    let previousMessage = null
-    if (isSqliteBackend()) {
-      previousMessage = await findNearestMessageWithFieldsFromSDK(ctx.client, sessionID)
-    } else {
-      const messageDir = getMessageDir(sessionID)
-      previousMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
-    }
-    agentName = agentName ?? previousMessage?.agent
-    model =
-      model ??
-      (previousMessage?.model?.providerID && previousMessage?.model?.modelID
-        ? {
-            providerID: previousMessage.model.providerID,
-            modelID: previousMessage.model.modelID,
-            ...(previousMessage.model.variant
-              ? { variant: previousMessage.model.variant }
-              : {}),
-          }
-        : undefined)
-    tools = tools ?? previousMessage?.tools
-  }
-
-  const promptAgent = normalizeAgentForPromptKey(agentName)
-  const launchAgent = resolveRegisteredAgentName(agentName)
-
-  if (promptAgent && skipAgents.some(s => getAgentConfigKey(s) === getAgentConfigKey(promptAgent))) {
-    log(`[${HOOK_NAME}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName })
-    return
-  }
-
-  if (!promptAgent) {
-    const compactionState = sessionStateStore.getExistingState(sessionID)
-    if (compactionState && isCompactionGuardActive(compactionState, Date.now())) {
-      log(`[${HOOK_NAME}] Skipped: agent unknown after compaction`, { sessionID })
-      return
-    }
-  }
-
-  if (!hasWritePermission(tools)) {
-    log(`[${HOOK_NAME}] Skipped: agent lacks write permission`, { sessionID, agent: agentName })
-    return
-  }
-
-  const incompleteTodos = todos.filter((todo) => todo.status !== "completed" && todo.status !== "cancelled")
-  const todoList = incompleteTodos.map((todo) => `- [${todo.status}] ${todo.content}`).join("\n")
-  const prompt = `${CONTINUATION_PROMPT}
-
-[Status: ${todos.length - freshIncompleteCount}/${todos.length} completed, ${freshIncompleteCount} remaining]
-
-Remaining tasks:
-${todoList}`
-
-  const injectionState = sessionStateStore.getExistingState(sessionID)
-  if (injectionState?.wasCancelled) {
-    log(`[${HOOK_NAME}] Skipped injection: session was cancelled before prompt`, { sessionID })
-    return
-  }
-
-  if (injectionState) {
-    injectionState.inFlight = true
-  }
-
-  try {
-    log(`[${HOOK_NAME}] Injecting continuation`, {
-      sessionID,
-      agent: launchAgent ?? promptAgent,
-      model,
-      incompleteCount: freshIncompleteCount,
-    })
-
-    const inheritedTools = resolveInheritedPromptTools(sessionID, tools)
-
-    const launchModel = model
-      ? { providerID: model.providerID, modelID: model.modelID }
-      : undefined
-    const launchVariant = model?.variant
-
-    await ctx.client.session.promptAsync({
-      path: { id: sessionID },
-      body: {
-        agent: launchAgent ?? promptAgent,
-        ...(launchModel ? { model: launchModel } : {}),
-        ...(launchVariant ? { variant: launchVariant } : {}),
-        ...(inheritedTools ? { tools: inheritedTools } : {}),
-        parts: [createInternalAgentTextPart(prompt)],
-      },
-      query: { directory: ctx.directory },
-    })
-
-    log(`[${HOOK_NAME}] Injection successful`, { sessionID })
-    if (injectionState) {
-      injectionState.inFlight = false
-      injectionState.lastInjectedAt = Date.now()
-      injectionState.awaitingPostInjectionProgressCheck = true
-      injectionState.consecutiveFailures = 0
-    }
-  } catch (error) {
-    log(`[${HOOK_NAME}] Injection failed`, { sessionID, error: String(error) })
-    if (injectionState) {
-      injectionState.inFlight = false
-      injectionState.lastInjectedAt = Date.now()
-      injectionState.consecutiveFailures = (injectionState.consecutiveFailures ?? 0) + 1
-
-      const errorObj = error instanceof Error
-        ? { name: error.name, message: error.message }
-        : { message: String(error) }
-      if (isTokenLimitError(errorObj)) {
-        injectionState.tokenLimitDetected = true
-        log(`[${HOOK_NAME}] Token limit error detected during injection, stopping continuation`, { sessionID })
-      }
-    }
-  }
-}