@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/features/background-agent/state.ts

@@ -1,199 +0,0 @@
-import type { BackgroundTask, LaunchInput } from "./types"
-import type { QueueItem } from "./constants"
-import { log } from "../../shared"
-import { subagentSessions } from "../claude-code-session-state"
-export class TaskStateManager {
-  readonly tasks: Map<string, BackgroundTask> = new Map()
-  readonly notifications: Map<string, BackgroundTask[]> = new Map()
-  readonly pendingByParent: Map<string, Set<string>> = new Map()
-  readonly queuesByKey: Map<string, QueueItem[]> = new Map()
-  readonly processingKeys: Set<string> = new Set()
-  readonly completionTimers: Map<string, ReturnType<typeof setTimeout>> = new Map()
-  getTask(id: string): BackgroundTask | undefined {
-    return this.tasks.get(id)
-  }
-  findBySession(sessionID: string): BackgroundTask | undefined {
-    for (const task of this.tasks.values()) {
-      if (task.sessionID === sessionID) {
-        return task
-      }
-    }
-    return undefined
-  }
-  getTasksByParentSession(sessionID: string): BackgroundTask[] {
-    const result: BackgroundTask[] = []
-    for (const task of this.tasks.values()) {
-      if (task.parentSessionID === sessionID) {
-        result.push(task)
-      }
-    }
-    return result
-  }
-
-  getAllDescendantTasks(sessionID: string): BackgroundTask[] {
-    const result: BackgroundTask[] = []
-    const directChildren = this.getTasksByParentSession(sessionID)
-
-    for (const child of directChildren) {
-      result.push(child)
-      if (child.sessionID) {
-        const descendants = this.getAllDescendantTasks(child.sessionID)
-        result.push(...descendants)
-      }
-    }
-
-    return result
-  }
-
-  getRunningTasks(): BackgroundTask[] {
-    return Array.from(this.tasks.values()).filter(t => t.status === "running")
-  }
-  getNonRunningTasks(): BackgroundTask[] {
-    return Array.from(this.tasks.values()).filter(t => t.status !== "running")
-  }
-
-  hasRunningTasks(): boolean {
-    for (const task of this.tasks.values()) {
-      if (task.status === "running") return true
-    }
-    return false
-  }
-
-  getConcurrencyKeyFromInput(input: LaunchInput): string {
-    if (input.model) {
-      return `${input.model.providerID}/${input.model.modelID}`
-    }
-    return input.agent
-  }
-
-  getConcurrencyKeyFromTask(task: BackgroundTask): string {
-    if (task.model) {
-      return `${task.model.providerID}/${task.model.modelID}`
-    }
-    return task.agent
-  }
-
-  addTask(task: BackgroundTask): void {
-    this.tasks.set(task.id, task)
-  }
-
-  removeTask(taskId: string): void {
-    const task = this.tasks.get(taskId)
-    if (task?.sessionID) {
-      subagentSessions.delete(task.sessionID)
-    }
-    this.tasks.delete(taskId)
-  }
-
-  trackPendingTask(parentSessionID: string, taskId: string): void {
-    const pending = this.pendingByParent.get(parentSessionID) ?? new Set()
-    pending.add(taskId)
-    this.pendingByParent.set(parentSessionID, pending)
-  }
-
-  cleanupPendingByParent(task: BackgroundTask): void {
-    if (!task.parentSessionID) return
-    const pending = this.pendingByParent.get(task.parentSessionID)
-    if (pending) {
-      pending.delete(task.id)
-      if (pending.size === 0) {
-        this.pendingByParent.delete(task.parentSessionID)
-      }
-    }
-  }
-
-  markForNotification(task: BackgroundTask): void {
-    const queue = this.notifications.get(task.parentSessionID) ?? []
-    queue.push(task)
-    this.notifications.set(task.parentSessionID, queue)
-  }
-
-  getPendingNotifications(sessionID: string): BackgroundTask[] {
-    return this.notifications.get(sessionID) ?? []
-  }
-
-  clearNotifications(sessionID: string): void {
-    this.notifications.delete(sessionID)
-  }
-
-  clearNotificationsForTask(taskId: string): void {
-    for (const [sessionID, tasks] of this.notifications.entries()) {
-      const filtered = tasks.filter((t) => t.id !== taskId)
-      if (filtered.length === 0) {
-        this.notifications.delete(sessionID)
-      } else {
-        this.notifications.set(sessionID, filtered)
-      }
-    }
-  }
-
-  addToQueue(key: string, item: QueueItem): void {
-    const queue = this.queuesByKey.get(key) ?? []
-    queue.push(item)
-    this.queuesByKey.set(key, queue)
-  }
-
-  getQueue(key: string): QueueItem[] | undefined {
-    return this.queuesByKey.get(key)
-  }
-
-  removeFromQueue(key: string, taskId: string): boolean {
-    const queue = this.queuesByKey.get(key)
-    if (!queue) return false
-
-    const index = queue.findIndex(item => item.task.id === taskId)
-    if (index === -1) return false
-
-    queue.splice(index, 1)
-    if (queue.length === 0) {
-      this.queuesByKey.delete(key)
-    }
-    return true
-  }
-
-  setCompletionTimer(taskId: string, timer: ReturnType<typeof setTimeout>): void {
-    this.completionTimers.set(taskId, timer)
-  }
-
-  clearCompletionTimer(taskId: string): void {
-    const timer = this.completionTimers.get(taskId)
-    if (timer) {
-      clearTimeout(timer)
-      this.completionTimers.delete(taskId)
-    }
-  }
-
-  clearAllCompletionTimers(): void {
-    for (const timer of this.completionTimers.values()) {
-      clearTimeout(timer)
-    }
-    this.completionTimers.clear()
-  }
-
-  clear(): void {
-    this.clearAllCompletionTimers()
-    this.tasks.clear()
-    this.notifications.clear()
-    this.pendingByParent.clear()
-    this.queuesByKey.clear()
-    this.processingKeys.clear()
-  }
-
-  cancelPendingTask(taskId: string): boolean {
-    const task = this.tasks.get(taskId)
-    if (!task || task.status !== "pending") {
-      return false
-    }
-
-    const key = this.getConcurrencyKeyFromTask(task)
-    this.removeFromQueue(key, taskId)
-
-    task.status = "cancelled"
-    task.completedAt = new Date()
-
-    this.cleanupPendingByParent(task)
-
-    log("[background-agent] Cancelled pending task:", { taskId, key })
-    return true
-  }
-}

