@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

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

@@ -1,130 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const VISUAL_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on VISUAL/UI tasks.
-
-<Routing_Policy>
-Executor contour: coder (deep execution). This category is not for cheap bounded edits.
-</Routing_Policy>
-
-<DESIGN_SYSTEM_WORKFLOW_MANDATE>
-## YOU ARE A VISUAL ENGINEER. FOLLOW THIS WORKFLOW OR YOUR OUTPUT IS REJECTED.
-
-**YOUR FAILURE MODE**: You skip design system analysis and jump straight to writing components with hardcoded colors, arbitrary spacing, and ad-hoc font sizes. The result is INCONSISTENT GARBAGE that looks like 5 different people built it. THIS STOPS NOW.
-
-**EVERY visual task follows this EXACT workflow. VIOLATION = BROKEN OUTPUT.**
-
-### PHASE 1: ANALYZE THE DESIGN SYSTEM (MANDATORY FIRST ACTION)
-
-**BEFORE writing a SINGLE line of CSS, HTML, JSX, Svelte, or component code - you MUST:**
-
-1. **SEARCH for the design system.** Use Grep, Glob, Read - actually LOOK:
-   - Design tokens: colors, spacing, typography, shadows, border-radii
-   - Theme files: CSS variables, Tailwind config, \`theme.ts\`, styled-components theme, design tokens file
-   - Shared/base components: Button, Card, Input, Layout primitives
-   - Existing UI patterns: How are pages structured? What spacing grid? What color usage?
-
-2. **READ at minimum 5-10 existing UI components.** Understand:
-   - Naming conventions (BEM? Atomic? Utility-first? Component-scoped?)
-   - Spacing system (4px grid? 8px? Tailwind scale? CSS variables?)
-   - Color usage (semantic tokens? Direct hex? Theme references?)
-   - Typography scale (heading levels, body, caption - how many? What font stack?)
-   - Component composition patterns (slots? children? compound components?)
-
-**DO NOT proceed to Phase 2 until you can answer ALL of these. If you cannot, you have not explored enough. EXPLORE MORE.**
-
-### PHASE 2: NO DESIGN SYSTEM? BUILD ONE. NOW.
-
-If Phase 1 reveals NO coherent design system (or scattered, inconsistent patterns):
-
-1. **STOP. Do NOT build the requested UI yet.**
-2. **Extract what exists** - even inconsistent patterns have salvageable decisions.
-3. **Create a minimal design system FIRST:**
-   - Color palette: primary, secondary, neutral, semantic (success/warning/error/info)
-   - Typography scale: heading levels (h1-h4 minimum), body, small, caption
-   - Spacing scale: consistent increments (4px or 8px base)
-   - Border radii, shadows, transitions - systematic, not random
-   - Component primitives: the reusable building blocks
-4. **Commit/save the design system, THEN proceed to Phase 3.**
-
-A design system is NOT optional overhead. It is the FOUNDATION. Building UI without one is like building a house on sand. It WILL collapse into inconsistency.
-
-### PHASE 3: BUILD WITH THE SYSTEM. NEVER AROUND IT.
-
-**NOW and ONLY NOW** - implement the requested visual work:
-
-| Element | CORRECT | WRONG (WILL BE REJECTED) |
-|---------|---------|--------------------------|
-| Color | Design token / CSS variable | Hardcoded \`#3b82f6\`, \`rgb(59,130,246)\` |
-| Spacing | System value (\`space-4\`, \`gap-md\`, \`var(--spacing-4)\`) | Arbitrary \`margin: 13px\`, \`padding: 7px\` |
-| Typography | Scale value (\`text-lg\`, \`heading-2\`, token) | Ad-hoc \`font-size: 17px\` |
-| Component | Extend/compose from existing primitives | One-off div soup with inline styles |
-| Border radius | System token | Random \`border-radius: 6px\` |
-
-**IF the design requires something OUTSIDE the current system:**
-- **Extend the system FIRST** - add the new token/primitive
-- **THEN use the new token** in your component
-- **NEVER one-off override.** That is how design systems die.
-
-### PHASE 4: VERIFY BEFORE CLAIMING DONE
-
-BEFORE reporting visual work as complete, answer these:
-
-- [ ] Does EVERY color reference a design token or CSS variable?
-- [ ] Does EVERY spacing use the system scale?
-- [ ] Does EVERY component follow the existing composition pattern?
-- [ ] Would a designer see CONSISTENCY across old and new components?
-- [ ] Are there ZERO hardcoded magic numbers for visual properties?
-
-**If ANY answer is NO - FIX IT. You are NOT done.**
-
-</DESIGN_SYSTEM_WORKFLOW_MANDATE>
-
-<DESIGN_QUALITY>
-Design-first mindset (AFTER design system is established):
-- Bold aesthetic choices over safe defaults
-- Unexpected layouts, asymmetry, grid-breaking elements
-- Distinctive typography (avoid: Arial, Inter, Roboto, Space Grotesk)
-- Cohesive color palettes with sharp accents
-- High-impact animations with staggered reveals
-- Atmosphere: gradient meshes, noise textures, layered transparencies
-
-AVOID: Generic fonts, purple gradients on white, predictable layouts, cookie-cutter patterns.
-</DESIGN_QUALITY>
-</Category_Context>`
-
-const ARTISTRY_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on HIGHLY CREATIVE / ARTISTIC tasks.
-
-<Routing_Policy>
-Executor contour: coder (deep execution). Reserve for high-effort creative work.
-</Routing_Policy>
-
-Artistic genius mindset:
-- Push far beyond conventional boundaries
-- Explore radical, unconventional directions
-- Surprise and delight: unexpected twists, novel combinations
-- Rich detail and vivid expression
-- Break patterns deliberately when it serves the creative vision
-
-Approach:
-- Generate diverse, bold options first
-- Embrace ambiguity and wild experimentation
-- Balance novelty with coherence
-- This is for tasks requiring exceptional creativity
-</Category_Context>`
-
-export const GOOGLE_CATEGORIES: BuiltinCategoryDefinition[] = [
-  {
-    name: "visual-engineering",
-    config: {},
-    description: "Frontend and UI systems work with design-system discipline. Uses coder execution contour.",
-    promptAppend: VISUAL_CATEGORY_PROMPT_APPEND,
-  },
-  {
-    name: "artistry",
-    config: {},
-    description: "High-effort creative problem solving beyond standard patterns. Uses coder execution contour.",
-    promptAppend: ARTISTRY_CATEGORY_PROMPT_APPEND,
-  },
-]

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

@@ -1,4 +0,0 @@
-export { createDelegateTask, resolveCategoryConfig, buildSystemContent, buildTaskPrompt } from "./tools"
-export type { DelegateTaskToolOptions, SyncSessionCreatedEvent, BuildSystemContentInput } from "./tools"
-export type * from "./types"
-export * from "./constants"

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

@@ -1,40 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const WRITING_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on WRITING / PROSE tasks.
-
-<Routing_Policy>
-Executor contour: coder (fast bounded execution) for focused docs and prose updates.
-</Routing_Policy>
-
-Wordsmith mindset:
-- Clear, flowing prose
-- Appropriate tone and voice
-- Engaging and readable
-- Proper structure and organization
-
-Approach:
-- Understand the audience
-- Draft with care
-- Polish for clarity and impact
-- Documentation, READMEs, articles, technical writing
-
-ANTI-AI-SLOP RULES (NON-NEGOTIABLE):
-- NEVER use em dashes (-) or en dashes (-). Use commas, periods, ellipses, or line breaks instead. Zero tolerance.
-- Remove AI-sounding phrases: "delve", "it's important to note", "I'd be happy to", "certainly", "please don't hesitate", "leverage", "utilize", "in order to", "moving forward", "circle back", "at the end of the day", "robust", "streamline", "facilitate"
-- Pick plain words. "Use" not "utilize". "Start" not "commence". "Help" not "facilitate".
-- Use contractions naturally: "don't" not "do not", "it's" not "it is".
-- Vary sentence length. Don't make every sentence the same length.
-- NEVER start consecutive sentences with the same word.
-- No filler openings: skip "In today's world...", "As we all know...", "It goes without saying..."
-- Write like a human, not a corporate template.
-</Category_Context>`
-
-export const KIMI_CATEGORIES: BuiltinCategoryDefinition[] = [
-  {
-    name: "writing",
-    config: {},
-    description: "Documentation and prose tasks with bounded scope. Uses coder execution contour.",
-    promptAppend: WRITING_CATEGORY_PROMPT_APPEND,
-  },
-]

