@hiai-gg/hiai-opencode 0.1.1 → 0.1.3

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

@@ -1,181 +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.
-        }
-      }
-    },
-  }
-}
+/**
+ * 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 +1 @@
-export { createThinkingBlockValidatorHook } from "./hook"
+export { createThinkingBlockValidatorHook } from "./hook"

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

@@ -1,65 +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.
+# 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 +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"
-}
+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 +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
-}
+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 +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
+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