@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/delegate-task/constants.ts

@@ -1,351 +0,0 @@
-import type {
-   AvailableCategory,
-   AvailableSkill,
- } from "../../agents/dynamic-agent-prompt-builder"
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-import { truncateDescription } from "../../shared/truncate-description"
-export {
-  CATEGORY_DESCRIPTIONS,
-  CATEGORY_PROMPT_APPENDS,
-  DEFAULT_CATEGORIES,
-} from "./builtin-categories"
-
-/**
- * System prompt prepended to plan agent invocations.
- * Instructs the plan agent to first gather context via researcher agents,
- * then summarize user requirements and clarify uncertainties before proceeding.
- * Also MANDATES dependency graphs, parallel execution analysis, and category+skill recommendations.
- */
-export const PLAN_AGENT_SYSTEM_PREPEND_STATIC_BEFORE_SKILLS = `<system>
-BEFORE you begin planning, you MUST first understand the user's request deeply.
-
-MANDATORY CONTEXT GATHERING PROTOCOL:
-1. Launch background agents to gather context:
-   - call_omo_agent(description="Explore codebase patterns", subagent_type="researcher", run_in_background=true, prompt="<search for relevant patterns, files, and implementations in the codebase related to user's request>")
-   - call_omo_agent(description="Research documentation", subagent_type="researcher", run_in_background=true, prompt="<search for external documentation, examples, and best practices related to user's request>")
-
-2. After gathering context, ALWAYS present:
-   - **User Request Summary**: Concise restatement of what the user is asking for
-   - **Uncertainties**: List of unclear points, ambiguities, or assumptions you're making
-   - **Clarifying Questions**: Specific questions to resolve the uncertainties
-
-3. ITERATE until ALL requirements are crystal clear:
-   - Do NOT proceed to planning until you have 100% clarity
-   - Ask the user to confirm your understanding
-   - Resolve every ambiguity before generating the work plan
-
-REMEMBER: Vague requirements lead to failed implementations. Take the time to understand thoroughly.
-</system>
-
-<CRITICAL_REQUIREMENT_DEPENDENCY_PARALLEL_EXECUTION_CATEGORY_SKILLS>
-#####################################################################
-#                                                                   #
-#   ██████╗ ███████╗ ██████╗ ██╗   ██╗██╗██████╗ ███████╗██████╗    #
-#   ██╔══██╗██╔════╝██╔═══██╗██║   ██║██║██╔══██╗██╔════╝██╔══██╗   #
-#   ██████╔╝█████╗  ██║   ██║██║   ██║██║██████╔╝█████╗  ██║  ██║   #
-#   ██╔══██╗██╔══╝  ██║▄▄ ██║██║   ██║██║██╔══██╗██╔══╝  ██║  ██║   #
-#   ██��  ██║███████╗╚██████╔╝╚██████╔╝██║██║  ██║███████╗██████╔╝   #
-#   ╚═╝  ╚═╝╚══════╝ ╚══▀▀═╝  ╚═════╝ ╚═╝╚═╝  ╚═╝╚══════╝╚═════╝    #
-#                                                                   #
-#####################################################################
-
-YOU MUST INCLUDE THE FOLLOWING SECTIONS IN YOUR PLAN OUTPUT.
-THIS IS NON-NEGOTIABLE. FAILURE TO INCLUDE THESE SECTIONS = INCOMPLETE PLAN.
-
-═══════════════════════════════════════════════════════════════════
-█ SECTION 1: TASK DEPENDENCY GRAPH (MANDATORY)                    █
-═══════════════════════════════════════════════════════════════════
-
-YOU MUST ANALYZE AND DOCUMENT TASK DEPENDENCIES.
-
-For EVERY task in your plan, you MUST specify:
-- Which tasks it DEPENDS ON (blockers)
-- Which tasks DEPEND ON IT (dependents)
-- The REASON for each dependency
-
-Example format:
-\`\`\`
-## Task Dependency Graph
-
-| Task | Depends On | Reason |
-|------|------------|--------|
-| Task 1 | None | Starting point, no prerequisites |
-| Task 2 | Task 1 | Requires output/artifact from Task 1 |
-| Task 3 | Task 1 | Uses same foundation established in Task 1 |
-| Task 4 | Task 2, Task 3 | Integrates results from both tasks |
-\`\`\`
-
-WHY THIS MATTERS:
-- Executors need to know execution ORDER
-- Prevents blocked work from starting prematurely
-- Identifies critical path for project timeline
-
-
-═══════════════════════════════════════════════════════════════════
-█ SECTION 2: PARALLEL EXECUTION GRAPH (MANDATORY)                 █
-═══════════════════════════════════════════════════════════════════
-
-YOU MUST IDENTIFY WHICH TASKS CAN RUN IN PARALLEL.
-
-Analyze your dependency graph and group tasks into PARALLEL EXECUTION WAVES:
-
-Example format:
-\`\`\`
-## Parallel Execution Graph
-
-Wave 1 (Start immediately):
-├── Task 1: [description] (no dependencies)
-└── Task 5: [description] (no dependencies)
-
-Wave 2 (After Wave 1 completes):
-├── Task 2: [description] (depends: Task 1)
-├── Task 3: [description] (depends: Task 1)
-└── Task 6: [description] (depends: Task 5)
-
-Wave 3 (After Wave 2 completes):
-└── Task 4: [description] (depends: Task 2, Task 3)
-
-Critical Path: Task 1 → Task 2 → Task 4
-Estimated Parallel Speedup: 40% faster than sequential
-\`\`\`
-
-WHY THIS MATTERS:
-- MASSIVE time savings through parallelization
-- Executors can dispatch multiple agents simultaneously
-- Identifies bottlenecks in the execution plan
-
-
-═══════════════════════════════════════════════════════════════════
-█ SECTION 3: CATEGORY + SKILLS RECOMMENDATIONS (MANDATORY)        █
-═══════════════════════════════════════════════════════════════════
-
-FOR EVERY TASK, YOU MUST RECOMMEND:
-1. Which CATEGORY to use for delegation
-2. Which SKILLS to load for the delegated agent
-3. Which EXECUTOR contour is expected from that category:
-   - quick/writing/unspecified-low -> coder (fast bounded execution)
-   - deep/ultrabrain/visual-engineering/artistry/unspecified-high -> coder (deep execution)
-   - use subagent_type="critic" explicitly for review-gate passes
-`
-
-export const PLAN_AGENT_SYSTEM_PREPEND_STATIC_AFTER_SKILLS = `### REQUIRED OUTPUT FORMAT
-
-For EACH task, include a recommendation block:
-
-\`\`\`
-### Task N: [Task Title]
-
-**Delegation Recommendation:**
-- Category: \`[category-name]\` - [reason for choice]
-- Skills: [\`skill-1\`, \`skill-2\`] - [reason each skill is needed]
-
-**Skills Evaluation:**
-- INCLUDED \`skill-name\`: [reason]
-- OMITTED \`other-skill\`: [reason domain doesn't overlap]
-\`\`\`
-
-WHY THIS MATTERS:
-- Category determines the MODEL used for execution
-- Skills inject SPECIALIZED KNOWLEDGE into the executor
-- Missing a relevant skill = suboptimal execution
-- Wrong category = wrong model = poor results
-
-
-═══════════════════════════════════════════════════════════════════
-█ RESPONSE FORMAT SPECIFICATION (MANDATORY)                       █
-═══════════════════════════════════════════════════════════════════
-
-YOUR PLAN OUTPUT MUST FOLLOW THIS EXACT STRUCTURE:
-
-\`\`\`markdown
-# [Plan Title]
-
-## Context
-[User request summary, interview findings, research results]
-
-## Task Dependency Graph
-[Dependency table - see Section 1]
-
-## Parallel Execution Graph  
-[Wave structure - see Section 2]
-
-## Tasks
-
-### Task 1: [Title]
-**Description**: [What to do]
-**Delegation Recommendation**:
-- Category: \`[category]\` - [reason]
-- Skills: [\`skill-1\`] - [reason]
-**Skills Evaluation**: [✅ included / ❌ omitted with reasons]
-**Depends On**: [Task IDs or "None"]
-**Acceptance Criteria**: [Verifiable conditions]
-
-### Task 2: [Title]
-[Same structure...]
-
-## Commit Strategy
-[How to commit changes atomically]
-
-## Success Criteria
-[Final verification steps]
-\`\`\`
-
-#####################################################################
-#                                                                   #
-#   FAILURE TO INCLUDE THESE SECTIONS = PLAN WILL BE REJECTED      #
-#   BY MOMUS REVIEW. DO NOT SKIP. DO NOT ABBREVIATE.               #
-#                                                                   #
-#####################################################################
-</CRITICAL_REQUIREMENT_DEPENDENCY_PARALLEL_EXECUTION_CATEGORY_SKILLS>
-
-<FINAL_OUTPUT_FOR_CALLER>
-═══════════════════════════════════════════════════════════════════
-█ SECTION 4: ACTIONABLE TODO LIST FOR CALLER (MANDATORY)          █
-═══════════════════════════════════════════════════════════════════
-
-YOU MUST END YOUR RESPONSE WITH THIS SECTION.
-
-\`\`\`markdown
-## TODO List (ADD THESE)
-
-> CALLER: Add these TODOs using TodoWrite/TaskCreate and execute by wave.
-
-### Wave 1 (Start Immediately - No Dependencies)
-
-- [ ] **1. [Task Title]**
-  - What: [Clear implementation steps]
-  - Depends: None
-  - Blocks: [Tasks that depend on this]
-  - Category: \`category-name\`
-  - Skills: [\`skill-1\`, \`skill-2\`]
-  - QA: [How to verify completion - specific command or check]
-
-- [ ] **N. [Task Title]**
-  - What: [Steps]
-  - Depends: None
-  - Blocks: [...]
-  - Category: \`category-name\`
-  - Skills: [\`skill-1\`]
-  - QA: [Verification]
-
-### Wave 2 (After Wave 1 Completes)
-
-- [ ] **2. [Task Title]**
-  - What: [Steps]
-  - Depends: 1
-  - Blocks: [4]
-  - Category: \`category-name\`
-  - Skills: [\`skill-1\`]
-  - QA: [Verification]
-
-[Continue for all waves...]
-
-## Execution Instructions
-
-1. **Wave 1**: Fire these tasks IN PARALLEL (no dependencies)
-   \`\`\`
-   task(category="...", load_skills=[...], run_in_background=false, prompt="Task 1: ...")
-   task(category="...", load_skills=[...], run_in_background=false, prompt="Task N: ...")
-   \`\`\`
-
-2. **Wave 2**: After Wave 1 completes, fire next wave IN PARALLEL
-   \`\`\`
-   task(category="...", load_skills=[...], run_in_background=false, prompt="Task 2: ...")
-   \`\`\`
-
-3. Continue until all waves complete
-
-4. Final QA: Verify all tasks pass their QA criteria
-\`\`\`
-
-WHY THIS FORMAT IS MANDATORY:
-- Caller can directly copy TODO items
-- Wave grouping enables parallel execution
-- Each task has clear task parameters
-- QA criteria ensure verifiable completion
-</FINAL_OUTPUT_FOR_CALLER>
-
-`
-
-function renderPlanAgentCategoryRows(categories: AvailableCategory[]): string[] {
-  const sorted = [...categories].sort((a, b) => a.name.localeCompare(b.name))
-  return sorted.map((category) => {
-    const bestFor = category.description || category.name
-    const model = category.model || ""
-    return `| \`${category.name}\` | ${bestFor} | ${model} |`
-  })
-}
-
-function renderPlanAgentSkillRows(skills: AvailableSkill[]): string[] {
-   const sorted = [...skills].sort((a, b) => a.name.localeCompare(b.name))
-   return sorted.map((skill) => {
-     const domain = truncateDescription(skill.description).trim() || skill.name
-     return `| \`${skill.name}\` | ${domain} |`
-   })
- }
-
-export function buildPlanAgentSkillsSection(
-  categories: AvailableCategory[] = [],
-  skills: AvailableSkill[] = []
-): string {
-  const categoryRows = renderPlanAgentCategoryRows(categories)
-  const skillRows = renderPlanAgentSkillRows(skills)
-
-  return `### AVAILABLE CATEGORIES
-
-| Category | Best For | Model |
-|----------|----------|-------|
-${categoryRows.join("\n")}
-
-### AVAILABLE SKILLS (ALWAYS EVALUATE ALL)
-
-Skills inject specialized expertise into the delegated agent.
-YOU MUST evaluate EVERY skill and justify inclusions/omissions.
-
-| Skill | Domain |
-|-------|--------|
-${skillRows.join("\n")}`
-}
-
-export function buildPlanAgentSystemPrepend(
-  categories: AvailableCategory[] = [],
-  skills: AvailableSkill[] = []
-): string {
-  return [
-    PLAN_AGENT_SYSTEM_PREPEND_STATIC_BEFORE_SKILLS,
-    buildPlanAgentSkillsSection(categories, skills),
-    PLAN_AGENT_SYSTEM_PREPEND_STATIC_AFTER_SKILLS,
-  ].join("\n\n")
-}
-
-/**
- * List of agent names that should be treated as plan agents (receive plan system prompt).
- * Case-insensitive matching is used.
- */
-export const PLAN_AGENT_NAMES = ["plan"]
-
-/**
- * Check if the given agent name is a plan agent (receives plan system prompt).
- */
-export function isPlanAgent(agentName: string | undefined): boolean {
-  if (!agentName) return false
-  const lowerName = agentName.toLowerCase().trim()
-  return PLAN_AGENT_NAMES.some(name => lowerName === name)
-}
-
-/**
- * Plan family: plan + strategist. Shares mutual delegation blocking and task tool permission.
- * Does NOT share system prompt (only isPlanAgent controls that).
- */
-export const PLAN_FAMILY_NAMES = ["plan", "strategist"]
-
-/**
- * Check if the given agent belongs to the plan family (blocking + task permission).
- */
-export function isPlanFamily(category: string): boolean
-export function isPlanFamily(category: string | undefined): boolean
-export function isPlanFamily(category: string | undefined): boolean {
-  if (!category) return false
-  const lowerCategory = getAgentConfigKey(category).toLowerCase().trim()
-  return PLAN_FAMILY_NAMES.some((name) => lowerCategory === name)
-}

