@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/hooks/fast-apply/ollama-client.ts

@@ -1,53 +0,0 @@
-import type { FastApplyConfig } from "../../config"
-
-export async function queryOllama(args: {
-  originalContent: string
-  patch: string
-  config: FastApplyConfig
-}): Promise<string> {
-  const { originalContent, patch, config } = args
-  const url = `${config.ollama_url}/api/generate`
-  const timeout = config.timeout
-
-  const prompt = [
-    "You are a code editor. Given the original file content and a patch/diff description, produce the full updated file content.",
-    "Return ONLY the updated file content, nothing else. No explanations, no markdown fences.",
-    "",
-    "=== ORIGINAL FILE ===",
-    originalContent,
-    "",
-    "=== PATCH ===",
-    patch,
-    "",
-    "=== UPDATED FILE ===",
-  ].join("\n")
-
-  const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), timeout)
-
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: config.model,
-        prompt,
-        stream: false,
-      }),
-      signal: controller.signal,
-    })
-
-    if (!response.ok) {
-      throw new Error(`Ollama returned ${response.status}: ${response.statusText}`)
-    }
-
-    const data = await response.json() as { response?: string }
-    if (!data.response) {
-      throw new Error("Ollama returned empty response")
-    }
-
-    return data.response
-  } finally {
-    clearTimeout(timer)
-  }
-}

package/src/hooks/fast-apply/tool-execute-before-handler.ts

@@ -1,86 +0,0 @@
-import type { FastApplyConfig } from "../../config"
-import { queryOllama } from "./ollama-client"
-import { log } from "../../shared"
-import { existsSync, readFileSync } from "fs"
-
-export async function handleFastApplyToolExecuteBefore(args: {
-  input: { tool: string; sessionID: string; callID: string }
-  output: { args: Record<string, unknown> }
-  config: FastApplyConfig
-}): Promise<void> {
-  const { input, output, config } = args
-  const normalizedTool = input.tool.toLowerCase()
-
-  if (normalizedTool !== "apply_patch" && normalizedTool !== "applypatch") {
-    return
-  }
-
-  const patchArgs = output.args as { filePath?: string; path?: string; file_path?: string; patch?: string }
-  const filePath = patchArgs.filePath ?? patchArgs.path ?? patchArgs.file_path
-  const patch = patchArgs.patch
-
-  if (!filePath || !patch) {
-    log("[fast-apply] Skipping: missing filePath or patch", {
-      sessionID: input.sessionID,
-      callID: input.callID,
-      hasFilePath: !!filePath,
-      hasPatch: !!patch,
-    })
-    return
-  }
-
-  if (!existsSync(filePath)) {
-    log("[fast-apply] Skipping: file does not exist (new file)", {
-      sessionID: input.sessionID,
-      callID: input.callID,
-      filePath,
-    })
-    return
-  }
-
-  let originalContent: string
-  try {
-    originalContent = readFileSync(filePath, "utf-8")
-  } catch (err) {
-    log("[fast-apply] Failed to read file, falling back to default", {
-      sessionID: input.sessionID,
-      callID: input.callID,
-      filePath,
-      error: String(err),
-    })
-    return
-  }
-
-  try {
-    log("[fast-apply] Sending to Ollama", {
-      sessionID: input.sessionID,
-      callID: input.callID,
-      filePath,
-      model: config.model,
-    })
-
-    const newContent = await queryOllama({
-      originalContent,
-      patch,
-      config,
-    })
-
-    output.args.content = newContent
-    output.args.patch = undefined
-
-    log("[fast-apply] Patch replaced with Ollama result", {
-      sessionID: input.sessionID,
-      callID: input.callID,
-      filePath,
-      originalLength: originalContent.length,
-      newLength: newContent.length,
-    })
-  } catch (err) {
-    log("[fast-apply] Ollama failed, falling back to default apply_patch", {
-      sessionID: input.sessionID,
-      callID: input.callID,
-      filePath,
-      error: String(err),
-    })
-  }
-}

