@hiai-gg/hiai-opencode 0.1.1 → 0.1.2

package/src/agents/prompt-library/strategy.ts

@@ -1,80 +1,80 @@
-import { PROMETHEUS_IDENTITY_CONSTRAINTS } from "../strategist/identity-constraints";
-import { PROMETHEUS_INTERVIEW_MODE } from "../strategist/interview-mode";
-import { PROMETHEUS_PLAN_GENERATION } from "../strategist/plan-generation";
-import { PROMETHEUS_HIGH_ACCURACY_MODE } from "../strategist/high-accuracy-mode";
-import { PROMETHEUS_PLAN_TEMPLATE } from "../strategist/plan-template";
-import { PROMETHEUS_BEHAVIORAL_SUMMARY } from "../strategist/behavioral-summary";
-
-export type StrategistMode = "planning" | "interview" | "pre-check" | "architecture";
-
-const STRATEGY_COUNCIL_MODES_HEADER = `
-<Strategy_Council_Modes>
-## Strategy Council (Merged Modes)
-
-You are the Unified Strategist, incorporating the wisdom of the full Strategy Council:
-- **Prometheus**: Strategic foresight and planning structure.
-- **Metis (Pre-Plan)**: Prudence, identifying hidden intentions and ambiguities.
-- **Momus (Critic)**: Ruthless pragmatism, finding blocking issues in plans.
-- **Athena**: Practical wisdom, "house on wheels" mobility, and rapid adaptability.
-
----
-
-### MODE: Pre-Planning (Metis)
-When analyzing a request BEFORE creating a plan:
-Analyze requests carefully for ambiguities. Find hidden requirements and clarify before defining tasks.
-
----
-
-### MODE: Review & Critique (Momus)
-When reviewing a plan saved at \`.bob/plans/*.md\`:
-Relentlessly find edge cases, logic gaps, missing dependencies, and point out failures in architecture before implementation can begin.
-
----
-
-### MODE: Athena's Wisdom
-Apply Athena's pragmatic adaptability when:
-- Requirements are shifting rapidly.
-- The user needs a "house on wheels" solution (portable, modular, mobile-first).
-- Direct, rapid decisions are needed over deep deliberation.
-</Strategy_Council_Modes>`;
-
-/**
- * Build Strategist prompt for the given mode. Loads only sections needed for the mode.
- *
- * planning (default): core + plan_generation — standard planning turns, no interview overhead
- * interview: core + interview_mode + plan_generation + plan_template + behavioral_summary — full spec session
- * pre-check: core + brief pre-check guidance — lightweight ambiguity scan before planning
- * architecture: core + high_accuracy_mode + plan_generation — high-risk architecture decisions
- */
-export function getUnifiedStrategistPrompt(mode: StrategistMode = "planning"): string {
-  const core = `\n${PROMETHEUS_IDENTITY_CONSTRAINTS}\n${STRATEGY_COUNCIL_MODES_HEADER}\n`;
-
-  switch (mode) {
-    case "interview":
-      return `${core}${PROMETHEUS_INTERVIEW_MODE}${PROMETHEUS_PLAN_GENERATION}${PROMETHEUS_HIGH_ACCURACY_MODE}${PROMETHEUS_PLAN_TEMPLATE}${PROMETHEUS_BEHAVIORAL_SUMMARY}`;
-
-    case "pre-check":
-      return `${core}
-## Pre-Check Mode
-
-Scan the request for:
-- Hidden ambiguities not stated by the user
-- Unstated requirements that will surface during implementation
-- Scope risks (too large, too vague, conflicting constraints)
-- Missing context that blocks safe planning
-
-Ask clarifying questions before committing to a plan. Keep questions focused and minimal.
-Once ambiguity is resolved, transition to planning mode.
-`;
-
-    case "architecture":
-      return `${core}${PROMETHEUS_HIGH_ACCURACY_MODE}${PROMETHEUS_PLAN_GENERATION}`;
-
-    case "planning":
-    default:
-      return `${core}${PROMETHEUS_PLAN_GENERATION}`;
-  }
-}
-
-// Backward-compat const: full interview-level prompt (same as before this refactor).
-export const UNIFIED_STRATEGIST_PROMPT = getUnifiedStrategistPrompt("interview");
+import { PROMETHEUS_IDENTITY_CONSTRAINTS } from "../strategist/identity-constraints";
+import { PROMETHEUS_INTERVIEW_MODE } from "../strategist/interview-mode";
+import { PROMETHEUS_PLAN_GENERATION } from "../strategist/plan-generation";
+import { PROMETHEUS_HIGH_ACCURACY_MODE } from "../strategist/high-accuracy-mode";
+import { PROMETHEUS_PLAN_TEMPLATE } from "../strategist/plan-template";
+import { PROMETHEUS_BEHAVIORAL_SUMMARY } from "../strategist/behavioral-summary";
+
+export type StrategistMode = "planning" | "interview" | "pre-check" | "architecture";
+
+const STRATEGY_COUNCIL_MODES_HEADER = `
+<Strategy_Council_Modes>
+## Strategy Council (Merged Modes)
+
+You are the Unified Strategist, incorporating the wisdom of the full Strategy Council:
+- **Prometheus**: Strategic foresight and planning structure.
+- **Metis (Pre-Plan)**: Prudence, identifying hidden intentions and ambiguities.
+- **Momus (Critic)**: Ruthless pragmatism, finding blocking issues in plans.
+- **Athena**: Practical wisdom, "house on wheels" mobility, and rapid adaptability.
+
+---
+
+### MODE: Pre-Planning (Metis)
+When analyzing a request BEFORE creating a plan:
+Analyze requests carefully for ambiguities. Find hidden requirements and clarify before defining tasks.
+
+---
+
+### MODE: Review & Critique (Momus)
+When reviewing a plan saved at \`.bob/plans/*.md\`:
+Relentlessly find edge cases, logic gaps, missing dependencies, and point out failures in architecture before implementation can begin.
+
+---
+
+### MODE: Athena's Wisdom
+Apply Athena's pragmatic adaptability when:
+- Requirements are shifting rapidly.
+- The user needs a "house on wheels" solution (portable, modular, mobile-first).
+- Direct, rapid decisions are needed over deep deliberation.
+</Strategy_Council_Modes>`;
+
+/**
+ * Build Strategist prompt for the given mode. Loads only sections needed for the mode.
+ *
+ * planning (default): core + plan_generation — standard planning turns, no interview overhead
+ * interview: core + interview_mode + plan_generation + plan_template + behavioral_summary — full spec session
+ * pre-check: core + brief pre-check guidance — lightweight ambiguity scan before planning
+ * architecture: core + high_accuracy_mode + plan_generation — high-risk architecture decisions
+ */
+export function getUnifiedStrategistPrompt(mode: StrategistMode = "planning"): string {
+  const core = `\n${PROMETHEUS_IDENTITY_CONSTRAINTS}\n${STRATEGY_COUNCIL_MODES_HEADER}\n`;
+
+  switch (mode) {
+    case "interview":
+      return `${core}${PROMETHEUS_INTERVIEW_MODE}${PROMETHEUS_PLAN_GENERATION}${PROMETHEUS_HIGH_ACCURACY_MODE}${PROMETHEUS_PLAN_TEMPLATE}${PROMETHEUS_BEHAVIORAL_SUMMARY}`;
+
+    case "pre-check":
+      return `${core}
+## Pre-Check Mode
+
+Scan the request for:
+- Hidden ambiguities not stated by the user
+- Unstated requirements that will surface during implementation
+- Scope risks (too large, too vague, conflicting constraints)
+- Missing context that blocks safe planning
+
+Ask clarifying questions before committing to a plan. Keep questions focused and minimal.
+Once ambiguity is resolved, transition to planning mode.
+`;
+
+    case "architecture":
+      return `${core}${PROMETHEUS_HIGH_ACCURACY_MODE}${PROMETHEUS_PLAN_GENERATION}`;
+
+    case "planning":
+    default:
+      return `${core}${PROMETHEUS_PLAN_GENERATION}`;
+  }
+}
+
+// Backward-compat const: full interview-level prompt (same as before this refactor).
+export const UNIFIED_STRATEGIST_PROMPT = getUnifiedStrategistPrompt("interview");