package/src/tools/delegate-task/model-selection.ts

@@ -1,201 +0,0 @@
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { normalizeModel } from "../../shared/model-normalization"
-import { fuzzyMatchModel } from "../../shared/model-availability"
-import { transformModelForProvider } from "../../shared/provider-model-id-transform"
-import { hasConnectedProvidersCache, hasProviderModelsCache, readConnectedProvidersCache } from "../../shared/connected-providers-cache"
-import { log } from "../../shared/logger"
-import { parseModelString, parseVariantFromModelID } from "./model-string-parser"
-
-function isExplicitHighModel(model: string): boolean {
-  return /(?:^|\/)[^/]+-high$/.test(model)
-}
-
-function getExplicitHighBaseModel(model: string): string | null {
-  return isExplicitHighModel(model) ? model.replace(/-high$/, "") : null
-}
-
-function parseUserFallbackModel(fallbackModel: string): {
-  baseModel: string
-  providerHint?: string[]
-  variant?: string
-} | undefined {
-  const normalizedFallback = normalizeModel(fallbackModel)
-  if (!normalizedFallback) {
-    return undefined
-  }
-
-  const parsedFullModel = parseModelString(normalizedFallback)
-  if (parsedFullModel) {
-    return {
-      baseModel: `${parsedFullModel.providerID}/${parsedFullModel.modelID}`,
-      providerHint: [parsedFullModel.providerID],
-      variant: parsedFullModel.variant,
-    }
-  }
-
-  const parsedModel = parseVariantFromModelID(normalizedFallback)
-  if (!parsedModel.modelID) {
-    return undefined
-  }
-
-  return {
-    baseModel: parsedModel.modelID,
-    variant: parsedModel.variant,
-  }
-}
-
-
-export function resolveModelForDelegateTask(input: {
-  userModel?: string
-  userFallbackModels?: string[]
-  categoryDefaultModel?: string
-  isUserConfiguredCategoryModel?: boolean
-  fallbackChain?: FallbackEntry[]
-  availableModels: Set<string>
-  systemDefaultModel?: string
-}): { model: string; variant?: string; fallbackEntry?: FallbackEntry; matchedFallback?: boolean } | { skipped: true } | undefined {
-  const userModel = normalizeModel(input.userModel)
-  if (userModel) {
-    const parsed = parseUserFallbackModel(userModel)
-    if (parsed?.variant) {
-      return { model: parsed.baseModel, variant: parsed.variant }
-    }
-    return { model: userModel }
-  }
-
-  const connectedProviders = input.availableModels.size === 0 ? readConnectedProvidersCache() : null
-
-  // Before provider cache is created (first run), skip model resolution entirely.
-  // OpenCode will use its system default model when no model is specified in the prompt.
-  if (input.availableModels.size === 0 && !hasProviderModelsCache() && !hasConnectedProvidersCache()) {
-    return { skipped: true }
-  }
-
-  const categoryDefault = normalizeModel(input.categoryDefaultModel)
-  const explicitHighBaseModel = categoryDefault ? getExplicitHighBaseModel(categoryDefault) : null
-  const explicitHighModel = explicitHighBaseModel ? categoryDefault : undefined
-  if (categoryDefault) {
-    if (input.isUserConfiguredCategoryModel) {
-      log("[resolveModelForDelegateTask] using user-configured category model (bypass validation)", {
-        categoryDefaultModel: categoryDefault,
-      })
-      const parsed = parseUserFallbackModel(categoryDefault)
-      if (parsed?.variant) {
-        return { model: parsed.baseModel, variant: parsed.variant }
-      }
-      return { model: categoryDefault }
-    }
-
-    if (input.availableModels.size === 0) {
-      const categoryProvider = categoryDefault.includes("/") ? categoryDefault.split("/")[0] : undefined
-      if (!connectedProviders || !categoryProvider || connectedProviders.includes(categoryProvider)) {
-        return { model: categoryDefault }
-      }
-
-      log("[resolveModelForDelegateTask] skipping disconnected category default on cold cache", {
-        categoryDefault,
-        connectedProviders,
-      })
-    }
-
-    const parts = categoryDefault.split("/")
-    const providerHint = parts.length >= 2 ? [parts[0]] : undefined
-    const match = fuzzyMatchModel(categoryDefault, input.availableModels, providerHint)
-    if (match) {
-      if (isExplicitHighModel(categoryDefault) && match !== categoryDefault) {
-        return { model: categoryDefault }
-      }
-
-      return { model: match }
-    }
-  }
-
-  const userFallbackModels = input.userFallbackModels
-  if (userFallbackModels && userFallbackModels.length > 0) {
-    if (input.availableModels.size === 0) {
-      for (const fallbackModel of userFallbackModels) {
-        const parsedFallback = parseUserFallbackModel(fallbackModel)
-        if (!parsedFallback) continue
-
-        if (
-          connectedProviders &&
-          parsedFallback.providerHint &&
-          !parsedFallback.providerHint.some((provider) => connectedProviders.includes(provider))
-        ) {
-          continue
-        }
-
-        return { model: parsedFallback.baseModel, variant: parsedFallback.variant, matchedFallback: true }
-      }
-    } else {
-      for (const fallbackModel of userFallbackModels) {
-        const parsedFallback = parseUserFallbackModel(fallbackModel)
-        if (!parsedFallback) continue
-
-        const match = fuzzyMatchModel(parsedFallback.baseModel, input.availableModels, parsedFallback.providerHint)
-        if (match) {
-          return { model: match, variant: parsedFallback.variant, matchedFallback: true }
-        }
-      }
-    }
-  }
-
-  const fallbackChain = input.fallbackChain
-  if (fallbackChain && fallbackChain.length > 0) {
-    if (input.availableModels.size === 0) {
-      if (connectedProviders) {
-        const connectedSet = new Set(connectedProviders)
-        for (const entry of fallbackChain) {
-          for (const provider of entry.providers) {
-            if (connectedSet.has(provider)) {
-              const transformedModelId = transformModelForProvider(provider, entry.model)
-              log("[resolveModelForDelegateTask] fallback chain resolved via connected provider", {
-                provider,
-                model: entry.model,
-              })
-              return { model: `${provider}/${transformedModelId}`, variant: entry.variant, fallbackEntry: entry, matchedFallback: true }
-            }
-          }
-        }
-        log("[resolveModelForDelegateTask] no connected provider found in fallback chain")
-      } else {
-        const first = fallbackChain[0]
-        const provider = first?.providers?.[0]
-        if (provider) {
-          const transformedModelId = transformModelForProvider(provider, first.model)
-          return { model: `${provider}/${transformedModelId}`, variant: first.variant, fallbackEntry: first, matchedFallback: true }
-        }
-      }
-    } else {
-      for (const entry of fallbackChain) {
-        for (const provider of entry.providers) {
-          const fullModel = `${provider}/${entry.model}`
-          const match = fuzzyMatchModel(fullModel, input.availableModels, [provider])
-          if (match) {
-            if (explicitHighModel && entry.variant === "high" && match === explicitHighBaseModel) {
-              return { model: explicitHighModel, fallbackEntry: entry, matchedFallback: true }
-            }
-
-            return { model: match, variant: entry.variant, fallbackEntry: entry, matchedFallback: true }
-          }
-        }
-
-        const crossProviderMatch = fuzzyMatchModel(entry.model, input.availableModels)
-        if (crossProviderMatch) {
-          if (explicitHighModel && entry.variant === "high" && crossProviderMatch === explicitHighBaseModel) {
-            return { model: explicitHighModel, fallbackEntry: entry, matchedFallback: true }
-          }
-
-          return { model: crossProviderMatch, variant: entry.variant, fallbackEntry: entry, matchedFallback: true }
-        }
-      }
-    }
-  }
-
-  const systemDefaultModel = normalizeModel(input.systemDefaultModel)
-  if (systemDefaultModel) {
-    return { model: systemDefaultModel }
-  }
-
-  return undefined
-}

