@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/features/tmux-subagent/tracked-session-state.ts

@@ -1,29 +0,0 @@
-import type { TrackedSession } from "./types"
-
-export function createTrackedSession(params: {
-  sessionId: string
-  paneId: string
-  description: string
-  now?: Date
-}): TrackedSession {
-  const now = params.now ?? new Date()
-
-  return {
-    sessionId: params.sessionId,
-    paneId: params.paneId,
-    description: params.description,
-    createdAt: now,
-    lastSeenAt: now,
-    closePending: false,
-    closeRetryCount: 0,
-    activityVersion: 0,
-  }
-}
-
-export function markTrackedSessionClosePending(tracked: TrackedSession): TrackedSession {
-  return {
-    ...tracked,
-    closePending: true,
-    closeRetryCount: tracked.closePending ? tracked.closeRetryCount + 1 : tracked.closeRetryCount,
-  }
-}

package/src/features/tmux-subagent/types.ts

@@ -1,54 +0,0 @@
-export interface TrackedSession {
-  sessionId: string
-  paneId: string
-  description: string
-  createdAt: Date
-  lastSeenAt: Date
-  closePending: boolean
-  closeRetryCount: number
-  // Stability detection fields (prevents premature closure)
-  lastMessageCount?: number
-  stableIdlePolls?: number
-  activityVersion?: number
-  observedIdleActivityVersion?: number
-}
-
-export const MIN_PANE_WIDTH = 52
-export const MIN_PANE_HEIGHT = 11
-
-export interface TmuxPaneInfo {
-  paneId: string
-  width: number
-  height: number
-  left: number
-  top: number
-  title: string
-  isActive: boolean
-}
-
-export interface WindowState {
-  windowWidth: number
-  windowHeight: number
-  mainPane: TmuxPaneInfo | null
-  agentPanes: TmuxPaneInfo[]
-}
-
-export type SplitDirection = "-h" | "-v"
-
-export type PaneAction =
-  | { type: "close"; paneId: string; sessionId: string }
-  | { type: "spawn"; sessionId: string; description: string; targetPaneId: string; splitDirection: SplitDirection }
-  | { type: "replace"; paneId: string; oldSessionId: string; newSessionId: string; description: string }
-
-export interface SpawnDecision {
-  canSpawn: boolean
-  actions: PaneAction[]
-  reason?: string
-}
-
-export interface CapacityConfig {
-  layout?: string
-  mainPaneSize?: number
-  mainPaneMinWidth: number
-  agentPaneWidth: number
-}

package/src/features/tool-metadata-store/index.ts

@@ -1,7 +0,0 @@
-export {
-  clearPendingStore,
-  consumeToolMetadata,
-  getPendingStoreSize,
-  storeToolMetadata,
-} from "./store"
-export type { PendingToolMetadata } from "./store"

package/src/features/tool-metadata-store/store.ts

@@ -1,84 +0,0 @@
-/**
- * Pending tool metadata store.
- *
- * OpenCode's `fromPlugin()` wrapper always replaces the metadata returned by
- * plugin tools with `{ truncated, outputPath }`, discarding any sessionId,
- * title, or custom metadata set during `execute()`.
- *
- * This store captures metadata written via `ctx.metadata()` inside execute(),
- * then the `tool.execute.after` hook consumes it and merges it back into the
- * result *before* the processor writes the final part to the session store.
- *
- * Flow:
- *   execute() → storeToolMetadata(sessionID, callID, data)
- *   fromPlugin() → overwrites metadata with { truncated }
- *   tool.execute.after → consumeToolMetadata(sessionID, callID) → merges back
- *   processor → Session.updatePart(status:"completed", metadata: result.metadata)
- */
-
-export interface PendingToolMetadata {
-  title?: string
-  metadata?: Record<string, unknown>
-}
-
-const pendingStore = new Map<string, PendingToolMetadata & { storedAt: number }>()
-
-const STALE_TIMEOUT_MS = 15 * 60 * 1000
-
-function makeKey(sessionID: string, callID: string): string {
-  return `${sessionID}:${callID}`
-}
-
-function cleanupStaleEntries(): void {
-  const now = Date.now()
-  for (const [key, entry] of pendingStore) {
-    if (now - entry.storedAt > STALE_TIMEOUT_MS) {
-      pendingStore.delete(key)
-    }
-  }
-}
-
-/**
- * Store metadata to be restored after fromPlugin() overwrites it.
- * Called from tool execute() functions alongside ctx.metadata().
- */
-export function storeToolMetadata(
-  sessionID: string,
-  callID: string,
-  data: PendingToolMetadata
-): void {
-  cleanupStaleEntries()
-  pendingStore.set(makeKey(sessionID, callID), { ...data, storedAt: Date.now() })
-}
-
-/**
- * Consume stored metadata (one-time read, removes from store).
- * Called from tool.execute.after hook.
- */
-export function consumeToolMetadata(
-  sessionID: string,
-  callID: string
-): PendingToolMetadata | undefined {
-  const key = makeKey(sessionID, callID)
-  const stored = pendingStore.get(key)
-  if (stored) {
-    pendingStore.delete(key)
-    const { storedAt: _, ...data } = stored
-    return data
-  }
-  return undefined
-}
-
-/**
- * Get current store size (for testing/debugging).
- */
-export function getPendingStoreSize(): number {
-  return pendingStore.size
-}
-
-/**
- * Clear all pending metadata (for testing).
- */
-export function clearPendingStore(): void {
-  pendingStore.clear()
-}