package/src/tools/delegate-task/delegated-model-config.ts

@@ -1,20 +0,0 @@
-import type { CategoryConfig } from "../../config/schema"
-import type { DelegatedModelConfig } from "./types"
-
-export function applyCategoryParams(
-  base: DelegatedModelConfig,
-  config: CategoryConfig | undefined,
-): DelegatedModelConfig {
-  if (!config) {
-    return base
-  }
-
-  return {
-    ...base,
-    ...(config.reasoningEffort !== undefined ? { reasoningEffort: config.reasoningEffort } : {}),
-    ...(config.temperature !== undefined ? { temperature: config.temperature } : {}),
-    ...(config.top_p !== undefined ? { top_p: config.top_p } : {}),
-    ...(config.maxTokens !== undefined ? { maxTokens: config.maxTokens } : {}),
-    ...(config.thinking !== undefined ? { thinking: config.thinking } : {}),
-  }
-}

package/src/tools/delegate-task/error-formatting.ts

@@ -1,51 +0,0 @@
-import type { DelegateTaskArgs } from "./types"
-
-/**
- * Context for error formatting.
- */
-export interface ErrorContext {
-  operation: string
-  args?: DelegateTaskArgs
-  sessionID?: string
-  agent?: string
-  category?: string
-}
-
-/**
- * Format an error with detailed context for debugging.
- */
-export function formatDetailedError(error: unknown, ctx: ErrorContext): string {
-  const message = error instanceof Error ? error.message : String(error)
-  const stack = error instanceof Error ? error.stack : undefined
-
-  const lines: string[] = [`${ctx.operation} failed`, "", `**Error**: ${message}`]
-
-  if (ctx.sessionID) {
-    lines.push(`**Session ID**: ${ctx.sessionID}`)
-  }
-
-  if (ctx.agent) {
-    lines.push(`**Agent**: ${ctx.agent}${ctx.category ? ` (category: ${ctx.category})` : ""}`)
-  }
-
-  if (ctx.args) {
-    lines.push("", "**Arguments**:")
-    lines.push(`- description: "${ctx.args.description}"`)
-    lines.push(`- category: ${ctx.args.category ?? "(none)"}`)
-    lines.push(`- subagent_type: ${ctx.args.subagent_type ?? "(none)"}`)
-    lines.push(`- run_in_background: ${ctx.args.run_in_background}`)
-    lines.push(`- load_skills: [${ctx.args.load_skills?.join(", ") ?? ""}]`)
-    if (ctx.args.session_id) {
-      lines.push(`- session_id: ${ctx.args.session_id}`)
-    }
-  }
-
-  if (stack) {
-    lines.push("", "**Stack Trace**:")
-    lines.push("```")
-    lines.push(stack.split("\n").slice(0, 10).join("\n"))
-    lines.push("```")
-  }
-
-  return lines.join("\n")
-}