package/src/tools/delegate-task/model-string-parser.test.ts

@@ -1,90 +0,0 @@
-import { expect, test, describe } from "bun:test"
-import { parseModelString, parseVariantFromModelID } from "./model-string-parser"
-
-describe("parseModelString", () => {
-  test("parses model with variant", () => {
-    const result = parseModelString("openai/gpt-5.3-codex medium")
-    expect(result?.modelID).toBe("gpt-5.3-codex")
-    expect(result?.providerID).toBe("openai")
-    expect(result?.variant).toBe("medium")
-  })
-
-  test("parses model without variant", () => {
-    const result = parseModelString("openai/gpt-5.3-codex")
-    expect(result?.modelID).toBe("gpt-5.3-codex")
-    expect(result?.providerID).toBe("openai")
-    expect(result?.variant).toBeUndefined()
-  })
-
-  test("handles whitespace trimming", () => {
-    const result = parseModelString("  openai/gpt-5.3-codex  high  ")
-    expect(result?.modelID).toBe("gpt-5.3-codex")
-    expect(result?.variant).toBe("high")
-  })
-
-  test("handles empty string", () => {
-    const result = parseModelString("")
-    expect(result).toBeUndefined()
-  })
-
-  test("handles model with multiple spaces before variant", () => {
-    const result = parseModelString("anthropic/claude-3.5-sonnet  high")
-    expect(result?.modelID).toBe("claude-3.5-sonnet")
-    expect(result?.variant).toBe("high")
-  })
-
-  test("handles provider/model with multiple slashes", () => {
-    const result = parseModelString("openrouter/anthropic/claude-3.5-sonnet ultra")
-    expect(result?.providerID).toBe("openrouter")
-    expect(result?.modelID).toBe("anthropic/claude-3.5-sonnet ultra")
-  })
-
-  test("returns model when no variant", () => {
-    const result = parseModelString("openrouter/google/gemini-2.0-flash")
-    expect(result?.modelID).toBe("google/gemini-2.0-flash")
-    expect(result?.providerID).toBe("openrouter")
-    expect(result?.variant).toBeUndefined()
-  })
-
-  test("single slash model returns undefined", () => {
-    const result = parseModelString("claude-medium")
-    expect(result).toBeUndefined()
-  })
-
-  test("model with xhigh variant", () => {
-    const result = parseModelString("openai/gpt-5.3-codex xhigh")
-    expect(result?.modelID).toBe("gpt-5.3-codex")
-    expect(result?.variant).toBe("xhigh")
-  })
-
-  test("model with max variant", () => {
-    const result = parseModelString("anthropic/claude-3.5-opus max")
-    expect(result?.modelID).toBe("claude-3.5-opus")
-    expect(result?.variant).toBe("max")
-  })
-})
-
-describe("parseVariantFromModelID", () => {
-  test("extracts parenthesized variant", () => {
-    const result = parseVariantFromModelID("gpt-5.3-codex (medium)")
-    expect(result.modelID).toBe("gpt-5.3-codex")
-    expect(result.variant).toBe("medium")
-  })
-
-  test("extracts space variant", () => {
-    const result = parseVariantFromModelID("gpt-5.3-codex medium")
-    expect(result.modelID).toBe("gpt-5.3-codex")
-    expect(result.variant).toBe("medium")
-  })
-
-  test("no variant when not recognized", () => {
-    const result = parseVariantFromModelID("gpt-5.3-codex unknownvariant")
-    expect(result.modelID).toBe("gpt-5.3-codex unknownvariant")
-    expect(result.variant).toBeUndefined()
-  })
-
-  test("handles empty string", () => {
-    const result = parseVariantFromModelID("")
-    expect(result.modelID).toBe("")
-  })
-})