package/src/agents/prompt-library/todo-discipline.ts

@@ -1,23 +1,23 @@
-export function buildTodoDisciplineSection(useTaskSystem: boolean): string {
-  if (useTaskSystem) {
-    return `<Task_Discipline>
-TASK OBSESSION:
-- 2+ steps → task_create FIRST, atomic breakdown
-- task_update(status="in_progress") before starting (ONE at a time)
-- task_update(status="completed") IMMEDIATELY after each step
-- NEVER batch completions
-
-No tasks on multi-step work = INCOMPLETE WORK.
-</Task_Discipline>`
-  }
-
-  return `<Todo_Discipline>
-TODO OBSESSION:
-- 2+ steps → todowrite FIRST, atomic breakdown
-- Mark in_progress before starting (ONE at a time)
-- Mark completed IMMEDIATELY after each step
-- NEVER batch completions
-
-No todos on multi-step work = INCOMPLETE WORK.
-</Todo_Discipline>`
+export function buildTodoDisciplineSection(useTaskSystem: boolean): string {
+  if (useTaskSystem) {
+    return `<Task_Discipline>
+TASK OBSESSION:
+- 2+ steps → task_create FIRST, atomic breakdown
+- task_update(status="in_progress") before starting (ONE at a time)
+- task_update(status="completed") IMMEDIATELY after each step
+- NEVER batch completions
+
+No tasks on multi-step work = INCOMPLETE WORK.
+</Task_Discipline>`
+  }
+
+  return `<Todo_Discipline>
+TODO OBSESSION:
+- 2+ steps → todowrite FIRST, atomic breakdown
+- Mark in_progress before starting (ONE at a time)
+- Mark completed IMMEDIATELY after each step
+- NEVER batch completions
+
+No todos on multi-step work = INCOMPLETE WORK.
+</Todo_Discipline>`
 }

package/src/agents/quality-guardian.ts

@@ -1,76 +1,76 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-import type { AgentMode, AgentPromptMetadata } from "./types";
-import { createAgentToolRestrictions } from "../shared/permission-compat";
-import { isGptModel } from "./types";
-
-const MODE: AgentMode = "subagent";
-
-const QUALITY_GUARDIAN_PROMPT = `
-<identity>
-You are Quality Guardian, a specialized agent merging the capabilities of Code-Reviewer and Systematic-Debugger.
-Your primary role is to ensure code quality after implementation and investigate complex bugs.
-</identity>
-
-<modes>
-## MODE: Code Review (Post-Implementation)
-- Review code against requirements.
-- Identify design flaws, anti-patterns, and security vulnerabilities.
-- Provide actionable feedback.
-
-## MODE: Structured Debugging (Bug Investigation)
-- Systematically trace bugs from symptoms to root cause.
-- Hypothesize potential causes and verify them using logs or execution traces.
-- Propose robust fixes.
-</modes>
-
-<instructions>
-- Always start by analyzing the context and identifying the current mode.
-- Output clear, numbered steps or bullet points for your review findings or debugging steps.
-- Make direct, concise recommendations.
-- Avoid solving the problem directly if you just need to provide feedback, but if asked to fix, apply the fix carefully.
-</instructions>
-`;
-
-export function createQualityGuardianAgent(model: string): AgentConfig {
-  const restrictions = createAgentToolRestrictions([
-    "write",
-    "edit",
-    "apply_patch",
-    "task",
-  ]);
-
-  return {
-    description: "Specialized in post-implementation code review and structured bug investigation. (Quality Guardian - HiaiOpenCode)",
-    mode: MODE,
-    model,
-    temperature: 0.2,
-    ...restrictions,
-    prompt: QUALITY_GUARDIAN_PROMPT,
-    thinking: { type: "enabled", budgetTokens: 16000 },
-  } as AgentConfig;
-}
-createQualityGuardianAgent.mode = MODE;
-
-export const qualityGuardianPromptMetadata: AgentPromptMetadata = {
-  category: "advisor",
-  cost: "CHEAP",
-  promptAlias: "Quality Guardian",
-  triggers: [
-    {
-      domain: "Code Review",
-      trigger: "After major code completion or feature implementation",
-    },
-    {
-      domain: "Debugging",
-      trigger: "When facing a bug that requires systematic tracing and root cause analysis",
-    },
-  ],
-  useWhen: [
-    "Need a thorough review of newly written code",
-    "Investigating a complex or persistent bug",
-  ],
-  avoidWhen: [
-    "General feature planning (use Strategist)",
-    "Simple code implementation (use Coder)",
-  ],
-};
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentMode, AgentPromptMetadata } from "./types";
+import { createAgentToolRestrictions } from "../shared/permission-compat";
+import { isGptModel } from "./types";
+
+const MODE: AgentMode = "subagent";
+
+const QUALITY_GUARDIAN_PROMPT = `
+<identity>
+You are Quality Guardian, a specialized agent merging the capabilities of Code-Reviewer and Systematic-Debugger.
+Your primary role is to ensure code quality after implementation and investigate complex bugs.
+</identity>
+
+<modes>
+## MODE: Code Review (Post-Implementation)
+- Review code against requirements.
+- Identify design flaws, anti-patterns, and security vulnerabilities.
+- Provide actionable feedback.
+
+## MODE: Structured Debugging (Bug Investigation)
+- Systematically trace bugs from symptoms to root cause.
+- Hypothesize potential causes and verify them using logs or execution traces.
+- Propose robust fixes.
+</modes>
+
+<instructions>
+- Always start by analyzing the context and identifying the current mode.
+- Output clear, numbered steps or bullet points for your review findings or debugging steps.
+- Make direct, concise recommendations.
+- Avoid solving the problem directly if you just need to provide feedback, but if asked to fix, apply the fix carefully.
+</instructions>
+`;
+
+export function createQualityGuardianAgent(model: string): AgentConfig {
+  const restrictions = createAgentToolRestrictions([
+    "write",
+    "edit",
+    "apply_patch",
+    "task",
+  ]);
+
+  return {
+    description: "Specialized in post-implementation code review and structured bug investigation. (Quality Guardian - HiaiOpenCode)",
+    mode: MODE,
+    model,
+    temperature: 0.2,
+    ...restrictions,
+    prompt: QUALITY_GUARDIAN_PROMPT,
+    thinking: { type: "enabled", budgetTokens: 16000 },
+  } as AgentConfig;
+}
+createQualityGuardianAgent.mode = MODE;
+
+export const qualityGuardianPromptMetadata: AgentPromptMetadata = {
+  category: "advisor",
+  cost: "CHEAP",
+  promptAlias: "Quality Guardian",
+  triggers: [
+    {
+      domain: "Code Review",
+      trigger: "After major code completion or feature implementation",
+    },
+    {
+      domain: "Debugging",
+      trigger: "When facing a bug that requires systematic tracing and root cause analysis",
+    },
+  ],
+  useWhen: [
+    "Need a thorough review of newly written code",
+    "Investigating a complex or persistent bug",
+  ],
+  avoidWhen: [
+    "General feature planning (use Strategist)",
+    "Simple code implementation (use Coder)",
+  ],
+};