package/src/hooks/agent-usage-reminder/constants.ts

@@ -1,52 +0,0 @@
-import { join } from "node:path";
-import { OPENCODE_STORAGE } from "../../shared";
-export const AGENT_USAGE_REMINDER_STORAGE = join(
-  OPENCODE_STORAGE,
-  "agent-usage-reminder",
-);
-
-// All tool names normalized to lowercase for case-insensitive matching
-export const TARGET_TOOLS = new Set([
-  "grep",
-  "safe_grep",
-  "glob",
-  "safe_glob",
-  "webfetch",
-  "context7_resolve-library-id",
-  "context7_query-docs",
-  "websearch_web_search_exa",
-  "context7_get-library-docs",
-  "grep_app_searchgithub",
-]);
-
-export const AGENT_TOOLS = new Set([
-  "task",
-  "call_omo_agent",
-  "task",
-]);
-
-export const REMINDER_MESSAGE = `
-[Agent Usage Reminder]
-
-You called a search/fetch tool directly without leveraging specialized agents.
-
-RECOMMENDED: Use task with researcher agents for better results:
-
-\`\`\`
-// Parallel exploration - fire multiple agents simultaneously
-task(subagent_type="researcher", load_skills=[], prompt="Find all files matching pattern X")
-task(subagent_type="researcher", load_skills=[], prompt="Search for implementation of Y")
-task(subagent_type="researcher", load_skills=[], prompt="Lookup documentation for Z")
-
-// Then continue your work while they run in background
-// System will notify you when each completes
-\`\`\`
-
-WHY:
-- Agents can perform deeper, more thorough searches
-- Background tasks run in parallel, saving time
-- Specialized agents have domain expertise
-- Reduces context window usage in main session
-
-ALWAYS prefer: Multiple parallel task calls > Direct tool calls
-`;

package/src/hooks/agent-usage-reminder/hook.ts

