@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/tools/delegate-task/openai-categories.ts

@@ -1,128 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const ULTRABRAIN_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on DEEP LOGICAL REASONING / COMPLEX ARCHITECTURE tasks.
-
-<Routing_Policy>
-Executor contour: coder (deep execution). Do not use this category for bounded quick edits.
-</Routing_Policy>
-
-**CRITICAL - CODE STYLE REQUIREMENTS (NON-NEGOTIABLE)**:
-1. BEFORE writing ANY code, SEARCH the existing codebase to find similar patterns/styles
-2. Your code MUST match the project's existing conventions - blend in seamlessly
-3. Write READABLE code that humans can easily understand - no clever tricks
-4. If unsure about style, explore more files until you find the pattern
-
-Strategic advisor mindset:
-- Bias toward simplicity: least complex solution that fulfills requirements
-- Leverage existing code/patterns over new components
-- Prioritize developer experience and maintainability
-- One clear recommendation with effort estimate (Quick/Short/Medium/Large)
-- Signal when advanced approach warranted
-
-Response format:
-- Bottom line (2-3 sentences)
-- Action plan (numbered steps)
-- Risks and mitigations (if relevant)
-</Category_Context>`
-
-const DEEP_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on GOAL-ORIENTED AUTONOMOUS tasks.
-
-<Routing_Policy>
-Executor contour: coder (deep execution). Use quick for bounded low-cost changes.
-</Routing_Policy>
-
-You are NOT an interactive assistant. You are an autonomous problem-solver.
-
-BEFORE making ANY changes:
-1. Silently explore the codebase extensively (5-15 minutes of reading is normal)
-2. Read related files, trace dependencies, understand the full context
-3. Build a complete mental model of the problem space
-4. Do not ask clarifying questions - the goal is already defined
-
-You receive a GOAL. When the goal includes numbered steps or phases, treat them as one atomic task broken into sub-steps, not as separate independent tasks. Figure out HOW to achieve it yourself. Thorough research before any action.
-
-Sub-steps of ONE goal = execute all steps as phases of one atomic task.
-Genuinely independent tasks = flag and refuse, require separate delegations.
-
-Approach: explore extensively, understand deeply, then act decisively. Prefer comprehensive solutions over quick patches. If the goal is unclear, make reasonable assumptions and proceed.
-
-Minimal status updates. Focus on results, not play-by-play. Report completion with summary of changes.
-</Category_Context>`
-
-const QUICK_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on SMALL / QUICK tasks.
-
-<Routing_Policy>
-Executor contour: coder (fast bounded execution). Keep the implementation narrow and escalate only when the task truly becomes deep or cross-system.
-</Routing_Policy>
-
-Efficient execution mindset:
-- Fast, focused, minimal overhead
-- Get to the point immediately
-- No over-engineering
-- Simple solutions for simple problems
-
-Approach:
-- Minimal viable implementation
-- Skip unnecessary abstractions
-- Direct and concise
-</Category_Context>
-
-<Caller_Warning>
-THIS CATEGORY USES A SMALLER/FASTER MODEL (the selected fast-tier model).
-
-The model executing this task is optimized for speed over depth. Your prompt MUST be:
-
-**EXHAUSTIVELY EXPLICIT** - Leave NOTHING to interpretation:
-1. MUST DO: List every required action as atomic, numbered steps
-2. MUST NOT DO: Explicitly forbid likely mistakes and deviations
-3. EXPECTED OUTPUT: Describe exact success criteria with concrete examples
-
-**WHY THIS MATTERS:**
-- Smaller models benefit from explicit guardrails
-- Vague instructions may lead to unpredictable results
-- Implicit expectations may be missed
-**PROMPT STRUCTURE (MANDATORY):**
-\`\`\`
-TASK: [One-sentence goal]
-
-MUST DO:
-1. [Specific action with exact details]
-2. [Another specific action]
-...
-
-MUST NOT DO:
-- [Forbidden action + why]
-- [Another forbidden action]
-...
-
-EXPECTED OUTPUT:
-- [Exact deliverable description]
-- [Success criteria / verification method]
-\`\`\`
-
-If your prompt lacks this structure, REWRITE IT before delegating.
-</Caller_Warning>`
-
-export const OPENAI_CATEGORIES: BuiltinCategoryDefinition[] = [
-  {
-    name: "ultrabrain",
-    config: {},
-    description: "Hard logic and architecture tasks. Uses coder execution contour; avoid for quick bounded edits.",
-    promptAppend: ULTRABRAIN_CATEGORY_PROMPT_APPEND,
-  },
-  {
-    name: "deep",
-    config: {},
-    description: "Deep autonomous implementation with full context buildup. Uses coder execution contour.",
-    promptAppend: DEEP_CATEGORY_PROMPT_APPEND,
-  },
-  {
-    name: "quick",
-    config: {},
-    description: "Fast bounded execution: single-file fixes, typos, and simple modifications. Uses coder execution contour.",
-    promptAppend: QUICK_CATEGORY_PROMPT_APPEND,
-  },
-]