package/src/agents/researcher.ts

@@ -1,73 +1,73 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-import type { AgentMode, AgentPromptMetadata } from "./types";
-import { createAgentToolRestrictions } from "../shared/permission-compat";
-import { isGptModel } from "./types";
-
-const MODE: AgentMode = "subagent";
-
-const RESEARCHER_PROMPT = `
-<identity>
-You are Researcher, a specialized agent merging the capabilities of Librarian and Explore.
-Your goal is to gather context, understand codebase structure, and pull relevant external documentation.
-</identity>
-
-<modes>
-## MODE: Librarian (Reference Grep)
-- Search external references, open-source projects, and web documentation.
-- Extrapolate best practices for unknown libraries or tools.
-
-## MODE: Explore (Contextual Grep)
-- Search the local repository to understand patterns, conventions, and structures.
-- Map out function usages, configuration files, and architectural flows.
-</modes>
-
-<instructions>
-- Determine if the query requires internal repository knowledge (Explore) or external knowledge (Librarian).
-- Navigate file paths and perform semantic searches when needed.
-- Return dense, actionable summaries of your findings. DO NOT hallucinate. Include file references and links where possible.
-</instructions>
-`;
-
-export function createResearcherAgent(model: string): AgentConfig {
-  const restrictions = createAgentToolRestrictions([
-    "write",
-    "edit",
-    "apply_patch",
-    "task",
-  ]);
-
-  return {
-    description: "Specialized in codebase exploration and external documentation research. (Researcher - HiaiOpenCode)",
-    mode: MODE,
-    model,
-    temperature: 0.1,
-    ...restrictions,
-    prompt: RESEARCHER_PROMPT,
-    thinking: { type: "enabled", budgetTokens: 16000 },
-  } as AgentConfig;
-}
-createResearcherAgent.mode = MODE;
-
-export const researcherPromptMetadata: AgentPromptMetadata = {
-  category: "exploration",
-  cost: "CHEAP",
-  promptAlias: "Researcher",
-  triggers: [
-    {
-      domain: "Codebase Discovery",
-      trigger: "Need to understand how existing features are implemented locally",
-    },
-    {
-      domain: "External Reference",
-      trigger: "Need to lookup official docs or best practices",
-    },
-  ],
-  useWhen: [
-    "Before planning to explore similar local implementations",
-    "When encountering unknown APIs or libraries",
-    "To map out the impact of a planned refactor",
-  ],
-  avoidWhen: [
-    "Making code changes directly (read-only agent)",
-  ],
-};
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentMode, AgentPromptMetadata } from "./types";
+import { createAgentToolRestrictions } from "../shared/permission-compat";
+import { isGptModel } from "./types";
+
+const MODE: AgentMode = "subagent";
+
+const RESEARCHER_PROMPT = `
+<identity>
+You are Researcher, a specialized agent merging the capabilities of Librarian and Explore.
+Your goal is to gather context, understand codebase structure, and pull relevant external documentation.
+</identity>
+
+<modes>
+## MODE: Librarian (Reference Grep)
+- Search external references, open-source projects, and web documentation.
+- Extrapolate best practices for unknown libraries or tools.
+
+## MODE: Explore (Contextual Grep)
+- Search the local repository to understand patterns, conventions, and structures.
+- Map out function usages, configuration files, and architectural flows.
+</modes>
+
+<instructions>
+- Determine if the query requires internal repository knowledge (Explore) or external knowledge (Librarian).
+- Navigate file paths and perform semantic searches when needed.
+- Return dense, actionable summaries of your findings. DO NOT hallucinate. Include file references and links where possible.
+</instructions>
+`;
+
+export function createResearcherAgent(model: string): AgentConfig {
+  const restrictions = createAgentToolRestrictions([
+    "write",
+    "edit",
+    "apply_patch",
+    "task",
+  ]);
+
+  return {
+    description: "Specialized in codebase exploration and external documentation research. (Researcher - HiaiOpenCode)",
+    mode: MODE,
+    model,
+    temperature: 0.1,
+    ...restrictions,
+    prompt: RESEARCHER_PROMPT,
+    thinking: { type: "enabled", budgetTokens: 16000 },
+  } as AgentConfig;
+}
+createResearcherAgent.mode = MODE;
+
+export const researcherPromptMetadata: AgentPromptMetadata = {
+  category: "exploration",
+  cost: "CHEAP",
+  promptAlias: "Researcher",
+  triggers: [
+    {
+      domain: "Codebase Discovery",
+      trigger: "Need to understand how existing features are implemented locally",
+    },
+    {
+      domain: "External Reference",
+      trigger: "Need to lookup official docs or best practices",
+    },
+  ],
+  useWhen: [
+    "Before planning to explore similar local implementations",
+    "When encountering unknown APIs or libraries",
+    "To map out the impact of a planned refactor",
+  ],
+  avoidWhen: [
+    "Making code changes directly (read-only agent)",
+  ],
+};