package/src/tools/delegate-task/model-string-parser.ts

@@ -1,63 +0,0 @@
-const KNOWN_VARIANTS = new Set([
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max",
-  "minimal",
-  "none",
-  "auto",
-  "thinking",
-])
-
-export function parseVariantFromModelID(rawModelID: string): { modelID: string; variant?: string } {
-  const trimmedModelID = rawModelID.trim()
-  if (!trimmedModelID) {
-    return { modelID: "" }
-  }
-
-  const parenthesizedVariant = trimmedModelID.match(/^(.*)\(([^()]+)\)\s*$/)
-  if (parenthesizedVariant) {
-    const modelID = parenthesizedVariant[1]?.trim() ?? ""
-    const variant = parenthesizedVariant[2]?.trim()
-    return variant ? { modelID, variant } : { modelID }
-  }
-
-  const spaceVariant = trimmedModelID.match(/^(.*\S)\s+([a-z][a-z0-9_-]*)$/i)
-  if (spaceVariant) {
-    const modelID = spaceVariant[1]?.trim() ?? ""
-    const variant = spaceVariant[2]?.trim().toLowerCase()
-    if (variant && KNOWN_VARIANTS.has(variant)) {
-      return { modelID, variant }
-    }
-  }
-
-  return { modelID: trimmedModelID }
-}
-
-export function parseModelString(
-  model: string,
-): { providerID: string; modelID: string; variant?: string } | undefined {
-  const trimmedModel = model.trim()
-  if (!trimmedModel) return undefined
-
-  const parts = trimmedModel.split("/")
-  if (parts.length < 2) {
-    return undefined
-  }
-
-  const providerID = parts[0]?.trim()
-  const rawModelID = parts.slice(1).join("/").trim()
-  if (!providerID || !rawModelID) {
-    return undefined
-  }
-
-  const parsedModel = parseVariantFromModelID(rawModelID)
-  if (!parsedModel.modelID) {
-    return undefined
-  }
-
-  return parsedModel.variant
-    ? { providerID, modelID: parsedModel.modelID, variant: parsedModel.variant }
-    : { providerID, modelID: parsedModel.modelID }
-}

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