package/src/tools/delegate-task/parent-context-resolver.ts

@@ -1,47 +0,0 @@
-import type { ToolContextWithMetadata } from "./types"
-import type { OpencodeClient } from "./types"
-import type { ParentContext } from "./executor-types"
-import { resolveMessageContext } from "../../features/hook-message-injector"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { log } from "../../shared/logger"
-import { getMessageDir } from "../../shared/opencode-message-dir"
-
-export async function resolveParentContext(
-  ctx: ToolContextWithMetadata,
-  client: OpencodeClient
-): Promise<ParentContext> {
-  const messageDir = getMessageDir(ctx.sessionID)
-  const { prevMessage, firstMessageAgent } = await resolveMessageContext(
-    ctx.sessionID,
-    client,
-    messageDir
-  )
-
-  const sessionAgent = getSessionAgent(ctx.sessionID)
-  const parentAgent = ctx.agent ?? sessionAgent ?? firstMessageAgent ?? prevMessage?.agent
-
-  log("[task] parentAgent resolution", {
-    sessionID: ctx.sessionID,
-    messageDir,
-    ctxAgent: ctx.agent,
-    sessionAgent,
-    firstMessageAgent,
-    prevMessageAgent: prevMessage?.agent,
-    resolvedParentAgent: parentAgent,
-  })
-
-  const parentModel = prevMessage?.model?.providerID && prevMessage?.model?.modelID
-    ? {
-        providerID: prevMessage.model.providerID,
-        modelID: prevMessage.model.modelID,
-        ...(prevMessage.model.variant ? { variant: prevMessage.model.variant } : {}),
-      }
-    : undefined
-
-  return {
-    sessionID: ctx.sessionID,
-    messageID: ctx.messageID,
-    agent: parentAgent,
-    model: parentModel,
-  }
-}

package/src/tools/delegate-task/prompt-builder.ts