package/src/features/background-agent/subagent-spawn-limits.ts

@@ -1,97 +0,0 @@
-import type { BackgroundTaskConfig } from "../../config/schema"
-import type { OpencodeClient } from "./constants"
-
-export const DEFAULT_MAX_SUBAGENT_DEPTH = 3
-export const DEFAULT_MAX_ROOT_SESSION_SPAWN_BUDGET = 50
-
-export interface SubagentSpawnContext {
-  rootSessionID: string
-  parentDepth: number
-  childDepth: number
-}
-
-export function getMaxSubagentDepth(config?: BackgroundTaskConfig): number {
-  return config?.maxDepth ?? DEFAULT_MAX_SUBAGENT_DEPTH
-}
-
-export function getMaxRootSessionSpawnBudget(config?: BackgroundTaskConfig): number {
-  return config?.maxDescendants ?? DEFAULT_MAX_ROOT_SESSION_SPAWN_BUDGET
-}
-
-export async function resolveSubagentSpawnContext(
-  client: OpencodeClient,
-  parentSessionID: string,
-  directory?: string
-): Promise<SubagentSpawnContext> {
-  const visitedSessionIDs = new Set<string>()
-  let rootSessionID = parentSessionID
-  let currentSessionID = parentSessionID
-  let parentDepth = 0
-
-  while (true) {
-    if (visitedSessionIDs.has(currentSessionID)) {
-      throw new Error(`Detected a session parent cycle while resolving ${parentSessionID}`)
-    }
-
-    visitedSessionIDs.add(currentSessionID)
-
-    let nextParentSessionID: string | undefined
-    try {
-      const response = await client.session.get({
-        path: { id: currentSessionID },
-        ...(directory ? { query: { directory } } : {}),
-      })
-      if (response.error) {
-        throw new Error(String(response.error))
-      }
-
-      if (!response.data) {
-        throw new Error("No session data returned")
-      }
-
-      nextParentSessionID = response.data.parentID
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error)
-      throw new Error(
-        `Subagent spawn blocked: failed to resolve session lineage for ${parentSessionID}, so background_task.maxDescendants cannot be enforced safely. ${reason}`
-      )
-    }
-
-    if (!nextParentSessionID) {
-      rootSessionID = currentSessionID
-      break
-    }
-
-    currentSessionID = nextParentSessionID
-    parentDepth += 1
-  }
-
-  return {
-    rootSessionID,
-    parentDepth,
-    childDepth: parentDepth + 1,
-  }
-}
-
-export function createSubagentDepthLimitError(input: {
-  childDepth: number
-  maxDepth: number
-  parentSessionID: string
-  rootSessionID: string
-}): Error {
-  const { childDepth, maxDepth, parentSessionID, rootSessionID } = input
-  return new Error(
-    `Subagent spawn blocked: child depth ${childDepth} exceeds background_task.maxDepth=${maxDepth}. Parent session: ${parentSessionID}. Root session: ${rootSessionID}. Continue in an existing subagent session instead of spawning another.`
-  )
-}
-
-export function createSubagentDescendantLimitError(input: {
-  rootSessionID: string
-  descendantCount: number
-  maxDescendants: number
-}): Error {
-  const { rootSessionID, descendantCount, maxDescendants } = input
-  return new Error(
-    `Subagent spawn blocked: root session ${rootSessionID} already has ${descendantCount} descendants, which meets background_task.maxDescendants=${maxDescendants}. Reuse an existing session instead of spawning another.`
-  )
-}

