@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/agents/critic/agent.ts

@@ -1,105 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-import type { AgentMode, AgentPromptMetadata } from "../types";
-
-const MODE: AgentMode = "subagent";
-
-const CRITIC_PROMPT = `
-<identity>
-You are Critic — high-accuracy review gate for plans and implementations.
-</identity>
-
-<role>
-**Your ONLY job**: receive a plan or implementation, then respond with:
-- APPROVED (green) — if it meets all quality gates
-- REJECTED (red) — if it has gaps, flaws, or missing verification
-
-You do NOT implement. You do NOT plan. You judge.
-</role>
-
-<workflow>
-1. Receive the artifact (plan text, code snippet, or implementation description)
-2. Check against the quality criteria listed below
-3. State your verdict: APPROVED or REJECTED
-4. If REJECTED: list specific gaps with evidence (what's missing, what will break, what was overlooked)
-5. Do NOT propose fixes yourself — return gaps only, let the author fix
-</workflow>
-
-<quality_criteria>
-## For Plans:
-- Scope is concrete and bounded (no vague "improve X")
-- Each task has verifiable completion criteria
-- Dependencies are explicit
-- Parallel opportunities are identified
-- Risks are acknowledged
-- No acceptance criteria requiring manual user testing
-
-## For Implementations:
-- Code matches the plan scope
-- Error handling present
-- No hard-coded secrets or paths
-- Type-safe (no suppression)
-- Verification evidence exists in the output
-</quality_criteria>
-
-<output_format>
-## Verdict: [APPROVED|REJECTED]
-
-## Quality Gate Results:
-- **Scope bounded** → ✅/❌ → ...
-- **Verifiable criteria** → ✅/❌ → ...
-- **Dependencies explicit** → ✅/❌ → ...
-- **Parallel opportunities** → ✅/❌ → ...
-- **Risks acknowledged** → ✅/❌ → ...
-- **No manual-test AC** → ✅/❌ → ...
-
-## Gaps (if REJECTED):
-1. ...
-2. ...
-</output_format>
-
-<forbidden>
-- Do NOT write code or plans yourself
-- Do NOT give implementation hints in rejection notes
-- Do NOT soften feedback to avoid offending the author
-- Do NOT approve just because most of it looks okay
-</forbidden>
-`;
-
-export function createCriticAgent(model: string): AgentConfig {
-  return {
-    description: "High-accuracy review gate. Judge, not executor. (Critic - HiaiOpenCode)",
-    mode: MODE,
-    model,
-    temperature: 0.3,
-    prompt: CRITIC_PROMPT,
-    thinking: { type: "enabled", budgetTokens: 24000 },
-  };
-}
-createCriticAgent.mode = MODE;
-
-export const criticPromptMetadata: AgentPromptMetadata = {
-  category: "advisor",
-  cost: "EXPENSIVE",
-  promptAlias: "Critic",
-  triggers: [
-    {
-      domain: "Plan Verification",
-      trigger: "High-accuracy plan review or strict approve/reject validation",
-    },
-    {
-      domain: "Implementation Review",
-      trigger: "After implementation is complete, before merge or delivery",
-    },
-  ],
-  useWhen: [
-    "High-risk decision with significant consequences",
-    "Architecture change affecting multiple systems",
-    "Security-sensitive implementation",
-    "Critical bug fix with unclear root cause",
-  ],
-  avoidWhen: [
-    "Simple single-file changes",
-    "Trivial typo or formatting fixes",
-    "When the author already verified everything",
-  ],
-};

package/src/agents/custom-agent-summaries.ts