@@ -1,107 +0,0 @@
-import type { BuildSystemContentInput } from "./types"
-import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder"
-import { buildPlanAgentSystemPrepend, isPlanAgent } from "./constants"
-import { buildSystemContentWithTokenLimit } from "./token-limiter"
-
-const FREE_OR_LOCAL_PROMPT_TOKEN_LIMIT = 24000
-const PLAN_AGENT_PROMPT_BASE = `
-
-Additional requirements for this planning request:
-- Answer in English.
-- Write the plan in English.
-- Plan well for ultrawork execution.
-- Include a clear atomic commit strategy.`
-
-const TDD_LINE = "- Use TDD-oriented planning."
-
-function buildPlanAgentPromptAppend(tddEnabled: boolean): string {
-  if (tddEnabled) {
-    return `${PLAN_AGENT_PROMPT_BASE}
-${TDD_LINE}`
-  }
-  return PLAN_AGENT_PROMPT_BASE
-}
-
-function buildAvailableSkillsSection(skills: AvailableSkill[]): string {
-  if (skills.length === 0) {
-    return ""
-  }
-
-  const rows = skills
-    .map((s) => `- \`${s.name}\`: ${s.description || s.name}`)
-    .join("\n")
-
-  return `<available_skills>
-Skills provide specialized instructions. Load via load_skills parameter when delegating tasks.
-
-${rows}
-</available_skills>`
-}
-
-function usesFreeOrLocalModel(model: { providerID: string; modelID: string; variant?: string } | undefined): boolean {
-  if (!model) {
-    return false
-  }
-
-  const provider = model.providerID.toLowerCase()
-  const modelId = model.modelID.toLowerCase()
-  return provider.includes("local")
-    || provider === "ollama"
-    || provider === "lmstudio"
-    || modelId.includes("free")
-}
-
-/**
- * Build the system content to inject into the agent prompt.
- * Combines skill content, category prompt append, and plan agent system prepend.
- */
-export function buildSystemContent(input: BuildSystemContentInput): string | undefined {
-  const {
-    skillContent,
-    skillContents,
-    categoryPromptAppend,
-    agentsContext,
-    maxPromptTokens,
-    model,
-    agentName,
-    availableCategories,
-    availableSkills,
-  } = input
-
-  const isPlan = isPlanAgent(agentName)
-  const planAgentPrepend = isPlan
-    ? buildPlanAgentSystemPrepend(availableCategories, availableSkills)
-    : ""
-
-  const skillsSection = !isPlan
-    ? buildAvailableSkillsSection(availableSkills ?? [])
-    : ""
-
-  const baseAgentsContext = agentsContext ?? planAgentPrepend
-  const effectiveAgentsContext = !isPlan && skillsSection
-    ? [baseAgentsContext, skillsSection].filter(Boolean).join("\n\n")
-    : baseAgentsContext
-
-  const effectiveMaxPromptTokens = maxPromptTokens
-    ?? (usesFreeOrLocalModel(model) ? FREE_OR_LOCAL_PROMPT_TOKEN_LIMIT : undefined)
-
-  return buildSystemContentWithTokenLimit(
-    {
-      skillContent,
-      skillContents,
-      categoryPromptAppend,
-      agentsContext: effectiveAgentsContext,
-      planAgentPrepend,
-    },
-    effectiveMaxPromptTokens
-  )
-}
-
-export function buildTaskPrompt(prompt: string, agentName: string | undefined, tddEnabled?: boolean): string {
-  if (!isPlanAgent(agentName)) {
-    return prompt
-  }
-
-  const effectiveTdd = tddEnabled ?? true
-  return `${prompt}${buildPlanAgentPromptAppend(effectiveTdd)}`
-}

package/src/tools/delegate-task/resolve-call-id.ts

@@ -1,5 +0,0 @@
-import type { ToolContextWithMetadata } from "./types"
-
-export function resolveCallID(ctx: ToolContextWithMetadata): string | undefined {
-  return ctx.callID ?? ctx.callId ?? ctx.call_id
-}

package/src/tools/delegate-task/skill-resolver.ts

@@ -1,22 +0,0 @@
-import type { GitMasterConfig, BrowserAutomationProvider } from "../../config/schema"
-import { resolveMultipleSkillsAsync } from "../../features/opencode-skill-loader/skill-content"
-import { discoverSkills } from "../../features/opencode-skill-loader"
-
-export async function resolveSkillContent(
-  skills: string[],
-  options: { gitMasterConfig?: GitMasterConfig; browserProvider?: BrowserAutomationProvider, disabledSkills?: Set<string>, directory?: string }
-): Promise<{ content: string | undefined; contents: string[]; error: string | null }> {
-  if (skills.length === 0) {
-    return { content: undefined, contents: [], error: null }
-  }
-
-  const { resolved, notFound } = await resolveMultipleSkillsAsync(skills, options)
-  if (notFound.length > 0) {
-    const allSkills = await discoverSkills({ includeClaudeCodePaths: true, directory: options?.directory })
-    const available = allSkills.map(s => s.name).join(", ")
-    return { content: undefined, contents: [], error: `Skills not found: ${notFound.join(", ")}. Available: ${available}` }
-  }
-
-  const contents = Array.from(resolved.values())
-  return { content: contents.join("\n\n"), contents, error: null }
-}

package/src/tools/delegate-task/sub-agent.ts