package/src/hooks/guard/AGENTS.md

@@ -1,64 +0,0 @@
-# src/hooks/guard/ — Master Boulder Orchestrator
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-17 files (~1976 LOC). The `guardHook` — Continuation Tier hook that monitors session.idle events and forces continuation when boulder sessions (ralph-loop, task-spawned agents) have incomplete work. Also enforces write/edit policies for subagent sessions.
-
-## WHAT ATLAS DOES
-
-Guard is the "keeper of sessions" — it tracks every session and decides:
-1. Should this session be forced to continue? (if boulder session with incomplete todos)
-2. Should write/edit be blocked? (policy enforcement for certain session types)
-3. Should a verification reminder be injected? (after tool execution)
-
-## DECISION GATE (session.idle)
-
-```
-session.idle event
-  → Is this a boulder/ralph/guard session? (session-last-agent.ts)
-  → Is there an abort signal? (is-abort-error.ts)
-  → Failure count < max? (state.promptFailureCount)
-  → No running background tasks?
-  → Agent matches expected? (recent-model-resolver.ts)
-  → Plan complete? (todo status)
-  → Cooldown passed? (5s between injections)
-  → Inject continuation prompt (boulder-continuation-injector.ts)
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `guard-hook.ts` | `createGuardHook()` — composes event + tool handlers, maintains session state |
-| `event-handler.ts` | `createGuardEventHandler()` — decision gate for session.idle events |
-| `boulder-continuation-injector.ts` | Build + inject continuation prompt into session |
-| `system-reminder-templates.ts` | Templates for continuation reminder messages |
-| `tool-execute-before.ts` | Block write/edit based on session policy |
-| `tool-execute-after.ts` | Inject verification reminders post-tool |
-| `write-edit-tool-policy.ts` | Policy: which sessions can write/edit? |
-| `verification-reminders.ts` | Reminder content for verifying work |
-| `session-last-agent.ts` | Determine which agent owns the session |
-| `recent-model-resolver.ts` | Resolve model used in recent messages |
-| `subagent-session-id.ts` | Detect if session is a subagent session |
-| `bob-path.ts` | Resolve `.bob/` directory path |
-| `is-abort-error.ts` | Detect abort signals in session output |
-| `types.ts` | `SessionState`, `GuardHookOptions`, `GuardContext` |
-
-## STATE PER SESSION
-
-```typescript
-interface SessionState {
-  promptFailureCount: number  // Increments on failed continuations
-  // Resets on successful continuation
-}
-```
-
-Max consecutive failures before 5min pause: 5 (exponential backoff in todo-continuation-enforcer).
-
-## RELATIONSHIP TO OTHER HOOKS
-
-- **guardHook** (Continuation Tier): Master orchestrator, handles boulder sessions
-- **todoContinuationEnforcer** (Continuation Tier): "Boulder" mechanism for main Bob sessions
-- Both inject into session.idle but serve different session types

package/src/hooks/guard/background-launch-session-tracking.ts

@@ -1,97 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { appendSessionId, type BoulderState, upsertTaskSessionState } from "../../features/boulder-state"
-import { log } from "../../shared/logger"
-import { HOOK_NAME } from "./hook-name"
-import { extractSessionIdFromOutput, validateSubagentSessionId } from "./subagent-session-id"
-import { resolveTaskContext } from "./task-context"
-import type { PendingTaskRef, ToolExecuteAfterInput, ToolExecuteAfterOutput } from "./types"
-
-export async function syncBackgroundLaunchSessionTracking(input: {
-  ctx: PluginInput
-  boulderState: BoulderState | null
-  toolInput: ToolExecuteAfterInput
-  toolOutput: ToolExecuteAfterOutput
-  pendingTaskRef: PendingTaskRef | undefined
-  metadataSessionId?: string
-}): Promise<void> {
-  const { ctx, boulderState, toolInput, toolOutput, pendingTaskRef, metadataSessionId } = input
-  if (!boulderState) {
-    return
-  }
-
-  const extractedSessionId = metadataSessionId ?? extractSessionIdFromOutput(toolOutput.output)
-  const lineageSessionIDs = boulderState.session_ids
-  const subagentSessionId = await validateSubagentSessionId({
-    client: ctx.client,
-    sessionID: extractedSessionId,
-    lineageSessionIDs,
-  })
-
-  const trackedSessionId = subagentSessionId ?? await resolveFallbackTrackedSessionId({
-    ctx,
-    extractedSessionId,
-    lineageSessionIDs,
-  })
-  if (!trackedSessionId) {
-    return
-  }
-
-  appendSessionId(ctx.directory, trackedSessionId, "appended")
-
-  const { currentTask, shouldSkipTaskSessionUpdate } = resolveTaskContext(
-    pendingTaskRef,
-    boulderState.active_plan,
-  )
-
-  if (currentTask && !shouldSkipTaskSessionUpdate) {
-    upsertTaskSessionState(ctx.directory, {
-      taskKey: currentTask.key,
-      taskLabel: currentTask.label,
-      taskTitle: currentTask.title,
-      sessionId: trackedSessionId,
-      agent: typeof toolOutput.metadata?.agent === "string" ? toolOutput.metadata.agent : undefined,
-      category: typeof toolOutput.metadata?.category === "string" ? toolOutput.metadata.category : undefined,
-    })
-  }
-
-  log(`[${HOOK_NAME}] Background launch session tracked`, {
-    sessionID: toolInput.sessionID,
-    subagentSessionId: trackedSessionId,
-    taskKey: currentTask?.key,
-  })
-}
-
-async function resolveFallbackTrackedSessionId(input: {
-  ctx: PluginInput
-  extractedSessionId?: string
-  lineageSessionIDs: string[]
-}): Promise<string | undefined> {
-  if (!input.extractedSessionId) {
-    return undefined
-  }
-
-  try {
-    const session = await input.ctx.client.session.get({ path: { id: input.extractedSessionId } })
-    const parentSessionId = session.data?.parentID
-    if (typeof parentSessionId === "string" && input.lineageSessionIDs.includes(parentSessionId)) {
-      return input.extractedSessionId
-    }
-    return undefined
-  } catch {
-    return undefined
-  }
-}
-
-async function resolveSessionOrigin(
-  ctx: PluginInput,
-  sessionID: string,
-): Promise<"direct" | "appended"> {
-  try {
-    const session = await ctx.client.session.get({ path: { id: sessionID } })
-    return typeof session.data?.parentID === "string" && session.data.parentID.length > 0
-      ? "appended"
-      : "direct"
-  } catch {
-    return "appended"
-  }
-}

package/src/hooks/guard/bob-path.ts

@@ -1,8 +0,0 @@
-/**
- * Cross-platform check if a path is inside .bob/ directory.
- * Handles both forward slashes (Unix) and backslashes (Windows).
- * Uses path segment matching (not substring) to avoid false positives like "not-bob/file.txt"
- */
-export function isBobPath(filePath: string): boolean {
-  return /\.bob[/\\]/.test(filePath)
-}

package/src/hooks/guard/boulder-continuation-injector.ts

@@ -1,109 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { BackgroundManager } from "../../features/background-agent"
-import {
-  isAgentRegistered,
-  resolveRegisteredAgentName,
-} from "../../features/claude-code-session-state"
-import { log } from "../../shared/logger"
-import { createInternalAgentTextPart, resolveInheritedPromptTools } from "../../shared"
-import { HOOK_NAME } from "./hook-name"
-import { BOULDER_CONTINUATION_PROMPT } from "./system-reminder-templates"
-import { resolveRecentPromptContextForSession } from "./recent-model-resolver"
-import type { SessionState } from "./types"
-
-export type BoulderContinuationResult = "injected" | "skipped_background_tasks" | "skipped_agent_unavailable" | "failed"
-
-export async function injectBoulderContinuation(input: {
-  ctx: PluginInput
-  sessionID: string
-  planName: string
-  remaining: number
-  total: number
-  agent?: string
-  worktreePath?: string
-  preferredTaskSessionId?: string
-  preferredTaskTitle?: string
-  backgroundManager?: BackgroundManager
-  sessionState: SessionState
-}): Promise<BoulderContinuationResult> {
-  const {
-    ctx,
-    sessionID,
-    planName,
-    remaining,
-    total,
-    agent,
-    worktreePath,
-    preferredTaskSessionId,
-    preferredTaskTitle,
-    backgroundManager,
-    sessionState,
-  } = input
-
-  const hasRunningBgTasks = backgroundManager
-    ? backgroundManager.getTasksByParentSession(sessionID).some((t: { status: string }) => t.status === "running")
-    : false
-
-  if (hasRunningBgTasks) {
-    log(`[${HOOK_NAME}] Skipped injection: background tasks running`, { sessionID })
-    return "skipped_background_tasks"
-  }
-
-  const worktreeContext = worktreePath ? `\n\n[Worktree: ${worktreePath}]` : ""
-  const preferredSessionContext = preferredTaskSessionId
-    ? `\n\n[Preferred reuse session for current top-level plan task${preferredTaskTitle ? `: ${preferredTaskTitle}` : ""}: ${preferredTaskSessionId}]`
-    : ""
-	const prompt =
-		BOULDER_CONTINUATION_PROMPT.replace(/{PLAN_NAME}/g, planName) +
-		`\n\n[Status: ${total - remaining}/${total} completed, ${remaining} remaining]` +
-		preferredSessionContext +
-		worktreeContext
-	const continuationAgent = resolveRegisteredAgentName(
-		agent ?? (isAgentRegistered("guard") ? "guard" : undefined),
-	)
-
-	if (!continuationAgent || !isAgentRegistered(continuationAgent)) {
-		log(`[${HOOK_NAME}] Skipped injection: continuation agent unavailable`, {
-			sessionID,
-			agent: continuationAgent ?? agent ?? "unknown",
-		})
-		return "skipped_agent_unavailable"
-	}
-
-	try {
-		log(`[${HOOK_NAME}] Injecting boulder continuation`, { sessionID, planName, remaining })
-
-    const promptContext = await resolveRecentPromptContextForSession(ctx, sessionID)
-    const inheritedTools = resolveInheritedPromptTools(sessionID, promptContext.tools)
-
-    const launchModel = promptContext.model
-      ? { providerID: promptContext.model.providerID, modelID: promptContext.model.modelID }
-      : undefined
-    const launchVariant = promptContext.model?.variant
-
-    await ctx.client.session.promptAsync({
-      path: { id: sessionID },
-      body: {
-        agent: continuationAgent,
-        ...(launchModel ? { model: launchModel } : {}),
-        ...(launchVariant ? { variant: launchVariant } : {}),
-        ...(inheritedTools ? { tools: inheritedTools } : {}),
-        parts: [createInternalAgentTextPart(prompt)],
-      },
-      query: { directory: ctx.directory },
-    })
-
-    sessionState.promptFailureCount = 0
-    log(`[${HOOK_NAME}] Boulder continuation injected`, { sessionID })
-    return "injected"
-  } catch (err) {
-    sessionState.promptFailureCount += 1
-    sessionState.lastFailureAt = Date.now()
-    log(`[${HOOK_NAME}] Boulder continuation failed`, {
-      sessionID,
-      error: String(err),
-      promptFailureCount: sessionState.promptFailureCount,
-    })
-    return "failed"
-  }
-}

package/src/hooks/guard/boulder-session-lineage.ts

@@ -1,44 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-import { HOOK_NAME } from "./hook-name"
-
-export async function isSessionInBoulderLineage(input: {
-  client: PluginInput["client"]
-  sessionID: string
-  boulderSessionIDs: string[]
-}): Promise<boolean> {
-  const visitedSessionIDs = new Set<string>()
-  let currentSessionID = input.sessionID
-
-  while (!visitedSessionIDs.has(currentSessionID)) {
-    visitedSessionIDs.add(currentSessionID)
-
-    const sessionResult = await input.client.session
-      .get({ path: { id: currentSessionID } })
-      .catch((error: unknown) => {
-        log(`[${HOOK_NAME}] Failed to resolve session lineage`, {
-          sessionID: input.sessionID,
-          currentSessionID,
-          error,
-        })
-        return null
-      })
-
-    if (!sessionResult || sessionResult.error) {
-      return false
-    }
-
-    const parentSessionID = sessionResult.data?.parentID
-    if (!parentSessionID) {
-      return false
-    }
-
-    if (input.boulderSessionIDs.includes(parentSessionID)) {
-      return true
-    }
-
-    currentSessionID = parentSessionID
-  }
-
-  return false
-}

package/src/hooks/guard/event-handler.ts

@@ -1,104 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-import { HOOK_NAME } from "./hook-name"
-import { isAbortError } from "./is-abort-error"
-import { handleGuardSessionIdle } from "./idle-event"
-import type { GuardHookOptions, SessionState } from "./types"
-
-export function createGuardEventHandler(input: {
-  ctx: PluginInput
-  options?: GuardHookOptions
-  sessions: Map<string, SessionState>
-  getState: (sessionID: string) => SessionState
-}): (arg: { event: { type: string; properties?: unknown } }) => Promise<void> {
-  const { ctx, options, sessions, getState } = input
-
-  return async ({ event }): Promise<void> => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.error") {
-      const sessionID = props?.sessionID as string | undefined
-      if (!sessionID) return
-
-      const state = getState(sessionID)
-      const isAbort = isAbortError(props?.error)
-      state.lastEventWasAbortError = isAbort
-
-      log(`[${HOOK_NAME}] session.error`, { sessionID, isAbort })
-      return
-    }
-
-    if (event.type === "session.idle") {
-      const sessionID = props?.sessionID as string | undefined
-      if (!sessionID) return
-      await handleGuardSessionIdle({ ctx, options, getState, sessionID })
-      return
-    }
-
-    if (event.type === "message.updated") {
-      const info = props?.info as Record<string, unknown> | undefined
-      const sessionID = info?.sessionID as string | undefined
-      const role = info?.role as string | undefined
-      if (!sessionID) return
-
-      const state = sessions.get(sessionID)
-      if (state) {
-        state.lastEventWasAbortError = false
-        if (role === "user") {
-          state.waitingForFinalWaveApproval = false
-        }
-      }
-      return
-    }
-
-    if (event.type === "message.part.updated") {
-      const info = props?.info as Record<string, unknown> | undefined
-      const sessionID = info?.sessionID as string | undefined
-      const role = info?.role as string | undefined
-
-      if (sessionID && role === "assistant") {
-        const state = sessions.get(sessionID)
-        if (state) {
-          state.lastEventWasAbortError = false
-        }
-      }
-      return
-    }
-
-    if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
-      const sessionID = props?.sessionID as string | undefined
-      if (sessionID) {
-        const state = sessions.get(sessionID)
-        if (state) {
-          state.lastEventWasAbortError = false
-        }
-      }
-      return
-    }
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        const deletedState = sessions.get(sessionInfo.id)
-        if (deletedState?.pendingRetryTimer) {
-          clearTimeout(deletedState.pendingRetryTimer)
-        }
-        sessions.delete(sessionInfo.id)
-        log(`[${HOOK_NAME}] Session deleted: cleaned up`, { sessionID: sessionInfo.id })
-      }
-      return
-    }
-
-    if (event.type === "session.compacted") {
-      const sessionID = (props?.sessionID ?? (props?.info as { id?: string } | undefined)?.id) as string | undefined
-      if (sessionID) {
-        const compactedState = sessions.get(sessionID)
-        if (compactedState?.pendingRetryTimer) {
-          clearTimeout(compactedState.pendingRetryTimer)
-        }
-        sessions.delete(sessionID)
-        log(`[${HOOK_NAME}] Session compacted: cleaned up`, { sessionID })
-      }
-    }
-  }
-}

package/src/hooks/guard/final-wave-approval-gate.ts

@@ -1,47 +0,0 @@
-import type { SessionState } from "./types"
-import { readFinalWavePlanState } from "./final-wave-plan-state"
-
-const APPROVE_VERDICT_PATTERN = /\bVERDICT:\s*APPROVE\b/i
-
-function clearFinalWaveApprovalTracking(sessionState: SessionState): void {
-  sessionState.pendingFinalWaveTaskCount = undefined
-  sessionState.approvedFinalWaveTaskCount = undefined
-}
-
-export function shouldPauseForFinalWaveApproval(input: {
-  planPath: string
-  taskOutput: string
-  sessionState: SessionState
-}): boolean {
-  const planState = readFinalWavePlanState(input.planPath)
-  if (!planState) {
-    return false
-  }
-
-  if (planState.pendingImplementationTaskCount > 0 || planState.pendingFinalWaveTaskCount === 0) {
-    clearFinalWaveApprovalTracking(input.sessionState)
-    return false
-  }
-
-  if (!APPROVE_VERDICT_PATTERN.test(input.taskOutput)) {
-    return false
-  }
-
-  if (planState.pendingFinalWaveTaskCount === 1) {
-    clearFinalWaveApprovalTracking(input.sessionState)
-    return true
-  }
-
-  if (input.sessionState.pendingFinalWaveTaskCount !== planState.pendingFinalWaveTaskCount) {
-    input.sessionState.pendingFinalWaveTaskCount = planState.pendingFinalWaveTaskCount
-    input.sessionState.approvedFinalWaveTaskCount = 0
-  }
-
-  input.sessionState.approvedFinalWaveTaskCount = (input.sessionState.approvedFinalWaveTaskCount ?? 0) + 1
-  const shouldPause = input.sessionState.approvedFinalWaveTaskCount >= planState.pendingFinalWaveTaskCount
-  if (shouldPause) {
-    clearFinalWaveApprovalTracking(input.sessionState)
-  }
-
-  return shouldPause
-}

package/src/hooks/guard/final-wave-plan-state.ts

@@ -1,60 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-
-const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i
-const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i
-const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/
-const UNCHECKED_CHECKBOX_PATTERN = /^\s*[-*]\s*\[\s*\]\s*(.+)$/
-const TODO_TASK_PATTERN = /^\d+\./
-const FINAL_WAVE_TASK_PATTERN = /^F\d+\./i
-
-type PlanSection = "todo" | "final-wave" | "other"
-
-export type FinalWavePlanState = {
-  pendingImplementationTaskCount: number
-  pendingFinalWaveTaskCount: number
-}
-
-export function readFinalWavePlanState(planPath: string): FinalWavePlanState | null {
-  if (!existsSync(planPath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(planPath, "utf-8")
-    const lines = content.split(/\r?\n/)
-    let section: PlanSection = "other"
-    let pendingImplementationTaskCount = 0
-    let pendingFinalWaveTaskCount = 0
-
-    for (const line of lines) {
-      if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
-        section = TODO_HEADING_PATTERN.test(line)
-          ? "todo"
-          : FINAL_VERIFICATION_HEADING_PATTERN.test(line)
-            ? "final-wave"
-            : "other"
-      }
-
-      const uncheckedTaskMatch = line.match(UNCHECKED_CHECKBOX_PATTERN)
-      if (!uncheckedTaskMatch) {
-        continue
-      }
-
-      const taskLabel = uncheckedTaskMatch[1].trim()
-      if (section === "todo" && TODO_TASK_PATTERN.test(taskLabel)) {
-        pendingImplementationTaskCount += 1
-      }
-
-      if (section === "final-wave" && FINAL_WAVE_TASK_PATTERN.test(taskLabel)) {
-        pendingFinalWaveTaskCount += 1
-      }
-    }
-
-    return {
-      pendingImplementationTaskCount,
-      pendingFinalWaveTaskCount,
-    }
-  } catch {
-    return null
-  }
-}