package/src/features/background-agent/task-history.ts

@@ -1,79 +0,0 @@
-import type { BackgroundTaskStatus } from "./types"
-
-const MAX_ENTRIES_PER_PARENT = 100
-
-export interface TaskHistoryEntry {
-  id: string
-  sessionID?: string
-  agent: string
-  description: string
-  status: BackgroundTaskStatus
-  category?: string
-  startedAt?: Date
-  completedAt?: Date
-}
-
-export class TaskHistory {
-  private entries: Map<string, TaskHistoryEntry[]> = new Map()
-
-  record(parentSessionID: string | undefined, entry: TaskHistoryEntry): void {
-    if (!parentSessionID) return
-
-    const list = this.entries.get(parentSessionID) ?? []
-    const existing = list.findIndex((e) => e.id === entry.id)
-
-    if (existing !== -1) {
-      const current = list[existing]
-      list[existing] = {
-        ...current,
-        ...(entry.sessionID !== undefined ? { sessionID: entry.sessionID } : {}),
-        ...(entry.agent !== undefined ? { agent: entry.agent } : {}),
-        ...(entry.description !== undefined ? { description: entry.description } : {}),
-        ...(entry.status !== undefined ? { status: entry.status } : {}),
-        ...(entry.category !== undefined ? { category: entry.category } : {}),
-        ...(entry.startedAt !== undefined ? { startedAt: entry.startedAt } : {}),
-        ...(entry.completedAt !== undefined ? { completedAt: entry.completedAt } : {}),
-      }
-    } else {
-      if (list.length >= MAX_ENTRIES_PER_PARENT) {
-        list.shift()
-      }
-      list.push({ ...entry })
-    }
-
-    this.entries.set(parentSessionID, list)
-  }
-
-  getByParentSession(parentSessionID: string): TaskHistoryEntry[] {
-    const list = this.entries.get(parentSessionID)
-    if (!list) return []
-    return list.map((e) => ({ ...e }))
-  }
-
-  clearSession(parentSessionID: string): void {
-    this.entries.delete(parentSessionID)
-  }
-
-  clearAll(): void {
-    this.entries.clear()
-  }
-
-  formatForCompaction(parentSessionID: string): string | null {
-    const list = this.getByParentSession(parentSessionID)
-    if (list.length === 0) return null
-
-    const lines = list.map((e) => {
-      const desc = e.description?.replace(/[\n\r]+/g, " ").trim() ?? ""
-      const parts = [
-        `- **${e.agent}**`,
-        e.category ? `[${e.category}]` : null,
-        `(${e.status})`,
-        `: ${desc}`,
-        e.sessionID ? ` | session: \`${e.sessionID}\`` : null,
-      ]
-      return parts.filter(Boolean).join("")
-    })
-
-    return lines.join("\n")
-  }
-}