@@ -1,70 +0,0 @@
-import { getAgentConfigKey, getAgentDisplayName } from "../../shared/agent-display-names"
-import { log } from "../../shared/logger"
-
-export const SUB_AGENT_CONFIG_KEY = "sub"
-export const CODER_AGENT_CONFIG_KEY = "coder"
-export const CRITIC_AGENT_CONFIG_KEY = "critic"
-
-export const CANONICAL_DELEGATE_AGENT_KEYS = [
-  "bob",
-  "guard",
-  "strategist",
-  "critic",
-  "coder",
-  "sub",
-  "researcher",
-  "multimodal",
-  "designer",
-  "platform-manager",
-  "brainstormer",
-  "agent-skills",
-] as const
-
-type CanonicalDelegateAgentKey = (typeof CANONICAL_DELEGATE_AGENT_KEYS)[number]
-const CANONICAL_DELEGATE_AGENT_KEY_SET = new Set<string>(CANONICAL_DELEGATE_AGENT_KEYS)
-
-const LEGACY_DELEGATE_AGENT_ALIASES: Record<string, CanonicalDelegateAgentKey> = {
-  general: "bob",
-  zoe: "bob",
-  build: "bob",
-  "plan-consultant": "strategist",
-  "pre-plan": "strategist",
-  "planner-bob": "strategist",
-  "omo-plan": "strategist",
-  plan: "strategist",
-  logician: "strategist",
-  athena: "strategist",
-  "athena-junior": "strategist",
-  librarian: "researcher",
-  explore: "researcher",
-  "code-reviewer": "critic",
-  "systematic-debugger": "critic",
-  "ledger-creator": "platform-manager",
-  bootstrapper: "platform-manager",
-  "project-initializer": "platform-manager",
-  mindmodel: "platform-manager",
-  ui: "multimodal",
-  subagent: "sub",
-  "bob-junior": "sub",
-}
-
-export function resolveCanonicalDelegateAgentKey(agentName: string): string {
-  const configKey = getAgentConfigKey(agentName).trim().toLowerCase()
-  if (!configKey) return configKey
-  const resolved = LEGACY_DELEGATE_AGENT_ALIASES[configKey]
-  if (resolved && resolved !== configKey) {
-    log("[delegate-task] Legacy agent alias resolved", { from: configKey, to: resolved })
-    return resolved
-  }
-  return configKey
-}
-
-export function isCanonicalDelegateAgentKey(agentName: string): boolean {
-  return CANONICAL_DELEGATE_AGENT_KEY_SET.has(resolveCanonicalDelegateAgentKey(agentName))
-}
-
-export function getCanonicalDelegateAgentDisplayName(agentName: string): string {
-  return getAgentDisplayName(resolveCanonicalDelegateAgentKey(agentName))
-}
-
-export const BOB_JUNIOR_AGENT = getAgentDisplayName(SUB_AGENT_CONFIG_KEY)

package/src/tools/delegate-task/subagent-discovery.ts