package/src/tools/delegate-task/executor-types.ts

@@ -1,39 +0,0 @@
-import type { BackgroundManager } from "../../features/background-agent"
-import type { CategoriesConfig, GitMasterConfig, BrowserAutomationProvider, AgentOverrides, BobAgentConfig } from "../../config/schema"
-import type { OpencodeClient } from "./types"
-
-export interface ExecutorContext {
-  manager: BackgroundManager
-  client: OpencodeClient
-  directory: string
-  userCategories?: CategoriesConfig
-  gitMasterConfig?: GitMasterConfig
-  bobJuniorModel?: string
-  browserProvider?: BrowserAutomationProvider
-  agentOverrides?: AgentOverrides
-  bobAgentConfig?: BobAgentConfig
-  onSyncSessionCreated?: (event: { sessionID: string; parentID: string; title: string }) => Promise<void>
-  syncPollTimeoutMs?: number
-}
-
-export interface ParentContext {
-  sessionID: string
-  messageID: string
-  agent?: string
-  model?: { providerID: string; modelID: string; variant?: string }
-}
-
-export interface SessionMessage {
-  info?: {
-    id?: string
-    role?: string
-    time?: { created?: number }
-    finish?: string
-    agent?: string
-    model?: { providerID: string; modelID: string; variant?: string }
-    modelID?: string
-    providerID?: string
-    variant?: string
-  }
-  parts?: Array<{ type?: string; text?: string }>
-}