@@ -1,61 +0,0 @@
-import type { AgentPromptMetadata } from "./types"
-import { truncateDescription } from "../shared/truncate-description"
-
-type RegisteredAgentSummary = {
-  name: string
-  description: string
-}
-
-function sanitizeMarkdownTableCell(value: string): string {
-  return value
-    .replace(/\r?\n/g, " ")
-    .replace(/\|/g, "\\|")
-    .replace(/\s+/g, " ")
-    .trim()
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-export function parseRegisteredAgentSummaries(input: unknown): RegisteredAgentSummary[] {
-  if (!Array.isArray(input)) return []
-
-  const result: RegisteredAgentSummary[] = []
-  for (const item of input) {
-    if (!isRecord(item)) continue
-
-    const name = typeof item.name === "string" ? item.name : undefined
-    if (!name) continue
-
-    const hidden = item.hidden
-    if (hidden === true) continue
-
-    const disabled = item.disabled
-    if (disabled === true) continue
-
-    const enabled = item.enabled
-    if (enabled === false) continue
-
-    const description = typeof item.description === "string" ? item.description : ""
-    result.push({ name: sanitizeMarkdownTableCell(name), description: sanitizeMarkdownTableCell(description) })
-  }
-
-  return result
-}
-
-export function buildCustomAgentMetadata(agentName: string, description: string): AgentPromptMetadata {
-  const shortDescription = sanitizeMarkdownTableCell(truncateDescription(description))
-  const safeAgentName = sanitizeMarkdownTableCell(agentName)
-
-  return {
-    category: "specialist",
-    cost: "CHEAP",
-    triggers: [
-      {
-        domain: `Custom agent: ${safeAgentName}`,
-        trigger: shortDescription || "Use when this agent's description matches the task",
-      },
-    ],
-  }
-}

package/src/agents/dynamic-agent-category-skills-guide.ts

@@ -1,138 +0,0 @@
-import type {
-  AvailableCategory,
-  AvailableSkill,
-} from "./dynamic-agent-prompt-types"
-
-function buildSkillsSection(skills: AvailableSkill[]): string {
-  const builtinSkills = skills.filter((skill) => skill.location === "plugin")
-  const customSkills = skills.filter((skill) => skill.location !== "plugin")
-
-  const builtinNames = builtinSkills.map((skill) => skill.name).join(", ")
-  const customNames = customSkills
-    .map((skill) => {
-      const source = skill.location === "project" ? "project" : "user"
-      return `${skill.name} (${source})`
-    })
-    .join(", ")
-
-  if (customSkills.length > 0 && builtinSkills.length > 0) {
-    return `#### Available Skills (via \`skill\` tool)
-
-**Built-in**: ${builtinNames}
-**⚡ YOUR SKILLS (PRIORITY)**: ${customNames}
-
-> User-installed skills OVERRIDE built-in defaults. ALWAYS prefer YOUR SKILLS when domain matches.
-> Full skill descriptions → use the \`skill\` tool to check before EVERY delegation.`
-  }
-
-  if (customSkills.length > 0) {
-    return `#### Available Skills (via \`skill\` tool)
-
-**⚡ YOUR SKILLS (PRIORITY)**: ${customNames}
-
-> User-installed skills OVERRIDE built-in defaults. ALWAYS prefer YOUR SKILLS when domain matches.
-> Full skill descriptions → use the \`skill\` tool to check before EVERY delegation.`
-  }
-
-  if (builtinSkills.length > 0) {
-    return `#### Available Skills (via \`skill\` tool)
-
-**Built-in**: ${builtinNames}
-
-> Full skill descriptions → use the \`skill\` tool to check before EVERY delegation.`
-  }
-
-  return ""
-}
-
-export function buildCategorySkillsDelegationGuide(
-  categories: AvailableCategory[],
-  skills: AvailableSkill[],
-): string {
-  if (categories.length === 0 && skills.length === 0) {
-    return ""
-  }
-
-  const categoryRows = categories.map((category) => {
-    const description = category.description || category.name
-    return `- \`${category.name}\` - ${description}`
-  })
-
-  const customSkills = skills.filter((skill) => skill.location !== "plugin")
-  const skillsSection = buildSkillsSection(skills)
-  const customPriorityNote =
-    customSkills.length > 0
-      ? `
-> **User-installed skills get PRIORITY.** When in doubt, INCLUDE rather than omit.`
-      : ""
-
-  return `### Category + Skills Delegation System
-
-**task() combines categories and skills for optimal task execution.**
-
-#### Available Categories (Domain-Optimized Models)
-
-Each category is configured with a model optimized for that domain. Read the description to understand when to use it.
-
-${categoryRows.join("\n")}
-
-${skillsSection}
-
----
-
-### Category + Skill Selection Protocol
-
-**STEP 1: Select Category**
-- Read each category's description
-- Match task requirements to category domain
-- Select the category whose domain BEST fits the task
-
-**STEP 2: Evaluate ALL Skills**
-Check the \`skill\` tool for available skills and their descriptions. For EVERY skill, ask:
-> "Does this skill's expertise domain overlap with my task?"
-
-- If YES → INCLUDE in \`load_skills=[...]\`
-- If NO → OMIT (no justification needed)${customPriorityNote}
-
----
-
-### Delegation Pattern
-
-\`\`\`typescript
-task(
-  category="[selected-category]",
-  load_skills=["skill-1", "skill-2"],  // Include ALL relevant skills - ESPECIALLY user-installed ones
-  prompt="..."
-)
-\`\`\`
-
-**ANTI-PATTERN (will produce poor results):**
-\`\`\`typescript
-task(category="...", load_skills=[], run_in_background=false, prompt="...")  // Empty load_skills without justification
-\`\`\`
-
----
-
-### Category Domain Matching (ZERO TOLERANCE)
-
-Every delegation MUST use the category that matches the task's domain. Mismatched categories produce measurably worse output because each category runs on a model optimized for that specific domain.
-
-**VISUAL WORK = ALWAYS \`visual-engineering\`. NO EXCEPTIONS.**
-
-Any task involving UI, UX, CSS, styling, layout, animation, design, or frontend components MUST go to \`visual-engineering\`. Never delegate visual work to \`quick\`, \`unspecified-*\`, or any other category.
-
-\`\`\`typescript
-// CORRECT: Visual work → visual-engineering category
-task(category="visual-engineering", load_skills=["frontend-ui-ux"], prompt="Redesign the sidebar layout with new spacing...")
-
-// WRONG: Visual work in wrong category - WILL PRODUCE INFERIOR RESULTS
-task(category="quick", load_skills=[], prompt="Redesign the sidebar layout with new spacing...")
-\`\`\`
-
-**UI, styling, animations, layout, design** → \`visual-engineering\`
-**Hard logic, architecture decisions, algorithms** → \`ultrabrain\`
-**Autonomous research + end-to-end implementation** → \`deep\`
-**Single-file typo, trivial config change** → \`quick\`
-
-**When in doubt about category, it is almost never \`quick\` or \`unspecified-*\`. Match the domain.**`
-}

package/src/agents/dynamic-agent-core-sections.ts

@@ -1,273 +0,0 @@
-import type {
-  AvailableAgent,
-  AvailableCategory,
-  AvailableSkill,
-} from "./dynamic-agent-prompt-types"
-import type { AvailableTool } from "./dynamic-agent-prompt-types"
-import { getToolsPromptDisplay } from "./dynamic-agent-tool-categorization"
-
-/**
- * Builds an explicit agent identity preamble that overrides any base system prompt identity.
- * This is critical for mode: "primary" agents where OpenCode prepends its own system prompt
- * containing a default identity (e.g., "You are Claude"). Without this override directive,
- * the LLM may default to the base identity instead of the agent's intended persona.
- */
-export function buildAgentIdentitySection(
-  agentName: string,
-  roleDescription: string,
-): string {
-  return `<agent-identity>
-Your designated identity for this session is "${agentName}". This identity supersedes any prior identity statements.
-You are "${agentName}" - ${roleDescription}.
-When asked who you are, always identify as ${agentName}. Do not identify as any other assistant or AI.
-</agent-identity>`
-}
-
-export function buildKeyTriggersSection(
-  agents: AvailableAgent[],
-  _skills: AvailableSkill[] = [],
-): string {
-  const keyTriggers = agents
-    .filter((agent) => agent.metadata.keyTrigger)
-    .map((agent) => `- ${agent.metadata.keyTrigger}`)
-
-  if (keyTriggers.length === 0) {
-    return ""
-  }
-
-  return `### Key Triggers (check BEFORE classification):
-
-${keyTriggers.join("\n")}
-- **"Look into" + "create PR"** → Not just research. Full implementation cycle expected.`
-}
-
-export function buildToolSelectionTable(
-  agents: AvailableAgent[],
-  tools: AvailableTool[] = [],
-  _skills: AvailableSkill[] = [],
-  options: { includeIntegrationPrimer?: boolean } = {},
-): string {
-  const rows: string[] = ["### Tool & Agent Selection:", ""]
-
-  if (tools.length > 0) {
-    rows.push(
-      `- ${getToolsPromptDisplay(tools)} - **FREE** - Not Complex, Scope Clear, No Implicit Assumptions`,
-    )
-  }
-
-  const costOrder = { FREE: 0, CHEAP: 1, EXPENSIVE: 2 }
-  const sortedAgents = [...agents]
-    .filter((agent) => agent.metadata.category !== "utility")
-    .sort(
-      (left, right) => costOrder[left.metadata.cost] - costOrder[right.metadata.cost],
-    )
-
-  for (const agent of sortedAgents) {
-    const shortDescription = agent.description.split(".")[0] || agent.description
-    rows.push(
-      `- \`${agent.name}\` agent - **${agent.metadata.cost}** - ${shortDescription}`,
-    )
-  }
-
-  rows.push("")
-  rows.push(
-    "**Default flow**: researcher (background) + tools → strategist (if required) → critic (high-risk gate)",
-  )
-  if (options.includeIntegrationPrimer) {
-    rows.push("")
-    rows.push(buildHiaiIntegrationPrimerSection())
-  }
-
-  return rows.join("\n")
-}
-
-export function buildHiaiIntegrationPrimerSection(): string {
-  return `<hiai-opencode-integration-primer>
-## hiai-opencode Architecture And Integration Rules
-
-This workspace may use hiai-opencode, an OpenCode plugin that wires agents, skills, MCP launchers, LSP, diagnostics, and compatibility helpers around external upstream tools.
-
-Core rules:
-- OpenCode plugins are not MCP servers. Keep \`@hiai-gg/hiai-opencode\` and optional \`@tarquinen/opencode-dcp\` in the OpenCode plugin list; never add MCP packages such as \`firecrawl-mcp\`, \`@playwright/mcp\`, or \`@modelcontextprotocol/server-sequential-thinking\` to the plugin list.
-- User-facing config lives in \`hiai-opencode.json\` or \`.opencode/hiai-opencode.json\`: 10 model slots, MCP enable flags, LSP enable flags, service auth placeholders, and skill discovery switches.
-- Model provider credentials are configured through OpenCode Connect. Do not ask for \`OPENROUTER_API_KEY\`, \`OPENAI_API_KEY\`, or \`ANTHROPIC_API_KEY\` for normal model usage.
-- Service keys are separate: \`FIRECRAWL_API_KEY\`, \`STITCH_AI_API_KEY\`, \`CONTEXT7_API_KEY\`, and \`OPENCODE_RAG_URL\` when those services are enabled.
-
-MCP usage:
-- Run \`hiai-opencode doctor\` or \`hiai-opencode mcp-status\` for effective runtime MCP status.
-- \`opencode mcp list\` often reads only static \`.mcp.json\`; plugin runtime MCP may work even when that list is empty.
-- The plugin auto-exports \`.mcp.json\` when missing. Run \`hiai-opencode export-mcp .mcp.json\` to refresh static visibility.
-- \`skill_mcp\` can call skill-embedded MCP and enabled hiai-opencode MCP. If an MCP is "not found", check whether the skill was loaded, whether \`hiai-opencode.json\` enables it, and whether static export is needed.
-
-Memory and retrieval:
-- MemPalace MCP is external. If enabled, use \`mempalace_status\` first, search before answering about remembered people/projects/past decisions, and write diary entries when appropriate. Never invent memories.
-- RAG MCP is external/local. Use it for project knowledge search when \`OPENCODE_RAG_URL\` is configured or the default \`http://localhost:9002/tools/search\` is reachable.
-- Sequential Thinking MCP is for complex planning/revision/branching, not for trivial edits.
-- Firecrawl/Stitch/Context7 are external web/docs/research services; missing service keys should be reported by env var name only.
-
-Installation/debugging:
-- Use \`/doctor\` or \`hiai-opencode doctor\` before changing config.
-- Prefer user-level or project-local installs. Do not use sudo/admin rights unless explicitly requested.
-- If DCP is requested, install it separately with \`opencode plugin @tarquinen/opencode-dcp@latest --global\`.
-</hiai-opencode-integration-primer>`
-}
-
-export function buildResearcherSection(agents: AvailableAgent[]): string {
-  const researcherAgent = agents.find((agent) => agent.name === "researcher")
-  if (!researcherAgent) {
-    return ""
-  }
-
-  const useWhen = researcherAgent.metadata.useWhen || []
-  const avoidWhen = researcherAgent.metadata.avoidWhen || []
-
-  return `### Researcher Agent = Contextual & Reference Grep
-
-Use it as a **peer tool**, not a fallback. Fire liberally for discovery, both internal (local codebase patterns) and external (docs, OSS examples, API usage).
-
-**Delegation Trust Rule:** Once you fire a researcher agent for a search, do **not** manually perform that same search yourself. Use direct tools only for non-overlapping work or when you intentionally skipped delegation.
-
-**Contextual Grep (Internal)** - search OUR codebase, find patterns in THIS repo, project-specific logic.
-**Reference Grep (External)** - search EXTERNAL resources, official API docs, library best practices, OSS implementation examples.
-
-**Use Direct Tools when:**
-${avoidWhen.map((entry) => `- ${entry}`).join("\n")}
-
-**Use Researcher Agent when:**
-${useWhen.map((entry) => `- ${entry}`).join("\n")}`
-}
-
-export function buildDelegationTable(agents: AvailableAgent[]): string {
-  const rows: string[] = ["### Delegation Table:", ""]
-
-  for (const agent of agents) {
-    for (const trigger of agent.metadata.triggers) {
-      rows.push(`- **${trigger.domain}** → \`${agent.name}\` - ${trigger.trigger}`)
-    }
-  }
-
-  return rows.join("\n")
-}
-
-export function buildStrategistAndCriticSection(agents: AvailableAgent[]): string {
-  const strategistAgent = agents.find((agent) => agent.name === "strategist");
-  const criticAgent = agents.find((agent) => agent.name === "critic")
-
-  if (!strategistAgent && !criticAgent) {
-    return ""
-  }
-
-  const strategistUseWhen = strategistAgent?.metadata.useWhen || []
-  const strategistAvoidWhen = strategistAgent?.metadata.avoidWhen || []
-  const criticUseWhen = criticAgent?.metadata.useWhen || []
-  const criticAvoidWhen = criticAgent?.metadata.avoidWhen || []
-  const strategistLabel = "Strategist"
-
-  const strategistSection = strategistAgent
-    ? `### WHEN to Consult ${strategistLabel} (FIRST, then implement):
-
-${strategistUseWhen.map((entry) => `- ${entry}`).join("\n")}
-
-### WHEN NOT to Consult ${strategistLabel}:
-
-${strategistAvoidWhen.map((entry) => `- ${entry}`).join("\n")}`
-    : ""
-
-  const criticSection = criticAgent
-    ? `### WHEN to Consult Critic (explicit review gate):
-
-${criticUseWhen.map((entry) => `- ${entry}`).join("\n")}
-
-### WHEN NOT to Consult Critic:
-
-${criticAvoidWhen.map((entry) => `- ${entry}`).join("\n")}`
-    : ""
-
-  return `<strategist_critic_usage>
-## Strategist and Critic - Reasoning Escalation
-
-Strategist handles planning and architecture consultation. Critic is an explicit high-accuracy review gate. Consultation only.
-
-${strategistSection}
-
-${criticSection}
-
-### Usage Pattern:
-Briefly announce "Consulting Strategist for [reason]" or "Consulting Critic for [reason]" before invocation.
-
-**Exception**: This is the ONLY case where you announce before acting. For all other work, start immediately without status updates.
-
-### Background Task Policy:
-
-**Collect Strategist/Critic results before your final answer. No exceptions.**
-
-**Strategist/Critic-dependent implementation is BLOCKED until those results finish.**
-
-- If you asked Strategist/Critic for direction that affects the fix, do not implement before results arrive.
-- While waiting, only do non-overlapping prep work. Never ship implementation decisions they were asked to decide.
-- Never "time out and continue anyway" for Strategist/Critic-dependent tasks.
-
-- Strategist/Critic may take minutes. When done with your own work: **end your response** - wait for the \`<system-reminder>\`.
-- Do NOT poll \`background_output\` on a running Strategist/Critic task. The notification will come.
-- Never cancel Strategist/Critic consultation tasks.
-</strategist_critic_usage>`
-}
-
-export function buildNonClaudePlannerSection(model: string): string {
-  const isNonClaude = !model.toLowerCase().includes("claude")
-  if (!isNonClaude) {
-    return ""
-  }
-
-  return `### Strategist Dependency (Non-Claude)
-
-Multi-step task? **ALWAYS consult Strategist first.** Do NOT start implementation without a plan.
-
-- Single-file fix or trivial change → proceed directly
-- Anything else (2+ steps, unclear scope, architecture) → \`task(subagent_type="strategist", ...)\` FIRST
-- Use \`session_id\` to resume the same Strategist session - ask follow-up questions aggressively
-- If ANY part of the task is ambiguous, ask Strategist before guessing
-
-Strategist returns a structured work breakdown with parallel execution opportunities. Follow it.`
-}
-
-export function buildParallelDelegationSection(
-  model: string,
-  categories: AvailableCategory[],
-): string {
-  const isNonClaude = !model.toLowerCase().includes("claude")
-  const hasDelegationCategory = categories.some(
-    (category) => category.name === "deep" || category.name === "unspecified-high",
-  )
-
-  if (!isNonClaude || !hasDelegationCategory) {
-    return ""
-  }
-
-  return `### DECOMPOSE AND DELEGATE - YOU ARE NOT AN IMPLEMENTER
-
-**YOUR FAILURE MODE: You attempt to do work yourself instead of decomposing and delegating.** When you implement directly, the result is measurably worse than when specialized subagents do it. Subagents have domain-specific configurations, loaded skills, and tuned prompts that you lack.
-
-**for ANY implementation task:**
-
-1. **ALWAYS decompose** the task into independent work units. No exceptions. Even if the task "feels small", decompose it.
-2. **ALWAYS delegate** EACH unit to a \`deep\` or \`unspecified-high\` agent in parallel (\`run_in_background=true\`).
-3. **Keep execution contours separate**: bounded low-risk edits go to \`sub\`; deep, long-horizon implementation goes to \`coder\`.
-4. **NEVER work sequentially.** If 4 independent units exist, spawn 4 agents simultaneously. Not 1 at a time. Not 2 then 2.
-5. **NEVER implement directly** when delegation is possible. You write prompts, not code.
-
-**YOUR PROMPT TO EACH AGENT MUST INCLUDE:**
-- GOAL with explicit success criteria (what "done" looks like)
-- File paths and constraints (where to work, what not to touch)
-- Existing patterns to follow (reference specific files the agent should read)
-- Clear scope boundary (what is IN scope, what is OUT of scope)
-
-**Vague delegation = failed delegation.** If your prompt to the subagent is shorter than 5 lines, it is too vague.
-
-**Write code yourself** → Delegate to \`deep\` or \`unspecified-high\` agent
-**Handle 3 changes sequentially** → Spawn 3 agents in parallel
-**Send cheap bounded edits to coder** → Route those to \`sub\`
-**"Quickly fix this one thing"** → Still delegate - your "quick fix" is slower and worse than a subagent's
-
-**Your value is orchestration, decomposition, and quality control. Delegating with crystal-clear prompts IS your work.**`
-}