@@ -1,152 +0,0 @@
-import { getAgentConfigKey, getAgentDisplayName, stripAgentListSortPrefix } from "../../shared/agent-display-names"
-import { loadUserAgents, loadProjectAgents } from "../../features/claude-code-agent-loader"
-import {
-  getCanonicalDelegateAgentDisplayName,
-  isCanonicalDelegateAgentKey,
-  resolveCanonicalDelegateAgentKey,
-} from "./sub-agent"
-
-export type AgentMode = "subagent" | "primary" | "all" | undefined
-
-export type AgentInfo = {
-  name: string
-  mode?: "subagent" | "primary" | "all"
-  model?: string | { providerID: string; modelID: string }
-}
-
-export function sanitizeSubagentType(subagentType: string): string {
-  return subagentType.trim().replace(/^[\\\/"']+|[\\\/"']+$/g, "").trim()
-}
-
-export function mergeWithClaudeCodeAgents(
-  serverAgents: AgentInfo[],
-  directory: string | undefined,
-): AgentInfo[] {
-  const userAgentsRecord = loadUserAgents()
-  const projectAgentsRecord = loadProjectAgents(directory)
-
-  const toAgentInfoList = (record: Record<string, { mode?: string; model?: AgentInfo["model"] }>): AgentInfo[] =>
-    Object.entries(record).map(([name, config]) => ({
-      name,
-      mode: config.mode as AgentInfo["mode"],
-      model: config.model,
-    }))
-
-  const mergedAgentMap = new Map<string, AgentInfo>()
-  const addIfAbsent = (agent: AgentInfo): void => {
-    const key = stripAgentListSortPrefix(agent.name).trim().toLowerCase()
-    if (!mergedAgentMap.has(key)) {
-      mergedAgentMap.set(key, agent)
-    }
-  }
-
-  for (const agent of serverAgents) addIfAbsent(agent)
-  for (const agent of toAgentInfoList(projectAgentsRecord)) addIfAbsent(agent)
-  for (const agent of toAgentInfoList(userAgentsRecord)) addIfAbsent(agent)
-
-  return Array.from(mergedAgentMap.values())
-}
-
-function normalizeComparableName(agentName: string): string {
-  return stripAgentListSortPrefix(agentName).trim().toLowerCase()
-}
-
-function getCanonicalKey(agentName: string): string {
-  return resolveCanonicalDelegateAgentKey(agentName).trim().toLowerCase()
-}
-
-function buildComparableNames(agentName: string): Set<string> {
-  return new Set([
-    agentName,
-    getAgentDisplayName(agentName),
-    getAgentConfigKey(agentName),
-    resolveCanonicalDelegateAgentKey(agentName),
-    getCanonicalDelegateAgentDisplayName(agentName),
-  ].map(normalizeComparableName))
-}
-
-function matchesRequestedAgent(agent: AgentInfo, requestedAgentName: string): boolean {
-  const comparableNames = buildComparableNames(requestedAgentName)
-  const listedAgentName = normalizeComparableName(agent.name)
-  const listedAgentConfigKey = normalizeComparableName(getAgentConfigKey(agent.name))
-  const listedCanonicalKey = getCanonicalKey(agent.name)
-
-  return comparableNames.has(listedAgentName)
-    || comparableNames.has(listedAgentConfigKey)
-    || comparableNames.has(listedCanonicalKey)
-}
-
-export function isTaskCallableAgentMode(mode: AgentMode): boolean {
-  return mode === "all" || mode === "subagent"
-}
-
-function selectPreferredAgentMatch(
-  agents: AgentInfo[],
-  requestedAgentName: string,
-  modeMatcher: (mode: AgentMode) => boolean,
-): AgentInfo | undefined {
-  const candidates = agents.filter(
-    (agent) => modeMatcher(agent.mode) && matchesRequestedAgent(agent, requestedAgentName)
-  )
-  if (candidates.length === 0) {
-    return undefined
-  }
-
-  const requestedCanonicalKey = getCanonicalKey(requestedAgentName)
-  const canonicalCandidates = candidates.filter(
-    (agent) => getCanonicalKey(agent.name) === requestedCanonicalKey
-  )
-  if (canonicalCandidates.length === 0) {
-    return candidates[0]
-  }
-
-  // Prefer canonical runtime agent names over legacy aliases when both exist.
-  const preferredCanonical = canonicalCandidates.find((agent) =>
-    isCanonicalDelegateAgentKey(getAgentConfigKey(agent.name))
-  )
-  return preferredCanonical ?? canonicalCandidates[0]
-}
-
-export function findPrimaryAgentMatch(
-  agents: AgentInfo[],
-  requestedAgentName: string,
-): AgentInfo | undefined {
-  return selectPreferredAgentMatch(
-    agents,
-    requestedAgentName,
-    (mode) => mode === "primary",
-  )
-}
-
-export function findCallableAgentMatch(
-  agents: AgentInfo[],
-  requestedAgentName: string,
-): AgentInfo | undefined {
-  return selectPreferredAgentMatch(
-    agents,
-    requestedAgentName,
-    (mode) => isTaskCallableAgentMode(mode),
-  )
-}
-
-export function listCallableAgentNames(agents: AgentInfo[]): string {
-  const uniqueNames = new Map<string, string>()
-
-  for (const agent of agents) {
-    if (!isTaskCallableAgentMode(agent.mode)) {
-      continue
-    }
-    const canonicalKey = resolveCanonicalDelegateAgentKey(agent.name)
-    const displayName = isCanonicalDelegateAgentKey(canonicalKey)
-      ? getAgentDisplayName(canonicalKey)
-      : stripAgentListSortPrefix(agent.name)
-    const lookupKey = displayName.toLowerCase()
-    if (!uniqueNames.has(lookupKey)) {
-      uniqueNames.set(lookupKey, displayName)
-    }
-  }
-
-  return Array.from(uniqueNames.values())
-    .sort()
-    .join(", ")
-}