package/src/features/background-agent/task-poller.ts

@@ -1,225 +0,0 @@
-import { log } from "../../shared"
-import { CONFIG_BASENAME } from "../../shared/plugin-identity"
-
-import type { BackgroundTaskConfig } from "../../config/schema"
-import type { BackgroundTask } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-import type { OpencodeClient } from "./opencode-client"
-
-import {
-  DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS,
-  DEFAULT_SESSION_GONE_TIMEOUT_MS,
-  DEFAULT_STALE_TIMEOUT_MS,
-  MIN_RUNTIME_BEFORE_STALE_MS,
-  TERMINAL_TASK_TTL_MS,
-  TASK_TTL_MS,
-} from "./constants"
-import { abortWithTimeout } from "./abort-with-timeout"
-import { removeTaskToastTracking } from "./remove-task-toast-tracking"
-import { MIN_SESSION_GONE_POLLS, verifySessionExists } from "./session-existence"
-
-import { isActiveSessionStatus } from "./session-status-classifier"
-const TERMINAL_TASK_STATUSES = new Set<BackgroundTask["status"]>([
-  "completed",
-  "error",
-  "cancelled",
-  "interrupt",
-])
-
-export function pruneStaleTasksAndNotifications(args: {
-  tasks: Map<string, BackgroundTask>
-  notifications: Map<string, BackgroundTask[]>
-  onTaskPruned: (taskId: string, task: BackgroundTask, errorMessage: string) => void
-  taskTtlMs?: number
-}): void {
-  const { tasks, notifications, onTaskPruned } = args
-  const effectiveTtl = args.taskTtlMs ?? TASK_TTL_MS
-  const now = Date.now()
-  const tasksWithPendingNotifications = new Set<string>()
-
-  for (const queued of notifications.values()) {
-    for (const task of queued) {
-      tasksWithPendingNotifications.add(task.id)
-    }
-  }
-
-  for (const [taskId, task] of tasks.entries()) {
-    if (TERMINAL_TASK_STATUSES.has(task.status)) {
-      if (tasksWithPendingNotifications.has(taskId)) continue
-
-      const completedAt = task.completedAt?.getTime()
-      if (!completedAt) continue
-
-      const age = now - completedAt
-      if (age <= TERMINAL_TASK_TTL_MS) continue
-
-      removeTaskToastTracking(taskId)
-      tasks.delete(taskId)
-      continue
-    }
-
-    const lastActivity = task.status === "running" && task.progress?.lastUpdate
-      ? task.progress.lastUpdate.getTime()
-      : undefined
-    const timestamp = task.status === "pending"
-      ? task.queuedAt?.getTime()
-      : (lastActivity ?? task.startedAt?.getTime())
-
-    if (!timestamp) continue
-
-    const age = now - timestamp
-    if (age <= effectiveTtl) continue
-
-    const ttlMinutes = Math.round(effectiveTtl / 60000)
-    const errorMessage = task.status === "pending"
-      ? `Task timed out while queued (${ttlMinutes} minutes)`
-      : `Task timed out after ${ttlMinutes} minutes of inactivity`
-
-    onTaskPruned(taskId, task, errorMessage)
-  }
-
-  for (const [sessionID, queued] of notifications.entries()) {
-    if (queued.length === 0) {
-      notifications.delete(sessionID)
-      continue
-    }
-
-    const validNotifications = queued.filter((task) => {
-      if (!task.startedAt) return false
-      const age = now - task.startedAt.getTime()
-      return age <= effectiveTtl
-    })
-
-    if (validNotifications.length === 0) {
-      notifications.delete(sessionID)
-    } else if (validNotifications.length !== queued.length) {
-      notifications.set(sessionID, validNotifications)
-    }
-  }
-}
-
-export type SessionStatusMap = Record<string, { type: string }>
-
-export async function checkAndInterruptStaleTasks(args: {
-  tasks: Iterable<BackgroundTask>
-  client: OpencodeClient
-  directory?: string
-  config: BackgroundTaskConfig | undefined
-  concurrencyManager: ConcurrencyManager
-  notifyParentSession: (task: BackgroundTask) => Promise<void>
-  sessionStatuses?: SessionStatusMap
-  onTaskInterrupted?: (task: BackgroundTask) => void
-}): Promise<void> {
-  const {
-    tasks,
-    client,
-    directory,
-    config,
-    concurrencyManager,
-    notifyParentSession,
-    sessionStatuses,
-    onTaskInterrupted = (task) => removeTaskToastTracking(task.id),
-  } = args
-  const staleTimeoutMs = config?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS
-  const sessionGoneTimeoutMs = config?.sessionGoneTimeoutMs ?? DEFAULT_SESSION_GONE_TIMEOUT_MS
-  const now = Date.now()
-  const abortPromises: Array<Promise<unknown>> = []
-
-  const messageStalenessMs = config?.messageStalenessTimeoutMs ?? DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS
-
-  for (const task of tasks) {
-    if (task.status !== "running") continue
-
-    const startedAt = task.startedAt
-    const sessionID = task.sessionID
-    if (!startedAt || !sessionID) continue
-
-    const sessionStatus = sessionStatuses?.[sessionID]?.type
-    const sessionIsRunning = sessionStatus !== undefined && isActiveSessionStatus(sessionStatus)
-    const sessionMissing = sessionStatuses !== undefined && sessionStatus === undefined
-    const runtime = now - startedAt.getTime()
-
-    if (sessionMissing) {
-      task.consecutiveMissedPolls = (task.consecutiveMissedPolls ?? 0) + 1
-    } else if (sessionStatuses !== undefined) {
-      task.consecutiveMissedPolls = 0
-    }
-
-    const sessionGone = sessionMissing && (task.consecutiveMissedPolls ?? 0) >= MIN_SESSION_GONE_POLLS
-
-    if (!task.progress?.lastUpdate) {
-      if (sessionIsRunning) continue
-      if (sessionMissing && !sessionGone) continue
-      const effectiveTimeout = sessionGone ? sessionGoneTimeoutMs : messageStalenessMs
-      if (runtime <= effectiveTimeout) continue
-
-      if (sessionGone && await verifySessionExists(client, sessionID, directory)) {
-        task.consecutiveMissedPolls = 0
-        continue
-      }
-
-      const staleMinutes = Math.round(runtime / 60000)
-      const reason = sessionGone ? "session gone from status registry" : "no activity"
-      task.status = "cancelled"
-      task.error = `Stale timeout (${reason} for ${staleMinutes}min since start). This is a FINAL cancellation - do NOT create a replacement task. If the timeout is too short, increase 'background_task.${sessionGone ? "sessionGoneTimeoutMs" : "staleTimeoutMs"}' in .opencode/${CONFIG_BASENAME}.json.`
-      task.completedAt = new Date()
-
-      if (task.concurrencyKey) {
-        concurrencyManager.release(task.concurrencyKey)
-        task.concurrencyKey = undefined
-      }
-
-      onTaskInterrupted(task)
-
-      abortPromises.push(abortWithTimeout(client, sessionID))
-      log(`[background-agent] Task ${task.id} interrupted: no progress since start`)
-
-      try {
-        await notifyParentSession(task)
-      } catch (err) {
-        log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err })
-      }
-      continue
-    }
-
-    if (sessionIsRunning) continue
-
-    if (runtime < MIN_RUNTIME_BEFORE_STALE_MS) continue
-
-    const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime()
-    const effectiveStaleTimeout = sessionGone ? sessionGoneTimeoutMs : staleTimeoutMs
-    if (timeSinceLastUpdate <= effectiveStaleTimeout) continue
-    if (task.status !== "running") continue
-
-    if (sessionGone && await verifySessionExists(client, sessionID, directory)) {
-      task.consecutiveMissedPolls = 0
-      continue
-    }
-
-    const staleMinutes = Math.round(timeSinceLastUpdate / 60000)
-    const reason = sessionGone ? "session gone from status registry" : "no activity"
-    task.status = "cancelled"
-    task.error = `Stale timeout (${reason} for ${staleMinutes}min). This is a FINAL cancellation - do NOT create a replacement task. If the timeout is too short, increase 'background_task.${sessionGone ? "sessionGoneTimeoutMs" : "staleTimeoutMs"}' in .opencode/${CONFIG_BASENAME}.json.`
-    task.completedAt = new Date()
-
-    if (task.concurrencyKey) {
-      concurrencyManager.release(task.concurrencyKey)
-      task.concurrencyKey = undefined
-    }
-
-    onTaskInterrupted(task)
-
-    abortPromises.push(abortWithTimeout(client, sessionID))
-    log(`[background-agent] Task ${task.id} interrupted: stale timeout`)
-
-    try {
-      await notifyParentSession(task)
-    } catch (err) {
-      log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err })
-    }
-  }
-
-  if (abortPromises.length > 0) {
-    await Promise.allSettled(abortPromises)
-  }
-}