package/src/tools/delegate-task/executor.ts

@@ -1,16 +0,0 @@
-export type { ExecutorContext, ParentContext } from "./executor-types"
-
-export { resolveSkillContent } from "./skill-resolver"
-export { resolveParentContext } from "./parent-context-resolver"
-
-export { executeBackgroundContinuation } from "./background-continuation"
-export { executeSyncContinuation } from "./sync-continuation"
-
-export { executeUnstableAgentTask } from "./unstable-agent-task"
-export { executeBackgroundTask } from "./background-task"
-export { executeSyncTask } from "./sync-task"
-
-export { resolveCategoryExecution } from "./category-resolver"
-export type { CategoryResolutionResult } from "./category-resolver"
-
-export { resolveSubagentExecution } from "./subagent-resolver"

package/src/tools/delegate-task/fallback-entry-resolution.ts

@@ -1,27 +0,0 @@
-import { findMostSpecificFallbackEntry } from "../../shared/fallback-chain-from-models"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import type { DelegatedModelConfig } from "./types"
-
-export function resolveEffectiveFallbackEntry(input: {
-  categoryModel: DelegatedModelConfig | undefined
-  configuredFallbackChain: FallbackEntry[] | undefined
-  resolution:
-    | { skipped: true }
-    | { fallbackEntry?: FallbackEntry; matchedFallback?: boolean }
-    | undefined
-}): FallbackEntry | undefined {
-  const { categoryModel, configuredFallbackChain, resolution } = input
-
-  const resolutionSkipped = resolution && "skipped" in resolution
-  const resolvedFallbackEntry = resolution && !resolutionSkipped ? resolution.fallbackEntry : undefined
-  const matchedFallback = resolution && !resolutionSkipped ? resolution.matchedFallback === true : false
-
-  if (!matchedFallback || !categoryModel) {
-    return undefined
-  }
-
-  return resolvedFallbackEntry
-    ?? (configuredFallbackChain
-      ? findMostSpecificFallbackEntry(categoryModel.providerID, categoryModel.modelID, configuredFallbackChain)
-      : undefined)
-}