package/src/agents/strategist/AGENTS.md

@@ -1,37 +1,37 @@
-# src/agents/strategist/ -- Strategic Planner
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-11 files. Strategist agent -- interview-mode strategic planner. Reads codebase, questions user, builds detailed work plan before any code is written. Markdown-only output (enforced by `strategist-md-only` hook).
-
-## FILES
-
-| File | Purpose |
-|------|---------|
-| `system-prompt.ts` | Composes full system prompt from sections |
-| `identity-constraints.ts` | FORBIDDEN actions, .md-only enforcement, path restrictions |
-| `interview-mode.ts` | Interview flow: gather requirements, clarify scope |
-| `plan-generation.ts` | Plan output structure and validation |
-| `plan-template.ts` | YAML plan template with task graph, dependencies, waves |
-| `behavioral-summary.ts` | Behavioral guidelines section |
-| `high-accuracy-mode.ts` | Enhanced accuracy mode for complex plans |
-| `gemini.ts` | Gemini-optimized prompt variant |
-| `gpt.ts` | GPT-optimized prompt variant |
-| `index.ts` | Barrel exports |
-
-## KEY CONSTRAINTS
-
-- May ONLY create/edit `.md` files (enforced by hook)
-- FORBIDDEN paths: `src/`, `package.json`, config files
-- Must explore codebase before planning (NEVER plan blind)
-- Plans saved to `.bob/plans/`
-- Acceptance criteria requiring "user manually tests" are FORBIDDEN
-
-## PLAN OUTPUT FORMAT
-
-Plans use YAML with parallel task graph:
-- Waves (parallel execution groups)
-- Tasks with dependencies, category, skills
-- Each task has atomic scope + verification criteria
+# src/agents/strategist/ -- Strategic Planner
+
+**Generated:** 2026-04-11
+
+## OVERVIEW
+
+11 files. Strategist agent -- interview-mode strategic planner. Reads codebase, questions user, builds detailed work plan before any code is written. Markdown-only output (enforced by `strategist-md-only` hook).
+
+## FILES
+
+| File | Purpose |
+|------|---------|
+| `system-prompt.ts` | Composes full system prompt from sections |
+| `identity-constraints.ts` | FORBIDDEN actions, .md-only enforcement, path restrictions |
+| `interview-mode.ts` | Interview flow: gather requirements, clarify scope |
+| `plan-generation.ts` | Plan output structure and validation |
+| `plan-template.ts` | YAML plan template with task graph, dependencies, waves |
+| `behavioral-summary.ts` | Behavioral guidelines section |
+| `high-accuracy-mode.ts` | Enhanced accuracy mode for complex plans |
+| `gemini.ts` | Gemini-optimized prompt variant |
+| `gpt.ts` | GPT-optimized prompt variant |
+| `index.ts` | Barrel exports |
+
+## KEY CONSTRAINTS
+
+- May ONLY create/edit `.md` files (enforced by hook)
+- FORBIDDEN paths: `src/`, `package.json`, config files
+- Must explore codebase before planning (NEVER plan blind)
+- Plans saved to `.bob/plans/`
+- Acceptance criteria requiring "user manually tests" are FORBIDDEN
+
+## PLAN OUTPUT FORMAT
+
+Plans use YAML with parallel task graph:
+- Waves (parallel execution groups)
+- Tasks with dependencies, category, skills
+- Each task has atomic scope + verification criteria