@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/call-omo-agent/tools.ts

@@ -1,199 +0,0 @@
-import { tool, type PluginInput, type ToolDefinition } from "@opencode-ai/plugin"
-import {
-  CALL_OMO_AGENT_DESCRIPTION,
-  PRIMARY_ALLOWED_AGENTS,
-} from "./constants"
-import type { AllowedAgentType, CallOmoAgentArgs, ToolContextWithMetadata } from "./types"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { CategoriesConfig, AgentOverrides } from "../../config/schema"
-import type { DelegatedModelConfig } from "../../shared/model-resolution-types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
-import { getAgentConfigKey, stripInvisibleAgentCharacters } from "../../shared/agent-display-names"
-import { resolveCanonicalDelegateAgentKey } from "../../tools/delegate-task/sub-agent"
-import { normalizeFallbackModels } from "../../shared/model-resolver"
-import { buildFallbackChainFromModels } from "../../shared/fallback-chain-from-models"
-import { log } from "../../shared"
-import { CONFIG_BASENAME } from "../../shared/plugin-identity"
-import { parseModelString } from "../delegate-task/model-string-parser"
-import { executeBackground } from "./background-executor"
-import { executeSync } from "./sync-executor"
-import { resolveCallableAgents } from "./agent-resolver"
-
-function resolveModelAndFallbackChain(args: {
-  subagentType: string
-  agentOverrides?: AgentOverrides
-  userCategories?: CategoriesConfig
-}): { model: DelegatedModelConfig | undefined; fallbackChain: FallbackEntry[] | undefined } {
-  const { subagentType, agentOverrides, userCategories } = args
-  const agentConfigKey = getAgentConfigKey(subagentType)
-  const agentRequirement = AGENT_MODEL_REQUIREMENTS[agentConfigKey]
-
-  const agentOverride = agentOverrides?.[agentConfigKey as keyof AgentOverrides]
-    ?? (agentOverrides
-      ? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === agentConfigKey)?.[1]
-      : undefined)
-  const agentCategoryModel = agentOverride?.category
-    ? userCategories?.[agentOverride.category]?.model
-    : undefined
-  const agentCategoryVariant = agentOverride?.category
-    ? userCategories?.[agentOverride.category]?.variant
-    : undefined
-
-  let model: DelegatedModelConfig | undefined
-  if (agentOverride?.model) {
-    const normalized = parseModelString(agentOverride.model)
-    if (normalized) {
-      model = agentOverride.variant ? { ...normalized, variant: agentOverride.variant } : normalized
-      log("[call_omo_agent] Resolved model override from agent config", {
-        agent: subagentType,
-        model: agentOverride.model,
-        variant: agentOverride.variant,
-      })
-    }
-  } else if (agentCategoryModel) {
-    const normalized = parseModelString(agentCategoryModel)
-    if (normalized) {
-      const variantToUse = agentOverride?.variant ?? agentCategoryVariant
-      model = variantToUse ? { ...normalized, variant: variantToUse } : normalized
-      log("[call_omo_agent] Resolved model override from agent category", {
-        agent: subagentType,
-        category: agentOverride?.category,
-        model: agentCategoryModel,
-        variant: variantToUse,
-      })
-    }
-  }
-
-  const normalizedFallbackModels = normalizeFallbackModels(
-    agentOverride?.fallback_models
-    ?? (agentOverride?.category ? userCategories?.[agentOverride.category]?.fallback_models : undefined)
-  )
-  const defaultProviderID = model?.providerID
-    ?? agentRequirement?.fallbackChain?.[0]?.providers?.[0]
-    ?? "opencode"
-  const configuredFallbackChain = buildFallbackChainFromModels(normalizedFallbackModels, defaultProviderID)
-
-  return {
-    model,
-    fallbackChain: configuredFallbackChain ?? agentRequirement?.fallbackChain,
-  }
-}
-
-export function createCallOmoAgent(
-  ctx: PluginInput,
-  backgroundManager: BackgroundManager,
-  disabledAgents: string[] = [],
-  agentOverrides?: AgentOverrides,
-  userCategories?: CategoriesConfig,
-): ToolDefinition {
-  const primaryAgentDescriptions = PRIMARY_ALLOWED_AGENTS.map((name) => {
-    switch (name) {
-      case "researcher":
-        return "- researcher: Canonical agent for codebase exploration and research";
-      case "strategist":
-        return "- strategist: Canonical agent for planning and reasoning";
-      case "coder":
-        return "- coder: Canonical agent for implementation work";
-      case "critic":
-        return "- critic: Canonical agent for review and verification";
-      case "designer":
-        return "- designer: Canonical agent for visual direction, interface design, and creative execution";
-      case "brainstormer":
-        return "- brainstormer: Canonical agent for ideation, option generation, and concept exploration";
-      case "platform-manager":
-        return "- platform-manager: Canonical agent for project setup, continuity, and platform management tasks";
-      case "multimodal":
-        return "- multimodal: Canonical agent for visual and multimodal tasks (runtime display name: Vision)";
-    }
-  }).join("\n");
-
-  const description = CALL_OMO_AGENT_DESCRIPTION.replace(
-    "{primary_agents}",
-    primaryAgentDescriptions,
-  );
-
-  return tool({
-    description,
-    args: {
-      description: tool.schema
-        .string()
-        .describe("A short (3-5 words) description of the task"),
-      prompt: tool.schema
-        .string()
-        .describe("The task for the agent to perform"),
-      subagent_type: tool.schema
-        .string()
-        .describe(
-          "The agent to invoke. Canonical names are preferred; compatibility aliases and custom agents are also accepted.",
-        ),
-      run_in_background: tool.schema
-        .boolean()
-        .describe(
-          "REQUIRED. true: run asynchronously (use background_output to get results), false: run synchronously and wait for completion",
-        ),
-      session_id: tool.schema
-        .string()
-        .describe("Existing Task session to continue")
-        .optional(),
-    },
-    async execute(args: CallOmoAgentArgs, toolContext) {
-      const toolCtx = toolContext as ToolContextWithMetadata;
-      log(
-        `[call_omo_agent] DEPRECATED: call_omo_agent is deprecated. Use task(agent="...", load_skills=[], run_in_background=...) instead.`,
-      );
-
-      const callableAgents = await resolveCallableAgents(ctx.client);
-
-      // Strip ZWSP and case-insensitive agent validation - allows canonical names and compatibility aliases.
-      const strippedAgentType = stripInvisibleAgentCharacters(args.subagent_type)
-      const preCanonicalAgentType = getAgentConfigKey(strippedAgentType)
-      const canonicalAgentType = resolveCanonicalDelegateAgentKey(preCanonicalAgentType)
-      const wasLegacyAlias = canonicalAgentType !== preCanonicalAgentType.toLowerCase()
-      if (wasLegacyAlias) {
-        log("[call_omo_agent] Legacy agent alias resolved", { from: preCanonicalAgentType, to: canonicalAgentType })
-      }
-      if (
-        !callableAgents.some(
-          (name) => name.toLowerCase() === canonicalAgentType.toLowerCase(),
-        )
-      ) {
-        return `Error: Invalid agent type "${args.subagent_type}". Available agents: ${callableAgents.join(", ")}. Legacy aliases: oracle→strategist, hephaestus→coder, metis→strategist, momus→critic, sisyphus-junior→sub, multimodal-looker→multimodal, librarian→researcher, explore→researcher.`;
-      }
-
-      const normalizedAgent = canonicalAgentType.toLowerCase();
-      args = { ...args, subagent_type: normalizedAgent };
-
-      // Check if agent is disabled
-      if (disabledAgents.some((disabled) => stripInvisibleAgentCharacters(disabled).toLowerCase() === normalizedAgent)) {
-        return `Error: Agent "${normalizedAgent}" is disabled via disabled_agents configuration. Remove it from disabled_agents in your ${CONFIG_BASENAME}.json to use it.`
-      }
-
-      const { model: resolvedModel, fallbackChain } = resolveModelAndFallbackChain({
-        subagentType: args.subagent_type,
-        agentOverrides,
-        userCategories,
-      })
-
-      if (args.run_in_background) {
-        if (args.session_id) {
-          return `Error: session_id is not supported in background mode. Use run_in_background=false to continue an existing session.`;
-        }
-        return await executeBackground(args, toolCtx, backgroundManager, ctx.client, fallbackChain, resolvedModel)
-      }
-
-      if (!args.session_id) {
-        let spawnReservation: Awaited<ReturnType<BackgroundManager["reserveSubagentSpawn"]>> | undefined
-        try {
-          spawnReservation = await backgroundManager.reserveSubagentSpawn(toolCtx.sessionID)
-          return await executeSync(args, toolCtx, ctx, undefined, fallbackChain, spawnReservation, resolvedModel)
-        } catch (error) {
-          spawnReservation?.rollback()
-          return `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      }
-
-      return await executeSync(args, toolCtx, ctx, undefined, fallbackChain, undefined, resolvedModel)
-    },
-  });
-}

package/src/tools/call-omo-agent/types.ts

@@ -1,34 +0,0 @@
-import type { ALLOWED_AGENTS } from "./constants"
-
-export type AllowedAgentType = (typeof ALLOWED_AGENTS)[number]
-
-export interface CallOmoAgentArgs {
-  description: string
-  prompt: string
-  subagent_type: string
-  run_in_background: boolean
-  session_id?: string
-}
-
-export interface CallOmoAgentSyncResult {
-  title: string
-  metadata: {
-    summary?: Array<{
-      id: string
-      tool: string
-      state: {
-        status: string
-        title?: string
-      }
-    }>
-    sessionId: string
-  }
-  output: string
-}
-export type ToolContextWithMetadata = {
-  sessionID: string
-  messageID: string
-  agent: string
-  abort: AbortSignal
-  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-}

package/src/tools/delegate-task/AGENTS.md

@@ -1,58 +0,0 @@
-# src/tools/delegate-task/ — Task Delegation Engine
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-49 files. The `task` tool implementation — delegates work to subagents via background or sync sessions. Resolves categories, models, skills, and manages both async and synchronous execution flows. 8+ built-in categories.
-
-## TWO EXECUTION MODES
-
-| Mode | Flow | Use Case |
-|------|------|----------|
-| **Background** (`run_in_background=true`) | Launch → BackgroundManager → poll → notify parent | Explore, librarian, parallel work |
-| **Sync** (`run_in_background=false`) | Create session → send prompt → poll until idle → return result | Sequential tasks needing immediate result |
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `tools.ts` | `createDelegateTask()` factory — main entry point |
-| `executor.ts` | Route to background or sync execution |
-| `types.ts` | `DelegateTaskArgs`, `DelegateTaskToolOptions`, `ToolContextWithMetadata` |
-| `category-resolver.ts` | Map category name → model + config |
-| `subagent-resolver.ts` | Map subagent_type → agent + model |
-| `model-selection.ts` | Model availability checking + fallback |
-| `skill-resolver.ts` | Resolve `load_skills[]` → skill content for injection |
-| `prompt-builder.ts` | Build system/user prompt with skill content, categories |
-
-## SYNC EXECUTION CHAIN
-
-```
-sync-task.ts → sync-session-creator.ts → sync-prompt-sender.ts → sync-session-poller.ts → sync-result-fetcher.ts
-```
-
-Each file handles one step. `sync-continuation.ts` handles session continuation (resume with session_id).
-
-## BACKGROUND EXECUTION
-
-```
-background-task.ts → BackgroundManager.launch() → (async polling) → background-continuation.ts
-```
-
-`background-continuation.ts` handles `session_id` resume for existing background tasks.
-
-## CATEGORY RESOLUTION
-
-1. Check user-defined categories (`pluginConfig.categories`)
-2. Fall back to built-in 8 categories
-3. Resolve model from category config
-4. Check model availability → fallback if unavailable
-
-## MODEL STRING PARSER
-
-`model-string-parser.ts` handles `"model variant"` format (e.g., `"gpt-5.3-codex medium"` → model=`gpt-5.3-codex`, variant=`medium`).
-
-## UNSTABLE AGENT TRACKING
-
-`unstable-agent-task.ts` marks tasks from categories/agents known to be unstable (e.g., free models). Enables `unstableAgentBabysitter` hook monitoring.

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

@@ -1,62 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on tasks that don't fit specific categories but require moderate effort.
-
-<Routing_Policy>
-Executor contour: sub (cheap fast-tier executor). Keep the scope bounded unless the task clearly requires deep or cross-system work; in that case escalate to unspecified-high or deep.
-</Routing_Policy>
-
-<Selection_Gate>
-BEFORE selecting this category, VERIFY ALL conditions:
-1. Task does NOT fit: quick (trivial), visual-engineering (UI), ultrabrain (deep logic), artistry (creative), writing (docs)
-2. Task requires more than trivial effort but is NOT system-wide
-3. Scope is contained within a few files/modules
-
-If task fits ANY other category, DO NOT select unspecified-low.
-This is NOT a default choice - it's for genuinely unclassifiable moderate-effort work.
-</Selection_Gate>
-</Category_Context>
-
-<Caller_Warning>
-THIS CATEGORY USES A MID-TIER MODEL (the selected mid-tier model).
-
-**PROVIDE CLEAR STRUCTURE:**
-1. MUST DO: Enumerate required actions explicitly
-2. MUST NOT DO: State forbidden actions to prevent scope creep
-3. EXPECTED OUTPUT: Define concrete success criteria
-</Caller_Warning>`
-
-const UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on tasks that don't fit specific categories but require substantial effort.
-
-<Routing_Policy>
-Executor contour: coder (deep execution). Use only when substantial, cross-module effort is justified.
-</Routing_Policy>
-
-<Selection_Gate>
-BEFORE selecting this category, VERIFY ALL conditions:
-1. Task does NOT fit: quick (trivial), visual-engineering (UI), ultrabrain (deep logic), artistry (creative), writing (docs)
-2. Task requires substantial effort across multiple systems/modules
-3. Changes have broad impact or require careful coordination
-4. NOT just "complex" - must be genuinely unclassifiable AND high-effort
-
-If task fits ANY other category, DO NOT select unspecified-high.
-If task is unclassifiable but moderate-effort, use unspecified-low instead.
-</Selection_Gate>
-</Category_Context>`
-
-export const ANTHROPIC_CATEGORIES: BuiltinCategoryDefinition[] = [
-  {
-    name: "unspecified-low",
-    config: {},
-    description: "Unclassifiable moderate tasks with bounded scope. Uses sub (cheap fast-tier) execution contour.",
-    promptAppend: UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND,
-  },
-  {
-    name: "unspecified-high",
-    config: {},
-    description: "Unclassifiable substantial tasks across modules. Uses coder (deep execution) with max-variant model.",
-    promptAppend: UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND,
-  },
-]

package/src/tools/delegate-task/available-models.ts

@@ -1,64 +0,0 @@
-import type { OpencodeClient } from "./types"
-import { log } from "../../shared/logger"
-import { readConnectedProvidersCache, readProviderModelsCache } from "../../shared/connected-providers-cache"
-
-function addFromProviderModels(
-  out: Set<string>,
-  providerID: string,
-  models: Array<string | { id?: string }> | undefined
-): void {
-  if (!models) return
-  for (const item of models) {
-    const modelID = typeof item === "string" ? item : item?.id
-    if (!modelID) continue
-    out.add(`${providerID}/${modelID}`)
-  }
-}
-
-export async function getAvailableModelsForDelegateTask(client: OpencodeClient): Promise<Set<string>> {
-  const providerModelsCache = readProviderModelsCache()
-
-  if (providerModelsCache?.models) {
-    const connected = new Set(providerModelsCache.connected)
-
-    const out = new Set<string>()
-    for (const [providerID, models] of Object.entries(providerModelsCache.models)) {
-      if (!connected.has(providerID)) continue
-      addFromProviderModels(out, providerID, models as Array<string | { id?: string }> | undefined)
-    }
-    return out
-  }
-
-  const connectedProviders = readConnectedProvidersCache()
-
-  if (!connectedProviders || connectedProviders.length === 0) {
-    return new Set()
-  }
-
-  const modelList = (client as unknown as { model?: { list?: () => Promise<unknown> } })
-    ?.model
-    ?.list
-
-  if (!modelList) {
-    return new Set()
-  }
-
-  try {
-    const result = await modelList()
-    const rows = Array.isArray(result)
-      ? result
-      : ((result as { data?: unknown }).data as Array<{ provider?: string; id?: string }> | undefined) ?? []
-
-    const connected = new Set(connectedProviders)
-    const out = new Set<string>()
-    for (const row of rows) {
-      if (!row?.provider || !row?.id) continue
-      if (!connected.has(row.provider)) continue
-      out.add(`${row.provider}/${row.id}`)
-    }
-    return out
-  } catch (err) {
-    log("[delegate-task] client.model.list failed", { error: String(err) })
-    return new Set()
-  }
-}

package/src/tools/delegate-task/background-continuation.ts

@@ -1,68 +0,0 @@
-import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types"
-import type { ExecutorContext, ParentContext } from "./executor-types"
-import { storeToolMetadata } from "../../features/tool-metadata-store"
-import { formatDetailedError } from "./error-formatting"
-import { getSessionTools } from "../../shared/session-tools-store"
-import { resolveCallID } from "./resolve-call-id"
-
-export async function executeBackgroundContinuation(
-  args: DelegateTaskArgs,
-  ctx: ToolContextWithMetadata,
-  executorCtx: ExecutorContext,
-  parentContext: ParentContext
-): Promise<string> {
-  const { manager } = executorCtx
-
-  try {
-    const task = await manager.resume({
-      sessionId: args.session_id!,
-      prompt: args.prompt,
-      parentSessionID: parentContext.sessionID,
-      parentMessageID: parentContext.messageID,
-      parentModel: parentContext.model,
-      parentAgent: parentContext.agent,
-      parentTools: getSessionTools(parentContext.sessionID),
-    })
-
-    const bgContMeta = {
-      title: `Continue: ${task.description}`,
-      metadata: {
-        prompt: args.prompt,
-        agent: task.agent,
-        load_skills: args.load_skills,
-        description: args.description,
-        run_in_background: args.run_in_background,
-        sessionId: task.sessionID,
-        command: args.command,
-        model: task.model ? { providerID: task.model.providerID, modelID: task.model.modelID } : undefined,
-      },
-    }
-    await ctx.metadata?.(bgContMeta)
-    const callID = resolveCallID(ctx)
-    if (callID) {
-      storeToolMetadata(ctx.sessionID, callID, bgContMeta)
-    }
-
-    return `Background task continued.
-
-Task ID: ${task.id}
-Description: ${task.description}
-Agent: ${task.agent}
-Status: ${task.status}
-
-Agent continues with full previous context preserved.
-System notifies on completion. Use \`background_output\` with task_id="${task.id}" to check.
-
-Do NOT call background_output now. Wait for <system-reminder> notification first.
-
-<task_metadata>
-session_id: ${task.sessionID}
-${task.agent ? `subagent: ${task.agent}\n` : ""}</task_metadata>`
-  } catch (error) {
-    return formatDetailedError(error, {
-      operation: "Continue background task",
-      args,
-      sessionID: args.session_id,
-    })
-  }
-}

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

@@ -1,165 +0,0 @@
-import type { DelegateTaskArgs, ToolContextWithMetadata, DelegatedModelConfig } from "./types"
-import type { ExecutorContext, ParentContext } from "./executor-types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { getTimingConfig } from "./timing"
-import { buildTaskPrompt } from "./prompt-builder"
-import { storeToolMetadata } from "../../features/tool-metadata-store"
-import { resolveCallID } from "./resolve-call-id"
-import { formatDetailedError } from "./error-formatting"
-import { getSessionTools } from "../../shared/session-tools-store"
-import { SessionCategoryRegistry } from "../../shared/session-category-registry"
-import { QUESTION_DENIED_SESSION_PERMISSION } from "../../shared/question-denied-session-permission"
-import { setSessionFallbackChain } from "../../hooks/model-fallback/hook"
-import { stripAgentListSortPrefix } from "../../shared/agent-display-names"
-
-function continueSessionSetup(args: {
-  taskID: string
-  manager: ExecutorContext["manager"]
-  timing: ReturnType<typeof getTimingConfig>
-  fallbackChain?: FallbackEntry[]
-  category?: string
-}): void {
-  if (!args.fallbackChain && !args.category) {
-    return
-  }
-
-  void (async () => {
-    const waitStart = Date.now()
-    while (Date.now() - waitStart < args.timing.WAIT_FOR_SESSION_TIMEOUT_MS) {
-      await new Promise(resolve => setTimeout(resolve, args.timing.WAIT_FOR_SESSION_INTERVAL_MS))
-      const updated = args.manager.getTask(args.taskID)
-      if (!updated) {
-        return
-      }
-      if (updated.status === "error" || updated.status === "cancelled" || updated.status === "interrupt") {
-        return
-      }
-
-      const sessionId = updated.sessionID
-      if (!sessionId) {
-        continue
-      }
-
-      setSessionFallbackChain(sessionId, args.fallbackChain)
-      if (args.category) {
-        SessionCategoryRegistry.register(sessionId, args.category)
-      }
-      return
-    }
-  })()
-}
-
-export async function executeBackgroundTask(
-  args: DelegateTaskArgs,
-  ctx: ToolContextWithMetadata,
-  executorCtx: ExecutorContext,
-  parentContext: ParentContext,
-  agentToUse: string,
-  categoryModel: DelegatedModelConfig | undefined,
-  systemContent: string | undefined,
-  fallbackChain?: FallbackEntry[],
-): Promise<string> {
-  const { manager } = executorCtx
-
-  try {
-    const tddEnabled = executorCtx.bobAgentConfig?.tdd
-    const normalizedAgent = stripAgentListSortPrefix(agentToUse)
-    const effectivePrompt = buildTaskPrompt(args.prompt, normalizedAgent, tddEnabled)
-    const task = await manager.launch({
-      description: args.description,
-      prompt: effectivePrompt,
-      agent: normalizedAgent,
-      parentSessionID: parentContext.sessionID,
-      parentMessageID: parentContext.messageID,
-      parentModel: parentContext.model,
-      parentAgent: parentContext.agent,
-      parentTools: getSessionTools(parentContext.sessionID),
-      model: categoryModel,
-      fallbackChain,
-      skills: args.load_skills.length > 0 ? args.load_skills : undefined,
-      skillContent: systemContent,
-      category: args.category,
-      sessionPermission: QUESTION_DENIED_SESSION_PERMISSION,
-    })
-
-    // OpenCode TUI's `Task` tool UI calculates toolcalls by looking up
-    // `props.metadata.sessionId` and then counting tool parts in that session.
-    // BackgroundManager.launch() returns immediately (pending) before the session exists,
-    // so we must wait briefly for the session to be created to set metadata correctly.
-    const timing = getTimingConfig()
-    const waitStart = Date.now()
-    let sessionId = task.sessionID
-    while (!sessionId && Date.now() - waitStart < timing.WAIT_FOR_SESSION_TIMEOUT_MS) {
-      const updated = manager.getTask(task.id)
-      if (updated?.status === "error" || updated?.status === "cancelled" || updated?.status === "interrupt") {
-        return `Task failed to start (status: ${updated.status}).\n\nTask ID: ${task.id}`
-      }
-      sessionId = updated?.sessionID
-      if (sessionId) {
-        break
-      }
-      if (ctx.abort?.aborted) {
-        continueSessionSetup({
-          taskID: task.id,
-          manager,
-          timing,
-          fallbackChain,
-          category: args.category,
-        })
-        break
-      }
-      await new Promise(resolve => setTimeout(resolve, timing.WAIT_FOR_SESSION_INTERVAL_MS))
-    }
-
-    if (sessionId) {
-      setSessionFallbackChain(sessionId, fallbackChain)
-    }
-    if (args.category && sessionId) {
-      SessionCategoryRegistry.register(sessionId, args.category)
-    }
-
-    const metadata = {
-      prompt: args.prompt,
-      agent: task.agent,
-      category: args.category,
-      load_skills: args.load_skills,
-      description: args.description,
-      run_in_background: args.run_in_background,
-      command: args.command,
-      ...(sessionId ? { sessionId } : {}),
-      ...(categoryModel ? { model: { providerID: categoryModel.providerID, modelID: categoryModel.modelID } } : {}),
-    }
-
-    const unstableMeta = {
-      title: args.description,
-      metadata,
-    }
-    await ctx.metadata?.(unstableMeta)
-    const callID = resolveCallID(ctx)
-    if (callID) {
-      storeToolMetadata(ctx.sessionID, callID, unstableMeta)
-    }
-
-    const taskMetadataBlock = sessionId
-      ? `\n\n<task_metadata>\nsession_id: ${sessionId}\ntask_id: ${task.id}\nbackground_task_id: ${task.id}\n</task_metadata>`
-      : ""
-
-    return `Background task launched.
-
-Background Task ID: ${task.id}
-Description: ${task.description}
-Agent: ${task.agent}${args.category ? ` (category: ${args.category})` : ""}
-Status: ${task.status}
-
-System notifies on completion. Use \`background_output\` with task_id="${task.id}" to check.
-
-Do NOT call background_output now. Wait for <system-reminder> notification first.${taskMetadataBlock}`
-  } catch (error) {
-    return formatDetailedError(error, {
-      operation: "Launch background task",
-      args,
-      agent: stripAgentListSortPrefix(agentToUse),
-      category: args.category,
-    })
-  }
-}

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

@@ -1,35 +0,0 @@
-import type { CategoryConfig } from "../../config/schema"
-import { ANTHROPIC_CATEGORIES } from "./anthropic-categories"
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-import { GIT_CATEGORIES } from "./git-categories"
-import { GOOGLE_CATEGORIES } from "./google-categories"
-import { KIMI_CATEGORIES } from "./kimi-categories"
-import { OPENAI_CATEGORIES } from "./openai-categories"
-
-const BUILTIN_CATEGORIES: BuiltinCategoryDefinition[] = [
-  ...GOOGLE_CATEGORIES,
-  ...OPENAI_CATEGORIES,
-  ...ANTHROPIC_CATEGORIES,
-  ...KIMI_CATEGORIES,
-  ...GIT_CATEGORIES,
-]
-
-function buildCategoryRecord<TValue>(
-  selector: (definition: BuiltinCategoryDefinition) => TValue
-): Record<string, TValue> {
-  return Object.fromEntries(
-    BUILTIN_CATEGORIES.map((definition) => [definition.name, selector(definition)])
-  )
-}
-
-export const DEFAULT_CATEGORIES: Record<string, CategoryConfig> = buildCategoryRecord(
-  (definition) => definition.config
-)
-
-export const CATEGORY_PROMPT_APPENDS: Record<string, string> = buildCategoryRecord(
-  (definition) => definition.promptAppend
-)
-
-export const CATEGORY_DESCRIPTIONS: Record<string, string> = buildCategoryRecord(
-  (definition) => definition.description
-)