@@ -1,132 +0,0 @@
-import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
-
-const ULTRABRAIN_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on DEEP LOGICAL REASONING / ARCHITECTURE / STRATEGY tasks.
-
-<Routing_Policy>
-Executor contour: strategist (plan + analysis, read-only). This category produces a structured plan, NOT implementation. The caller is responsible for routing the implementation step to \`deep\`, \`bounded\`, or \`cross-module\` mode based on your plan.
-</Routing_Policy>
-
-<Output_Contract>
-Your output MUST contain:
-1. **Decomposition** - concrete tasks with bounded scope (each task small enough that one executor agent can complete it without further planning).
-2. **Dependency graph** - which tasks block which; identify parallel-safe tasks explicitly.
-3. **Tradeoffs** - at least 2 alternative approaches with cost/risk for each; recommend one and justify briefly.
-4. **Recommended next step** - explicit \`task(category=...)\` call the caller should make to start implementation.
-5. **Open questions** - assumptions the caller should confirm before kickoff (if any).
-
-You MUST NOT:
-- Write or edit code (you have no write/edit tools).
-- Mark task as done yourself; the caller verifies the plan and routes implementation.
-- Defer planning by asking clarifying questions when assumptions can be stated and surfaced as Open questions.
-</Output_Contract>
-
-<Reasoning_Discipline>
-- Bias toward simplicity: least complex solution that fulfills requirements.
-- Leverage existing code/patterns over new components - reference concrete files when relevant.
-- Surface assumptions explicitly as Open questions rather than guessing silently.
-- For unfamiliar domains, recommend a \`task(subagent_type="researcher", run_in_background=true, ...)\` exploration step before planning.
-- One clear recommendation with effort estimate (Quick / Short / Medium / Large).
-</Reasoning_Discipline>
-</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: sub (cheap fast-tier executor). 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, architecture, strategy. Returns structured plan (decomposition + dependency graph + tradeoffs), NOT implementation. Follow up with deep/bounded/cross-module mode for build.",
-    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 sub (cheap fast-tier) execution contour.",
-    promptAppend: QUICK_CATEGORY_PROMPT_APPEND,
-  },
-]