@hiai-gg/hiai-opencode 1.0.0

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

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

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

@@ -0,0 +1,100 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,181 @@
+/**
+ * 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

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

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

@@ -0,0 +1,65 @@
+# 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,222 @@
+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 })
+      }
+    }
+  }
+}