@@ -1,134 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import {
-  loadAgentUsageState,
-  saveAgentUsageState,
-  clearAgentUsageState,
-} from "./storage";
-import { TARGET_TOOLS, AGENT_TOOLS, REMINDER_MESSAGE } from "./constants";
-import type { AgentUsageState } from "./types";
-import { getSessionAgent } from "../../features/claude-code-session-state";
-import { getAgentConfigKey } from "../../shared/agent-display-names";
-
-interface ToolExecuteInput {
-  tool: string;
-  sessionID: string;
-  callID: string;
-}
-
-interface ToolExecuteOutput {
-  title: string;
-  output: string;
-  metadata: unknown;
-}
-
-interface EventInput {
-  event: {
-    type: string;
-    properties?: unknown;
-  };
-}
-
-/**
- * Only orchestrator agents should receive usage reminders.
- * Subagents (explore, librarian, logician, etc.) are the targets of delegation,
- * so reminding them to delegate to themselves is counterproductive.
- */
-const ORCHESTRATOR_AGENTS = new Set([
-  "bob",
-  "sub",
-  "guard",
-  "coder",
-  "strategist",
-]);
-
-function isOrchestratorAgent(agentName: string): boolean {
-  return ORCHESTRATOR_AGENTS.has(getAgentConfigKey(agentName));
-}
-
-export function createAgentUsageReminderHook(_ctx: PluginInput) {
-  const sessionStates = new Map<string, AgentUsageState>();
-
-  function getOrCreateState(sessionID: string): AgentUsageState {
-    if (!sessionStates.has(sessionID)) {
-      const persisted = loadAgentUsageState(sessionID);
-      const state: AgentUsageState = persisted ?? {
-        sessionID,
-        agentUsed: false,
-        reminderCount: 0,
-        updatedAt: Date.now(),
-      };
-      sessionStates.set(sessionID, state);
-    }
-    return sessionStates.get(sessionID)!;
-  }
-
-  function markAgentUsed(sessionID: string): void {
-    const state = getOrCreateState(sessionID);
-    state.agentUsed = true;
-    state.updatedAt = Date.now();
-    saveAgentUsageState(state);
-  }
-
-  function resetState(sessionID: string): void {
-    sessionStates.delete(sessionID);
-    clearAgentUsageState(sessionID);
-  }
-
-  const toolExecuteAfter = async (
-    input: ToolExecuteInput,
-    output: ToolExecuteOutput,
-  ) => {
-    const { tool, sessionID } = input;
-
-    const agent = getSessionAgent(sessionID);
-    if (agent && !isOrchestratorAgent(agent)) {
-      return;
-    }
-
-    const toolLower = tool.toLowerCase();
-
-    if (AGENT_TOOLS.has(toolLower)) {
-      markAgentUsed(sessionID);
-      return;
-    }
-
-    if (!TARGET_TOOLS.has(toolLower)) {
-      return;
-    }
-
-    const state = getOrCreateState(sessionID);
-
-    if (state.agentUsed) {
-      return;
-    }
-
-    output.output += REMINDER_MESSAGE;
-    state.reminderCount++;
-    state.updatedAt = Date.now();
-    saveAgentUsageState(state);
-  };
-
-  const eventHandler = async ({ event }: EventInput) => {
-    const props = event.properties as Record<string, unknown> | undefined;
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined;
-      if (sessionInfo?.id) {
-        resetState(sessionInfo.id);
-      }
-    }
-
-    if (event.type === "session.compacted") {
-      const sessionID = (props?.sessionID ??
-        (props?.info as { id?: string } | undefined)?.id) as string | undefined;
-      if (sessionID) {
-        resetState(sessionID);
-      }
-    }
-  };
-
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler,
-  };
-}

package/src/hooks/agent-usage-reminder/index.ts

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

package/src/hooks/agent-usage-reminder/storage.ts