package/src/tools/delegate-task/fallback-entry-settings.ts

@@ -1,20 +0,0 @@
-import type { DelegatedModelConfig } from "./types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-
-export function applyFallbackEntrySettings(input: {
-  categoryModel: DelegatedModelConfig
-  effectiveEntry: FallbackEntry
-  variantOverride?: string
-}): DelegatedModelConfig {
-  const { categoryModel, effectiveEntry, variantOverride } = input
-
-  return {
-    ...categoryModel,
-    variant: variantOverride ?? effectiveEntry.variant ?? categoryModel.variant,
-    reasoningEffort: effectiveEntry.reasoningEffort ?? categoryModel.reasoningEffort,
-    temperature: effectiveEntry.temperature ?? categoryModel.temperature,
-    top_p: effectiveEntry.top_p ?? categoryModel.top_p,
-    maxTokens: effectiveEntry.maxTokens ?? categoryModel.maxTokens,
-    thinking: effectiveEntry.thinking ?? categoryModel.thinking,
-  }
-}

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

@@ -1,30 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const GIT_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on GIT / VERSION CONTROL tasks.
-
-<Routing_Policy>
-Executor contour: platform-manager (git operations specialist).
-</Routing_Policy>
-
-Git operations mindset:
-- Atomic commits with clear messages
-- Clean history: rebase/squash before push
-- Safe operations: never force-push to main/master
-- Clear handoff notes for session continuity
-
-Approach:
-- Understand the current branch state
-- Plan atomic commit strategy
-- Execute with minimal noise
-- Verify state after operation
-</Category_Context>`
-
-export const GIT_CATEGORIES: BuiltinCategoryDefinition[] = [
-  {
-    name: "git",
-    config: {},
-    description: "Git operations: commits, branching, history, rebasing. Uses platform-manager execution contour.",
-    promptAppend: GIT_CATEGORY_PROMPT_APPEND,
-  },
-]