package/src/features/background-agent/types.ts

@@ -1,100 +0,0 @@
-import type { FallbackEntry } from "../../shared/model-requirements"
-import type { DelegatedModelConfig } from "../../shared/model-resolution-types"
-import type { SessionPermissionRule } from "../../shared/question-denied-session-permission"
-
-export type BackgroundTaskStatus =
-  | "pending"
-  | "running"
-  | "completed"
-  | "error"
-  | "cancelled"
-  | "interrupt"
-
-export interface ToolCallWindow {
-  lastSignature: string
-  consecutiveCount: number
-  threshold: number
-}
-
-export interface TaskProgress {
-  toolCalls: number
-  lastTool?: string
-  toolCallWindow?: ToolCallWindow
-  countedToolPartIDs?: Set<string>
-  lastUpdate: Date
-  lastMessage?: string
-  lastMessageAt?: Date
-}
-
-export interface BackgroundTask {
-  id: string
-  sessionID?: string
-  rootSessionID?: string
-  parentSessionID: string
-  parentMessageID: string
-  description: string
-  prompt: string
-  agent: string
-  spawnDepth?: number
-  status: BackgroundTaskStatus
-  queuedAt?: Date
-  startedAt?: Date
-  completedAt?: Date
-  result?: string
-  error?: string
-  progress?: TaskProgress
-  parentModel?: { providerID: string; modelID: string }
-  model?: DelegatedModelConfig
-  /** Fallback chain for runtime retry on model errors */
-  fallbackChain?: FallbackEntry[]
-  /** Number of fallback retry attempts made */
-  attemptCount?: number
-  /** Active concurrency slot key */
-  concurrencyKey?: string
-  /** Persistent key for re-acquiring concurrency on resume */
-  concurrencyGroup?: string
-  /** Parent session's agent name for notification */
-  parentAgent?: string
-  /** Parent session's tool restrictions for notification prompts */
-  parentTools?: Record<string, boolean>
-  /** Marks if the task was launched from an unstable agent/category */
-  isUnstableAgent?: boolean
-  /** Category used for this task (e.g., 'quick', 'visual-engineering') */
-  category?: string
-
-  /** Last message count for stability detection */
-  lastMsgCount?: number
-  /** Number of consecutive polls with stable message count */
-  stablePolls?: number
-  /** Number of consecutive polls where session was missing from status map */
-  consecutiveMissedPolls?: number
-}
-
-export interface LaunchInput {
-  description: string
-  prompt: string
-  agent: string
-  parentSessionID: string
-  parentMessageID: string
-  parentModel?: { providerID: string; modelID: string }
-  parentAgent?: string
-  parentTools?: Record<string, boolean>
-  model?: DelegatedModelConfig
-  /** Fallback chain for runtime retry on model errors */
-  fallbackChain?: FallbackEntry[]
-  isUnstableAgent?: boolean
-  skills?: string[]
-  skillContent?: string
-  category?: string
-  sessionPermission?: SessionPermissionRule[]
-}
-
-export interface ResumeInput {
-  sessionId: string
-  prompt: string
-  parentSessionID: string
-  parentMessageID: string
-  parentModel?: { providerID: string; modelID: string }
-  parentAgent?: string
-  parentTools?: Record<string, boolean>
-}