@@ -1,42 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-} from "node:fs";
-import { join } from "node:path";
-import { AGENT_USAGE_REMINDER_STORAGE } from "./constants";
-import type { AgentUsageState } from "./types";
-
-function getStoragePath(sessionID: string): string {
-  return join(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
-}
-
-export function loadAgentUsageState(sessionID: string): AgentUsageState | null {
-  const filePath = getStoragePath(sessionID);
-  if (!existsSync(filePath)) return null;
-
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    return JSON.parse(content) as AgentUsageState;
-  } catch {
-    return null;
-  }
-}
-
-export function saveAgentUsageState(state: AgentUsageState): void {
-  if (!existsSync(AGENT_USAGE_REMINDER_STORAGE)) {
-    mkdirSync(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
-  }
-
-  const filePath = getStoragePath(state.sessionID);
-  writeFileSync(filePath, JSON.stringify(state, null, 2));
-}
-
-export function clearAgentUsageState(sessionID: string): void {
-  const filePath = getStoragePath(sessionID);
-  if (existsSync(filePath)) {
-    unlinkSync(filePath);
-  }
-}

package/src/hooks/agent-usage-reminder/types.ts

@@ -1,6 +0,0 @@
-export interface AgentUsageState {
-  sessionID: string;
-  agentUsed: boolean;
-  reminderCount: number;
-  updatedAt: number;
-}

package/src/hooks/anthropic-context-window-limit-recovery/AGENTS.md

@@ -1,49 +0,0 @@
-# src/hooks/anthropic-context-window-limit-recovery/ — Multi-Strategy Context Recovery
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-31 files (~2232 LOC). Most complex hook. Recovers from context window limit errors via multiple strategies applied in sequence.
-
-## RECOVERY STRATEGIES (in priority order)
-
-| Strategy | File | Mechanism |
-|----------|------|-----------|
-| **Empty content recovery** | `empty-content-recovery.ts` | Handle empty/null content blocks in messages |
-| **Deduplication** | `deduplication-recovery.ts` | Remove duplicate tool results from context |
-| **Target-token truncation** | `target-token-truncation.ts` | Truncate largest tool outputs to fit target ratio |
-| **Aggressive truncation** | `aggressive-truncation-strategy.ts` | Last-resort truncation with minimal output preservation |
-| **Summarize retry** | `summarize-retry-strategy.ts` | Compaction + summarization then retry |
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `recovery-hook.ts` | Main hook entry — `session.error` handler, strategy orchestration |
-| `executor.ts` | Execute recovery strategies in sequence |
-| `parser.ts` | Parse Anthropic token limit error messages |
-| `state.ts` | `AutoCompactState` — per-session retry/truncation tracking |
-| `types.ts` | `ParsedTokenLimitError`, `RetryState`, `TruncateState`, config constants |
-| `storage.ts` | Persist tool results for later truncation |
-| `tool-result-storage.ts` | Store/retrieve individual tool call results |
-| `message-builder.ts` | Build retry messages after recovery |
-
-## RETRY CONFIG
-
-- Max attempts: 2
-- Initial delay: 2s, backoff ×2, max 30s
-- Max truncation attempts: 20
-- Target token ratio: 0.5 (truncate to 50% of limit)
-- Chars per token estimate: 4
-
-## PRUNING SYSTEM
-
-`pruning-*.ts` files handle intelligent output pruning:
-- `pruning-deduplication.ts` — Remove duplicate content across tool results
-- `pruning-tool-output-truncation.ts` — Truncate oversized tool outputs
-- `pruning-types.ts` — Pruning-specific type definitions
-
-## SDK VARIANTS
-
-`empty-content-recovery-sdk.ts` and `tool-result-storage-sdk.ts` provide SDK-based implementations for OpenCode client interactions.

package/src/hooks/anthropic-context-window-limit-recovery/aggressive-truncation-strategy.ts

@@ -1,87 +0,0 @@
-import type { AutoCompactState } from "./types"
-import { TRUNCATE_CONFIG } from "./types"
-import { truncateUntilTargetTokens } from "./storage"
-import type { Client } from "./client"
-import { clearSessionState } from "./state"
-import { formatBytes } from "./message-builder"
-import { log } from "../../shared/logger"
-import { resolveInheritedPromptTools } from "../../shared"
-
-export async function runAggressiveTruncationStrategy(params: {
-  sessionID: string
-  autoCompactState: AutoCompactState
-  client: Client
-  directory: string
-  truncateAttempt: number
-  currentTokens: number
-  maxTokens: number
-}): Promise<{ handled: boolean; nextTruncateAttempt: number }> {
-  if (params.truncateAttempt >= TRUNCATE_CONFIG.maxTruncateAttempts) {
-    return { handled: false, nextTruncateAttempt: params.truncateAttempt }
-  }
-
-  log("[auto-compact] PHASE 2: aggressive truncation triggered", {
-    currentTokens: params.currentTokens,
-    maxTokens: params.maxTokens,
-    targetRatio: TRUNCATE_CONFIG.targetTokenRatio,
-  })
-
-  const aggressiveResult = await truncateUntilTargetTokens(
-    params.sessionID,
-    params.currentTokens,
-    params.maxTokens,
-    TRUNCATE_CONFIG.targetTokenRatio,
-    TRUNCATE_CONFIG.charsPerToken,
-    params.client,
-  )
-
-  if (aggressiveResult.truncatedCount <= 0) {
-    return { handled: false, nextTruncateAttempt: params.truncateAttempt }
-  }
-
-  const nextTruncateAttempt = params.truncateAttempt + aggressiveResult.truncatedCount
-  const toolNames = aggressiveResult.truncatedTools.map((t) => t.toolName).join(", ")
-  const statusMsg = aggressiveResult.sufficient
-    ? `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)})`
-    : `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)}) - continuing to summarize...`
-
-  await params.client.tui
-    .showToast({
-      body: {
-        title: aggressiveResult.sufficient ? "Truncation Complete" : "Partial Truncation",
-        message: `${statusMsg}: ${toolNames}`,
-        variant: aggressiveResult.sufficient ? "success" : "warning",
-        duration: 4000,
-      },
-    })
-    .catch(() => {})
-
-  log("[auto-compact] aggressive truncation completed", aggressiveResult)
-
-  if (aggressiveResult.sufficient) {
-    clearSessionState(params.autoCompactState, params.sessionID)
-    setTimeout(async () => {
-      try {
-        const inheritedTools = resolveInheritedPromptTools(params.sessionID)
-        await params.client.session.promptAsync({
-          path: { id: params.sessionID },
-          body: {
-            auto: true,
-            ...(inheritedTools ? { tools: inheritedTools } : {}),
-          } as never,
-          query: { directory: params.directory },
-        })
-      } catch {}
-    }, 500)
-
-    return { handled: true, nextTruncateAttempt }
-  }
-
-  log("[auto-compact] truncation insufficient, falling through to summarize", {
-    sessionID: params.sessionID,
-    truncatedCount: aggressiveResult.truncatedCount,
-    sufficient: aggressiveResult.sufficient,
-  })
-
-  return { handled: false, nextTruncateAttempt }
-}

package/src/hooks/anthropic-context-window-limit-recovery/client.ts

@@ -1,21 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-export type Client = PluginInput["client"] & {
-  session: {
-    promptAsync: (opts: {
-      path: { id: string }
-      body: { parts: Array<{ type: string; text: string }> }
-      query: { directory: string }
-    }) => Promise<unknown>
-  }
-  tui: {
-    showToast: (opts: {
-      body: {
-        title: string
-        message: string
-        variant: string
-        duration: number
-      }
-    }) => Promise<unknown>
-  }
-}

package/src/hooks/anthropic-context-window-limit-recovery/deduplication-recovery.ts

@@ -1,77 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { ParsedTokenLimitError } from "./types"
-import type { ExperimentalConfig } from "../../config"
-import type { DeduplicationConfig } from "./pruning-deduplication"
-import type { PruningState } from "./pruning-types"
-import { executeDeduplication } from "./pruning-deduplication"
-import { truncateToolOutputsByCallId } from "./pruning-tool-output-truncation"
-import { log } from "../../shared/logger"
-
-type OpencodeClient = PluginInput["client"]
-
-function createPruningState(): PruningState {
-  return {
-    toolIdsToPrune: new Set<string>(),
-    currentTurn: 0,
-    fileOperations: new Map(),
-    toolSignatures: new Map(),
-    erroredTools: new Map(),
-  }
-}
-
-function isPromptTooLongError(parsed: ParsedTokenLimitError): boolean {
-  return !parsed.errorType.toLowerCase().includes("non-empty content")
-}
-
-function getDeduplicationPlan(
-  experimental?: ExperimentalConfig,
-): { config: DeduplicationConfig; protectedTools: Set<string> } | null {
-  const pruningConfig = experimental?.dynamic_context_pruning
-  if (!pruningConfig?.enabled) return null
-
-  const deduplicationEnabled = pruningConfig.strategies?.deduplication?.enabled
-  if (deduplicationEnabled === false) return null
-
-  const protectedTools = new Set(pruningConfig.protected_tools ?? [])
-  return {
-    config: {
-      enabled: true,
-      protectedTools: pruningConfig.protected_tools ?? [],
-    },
-    protectedTools,
-  }
-}
-
-export async function attemptDeduplicationRecovery(
-  sessionID: string,
-  parsed: ParsedTokenLimitError,
-  experimental: ExperimentalConfig | undefined,
-  client?: OpencodeClient,
-): Promise<void> {
-  if (!isPromptTooLongError(parsed)) return
-
-  const plan = getDeduplicationPlan(experimental)
-  if (!plan) return
-
-  const pruningState = createPruningState()
-  const prunedCount = await executeDeduplication(
-    sessionID,
-    pruningState,
-    plan.config,
-    plan.protectedTools,
-    client,
-  )
-  const { truncatedCount } = await truncateToolOutputsByCallId(
-    sessionID,
-    pruningState.toolIdsToPrune,
-    client,
-  )
-
-  if (prunedCount > 0 || truncatedCount > 0) {
-    log("[auto-compact] deduplication recovery applied", {
-      sessionID,
-      prunedCount,
-      truncatedCount,
-    })
-  }
-}