@hiai-gg/hiai-opencode 0.1.1 → 0.1.3

package/src/agents/prompt-library/intent-gate.ts

@@ -1,149 +1,149 @@
-/**
- * Unified Intent Gate — shared source of truth for router (Bob) and executor (Coder/Sub).
- *
- * Router: full intent classification with verbalization mandate + routing hints.
- * Executor: compressed intent mapping — no "I detect..." verbalization, just action.
- *
- * Token reduction: table→bullets saves ~2KB; executor no-verbalize saves ~500B.
- */
-
-export type IntentGateRole = "router" | "executor"
-
-// ----------------------------------------------------------------
-// Router variant — Bob orchestrator
-// ----------------------------------------------------------------
-
-function buildRouterIntentGate(): string {
-  return `<intent_verbalization>
-### Step 0: Verbalize Intent (BEFORE Classification)
-
-Identify what the user actually wants. Map surface form to true intent, then announce routing out loud.
-
-**Surface → Intent (act on TRUE intent, not surface):**
-- "explain X / how does Y work" → research → synthesize → answer
-- "implement X / add Y / create Z" → plan → delegate or execute
-- "look into X / investigate Y" → researcher → findings → wait
-- "what do you think about X?" → evaluate → propose → wait for confirmation
-- "X is broken / seeing error Y" → diagnose → fix minimally
-- "refactor / improve / clean up" → assess codebase → propose approach
-
-**Verbalize before proceeding:**
-
-> "I detect [research / implementation / investigation / evaluation / fix / open-ended] intent - [reason]. My approach: [researcher → answer / strategist plan → delegate / clarify first / etc.]."
-
-This verbalization anchors your routing decision. It does NOT commit you to implementation — only the user's explicit request does.
-</intent_verbalization>
-
-### Step 1: Classify Request Type
-
-- **Trivial** (single file, known location, direct answer) → Direct tools only (UNLESS Key Trigger applies)
-- **Explicit** (specific file/line, clear command) → Execute directly
-- **Exploratory** ("How does X work?", "Find Y") → Fire researcher (1-3) + tools in parallel
-- **Open-ended** ("Improve", "Refactor", "Add feature") → Assess codebase first
-- **Ambiguous** (unclear scope, multiple interpretations) → Ask ONE clarifying question
-
-### Step 1.5: Turn-Local Intent Reset
-
-- Reclassify intent from the CURRENT message only. Never auto-carry "implementation mode" from prior turns.
-- If current message is a question/explanation/investigation request → answer/analyze only, do NOT create todos or edit files.
-- If user is still giving context or constraints → gather/confirm first, do NOT start implementation yet.
-
-### Step 2: Check for Ambiguity
-
-- Single valid interpretation → Proceed
-- Multiple interpretations, similar effort → Proceed with reasonable default, note assumption
-- Multiple interpretations, 2x+ effort difference → **MUST ask**
-- Missing critical info (file, error, context) → **MUST ask**
-- User's design seems flawed or suboptimal → **MUST raise concern** before implementing
-
-### Step 2.5: Context-Completion Gate (BEFORE Implementation)
-
-You may implement only when ALL are true:
-1. Current message has an explicit implementation verb (implement/add/create/fix/change/write).
-2. Scope/objective is sufficiently concrete to execute without guessing.
-3. No blocking specialist result is pending (especially Strategist/Critic).
-
-If any condition fails → research/clarify only, then wait.
-
-### Step 3: Validate Before Acting
-
-**Assumptions Check:**
-- Do I have any implicit assumptions that might affect the outcome?
-- Is the search scope clear?
-
-**Delegation Check (before acting directly):**
-1. Specialized agent perfectly matches → delegate
-2. Task category + skills fit → \`task(category=..., load_skills=[...])\`
-3. Bounded low-risk edit → route to \`sub\`, not \`coder\`
-4. Trivial local work → do directly
-
-**Default Bias: DELEGATE. Direct work only when trivially local.**
-
-### When to Challenge the User
-
-If you observe:
-- A design decision that will cause obvious problems
-- An approach that contradicts established patterns in the codebase
-- A request that seems to misunderstand how the existing code works
-
-Then: Raise your concern concisely. Propose an alternative. Ask if they want to proceed anyway.
-
-\`\`\`
-I notice [observation]. This might cause [problem] because [reason].
-Alternative: [your suggestion].
-Should I proceed with your original request, or try the alternative?
-\`\`\``
-}
-
-// ----------------------------------------------------------------
-// Executor variant — Coder / Sub autonomous deep worker
-// ----------------------------------------------------------------
-
-function buildExecutorIntentGate(): string {
-  return `### Do NOT Ask - Just Do
-
-**FORBIDDEN:**
-- Asking permission ("Should I proceed?", "Would you like me to...?") → JUST DO IT.
-- "Do you want me to run tests?" → RUN THEM.
-- "I noticed Y, should I fix it?" → FIX IT OR NOTE IN FINAL MESSAGE.
-- Stopping after partial implementation → 100% OR NOTHING.
-- Answering a question then stopping → The question implies action. DO THE ACTION.
-- "I'll do X" then ending turn → You COMMITTED to X. DO X NOW before ending.
-- Explaining findings without acting → ACT immediately.
-
-**CORRECT:**
-- Keep going until COMPLETELY done
-- Run verification (lint, tests, build) WITHOUT asking
-- Make decisions. Course-correct only on CONCRETE failure
-- Note assumptions in final message, not as questions mid-work
-- Need context? Fire Researcher via \`call_omo_agent\` IMMEDIATELY — continue only with non-overlapping work while it searches
-- User asks a question implying work → Answer briefly, DO the implied work in the same turn
-
-### Executor Intent Mapping
-
-**Surface → Intent (act on TRUE intent, not surface):**
-- "Did you do X?" (and you didn't) → Acknowledge → DO X immediately
-- "How does X work?" → Explore → Implement/Fix
-- "Can you look into Y?" → Investigate → Resolve
-- "What's the best way to do Z?" → Decide → Implement best way
-- "Why is A broken?" / "I'm seeing error B" → Diagnose → Fix
-- "What do you think about C?" → Evaluate → Implement best option
-
-**Pure question (NO action) ONLY when ALL of these are true:**
-- User explicitly says "just explain" / "don't change anything" / "I'm just curious"
-- No actionable codebase context in the message
-- No problem, bug, or improvement is mentioned or implied
-
-**DEFAULT: Message implies action unless explicitly stated otherwise.**`
-}
-
-// ----------------------------------------------------------------
-// Public API
-// ----------------------------------------------------------------
-
-export function buildIntentGate(role: IntentGateRole): string {
-  if (role === "router") {
-    return buildRouterIntentGate()
-  }
-  return buildExecutorIntentGate()
-}
+/**
+ * Unified Intent Gate — shared source of truth for router (Bob) and executor (Coder/Sub).
+ *
+ * Router: full intent classification with verbalization mandate + routing hints.
+ * Executor: compressed intent mapping — no "I detect..." verbalization, just action.
+ *
+ * Token reduction: table→bullets saves ~2KB; executor no-verbalize saves ~500B.
+ */
+
+export type IntentGateRole = "router" | "executor"
+
+// ----------------------------------------------------------------
+// Router variant — Bob orchestrator
+// ----------------------------------------------------------------
+
+function buildRouterIntentGate(): string {
+  return `<intent_verbalization>
+### Step 0: Verbalize Intent (BEFORE Classification)
+
+Identify what the user actually wants. Map surface form to true intent, then announce routing out loud.
+
+**Surface → Intent (act on TRUE intent, not surface):**
+- "explain X / how does Y work" → research → synthesize → answer
+- "implement X / add Y / create Z" → plan → delegate or execute
+- "look into X / investigate Y" → researcher → findings → wait
+- "what do you think about X?" → evaluate → propose → wait for confirmation
+- "X is broken / seeing error Y" → diagnose → fix minimally
+- "refactor / improve / clean up" → assess codebase → propose approach
+
+**Verbalize before proceeding:**
+
+> "I detect [research / implementation / investigation / evaluation / fix / open-ended] intent - [reason]. My approach: [researcher → answer / strategist plan → delegate / clarify first / etc.]."
+
+This verbalization anchors your routing decision. It does NOT commit you to implementation — only the user's explicit request does.
+</intent_verbalization>
+
+### Step 1: Classify Request Type
+
+- **Trivial** (single file, known location, direct answer) → Direct tools only (UNLESS Key Trigger applies)
+- **Explicit** (specific file/line, clear command) → Execute directly
+- **Exploratory** ("How does X work?", "Find Y") → Fire researcher (1-3) + tools in parallel
+- **Open-ended** ("Improve", "Refactor", "Add feature") → Assess codebase first
+- **Ambiguous** (unclear scope, multiple interpretations) → Ask ONE clarifying question
+
+### Step 1.5: Turn-Local Intent Reset
+
+- Reclassify intent from the CURRENT message only. Never auto-carry "implementation mode" from prior turns.
+- If current message is a question/explanation/investigation request → answer/analyze only, do NOT create todos or edit files.
+- If user is still giving context or constraints → gather/confirm first, do NOT start implementation yet.
+
+### Step 2: Check for Ambiguity
+
+- Single valid interpretation → Proceed
+- Multiple interpretations, similar effort → Proceed with reasonable default, note assumption
+- Multiple interpretations, 2x+ effort difference → **MUST ask**
+- Missing critical info (file, error, context) → **MUST ask**
+- User's design seems flawed or suboptimal → **MUST raise concern** before implementing
+
+### Step 2.5: Context-Completion Gate (BEFORE Implementation)
+
+You may implement only when ALL are true:
+1. Current message has an explicit implementation verb (implement/add/create/fix/change/write).
+2. Scope/objective is sufficiently concrete to execute without guessing.
+3. No blocking specialist result is pending (especially Strategist/Critic).
+
+If any condition fails → research/clarify only, then wait.
+
+### Step 3: Validate Before Acting
+
+**Assumptions Check:**
+- Do I have any implicit assumptions that might affect the outcome?
+- Is the search scope clear?
+
+**Delegation Check (before acting directly):**
+1. Specialized agent perfectly matches → delegate
+2. Task category + skills fit → \`task(category=..., load_skills=[...])\`
+3. Bounded low-risk edit → route to \`sub\`, not \`coder\`
+4. Trivial local work → do directly
+
+**Default Bias: DELEGATE. Direct work only when trivially local.**
+
+### When to Challenge the User
+
+If you observe:
+- A design decision that will cause obvious problems
+- An approach that contradicts established patterns in the codebase
+- A request that seems to misunderstand how the existing code works
+
+Then: Raise your concern concisely. Propose an alternative. Ask if they want to proceed anyway.
+
+\`\`\`
+I notice [observation]. This might cause [problem] because [reason].
+Alternative: [your suggestion].
+Should I proceed with your original request, or try the alternative?
+\`\`\``
+}
+
+// ----------------------------------------------------------------
+// Executor variant — Coder / Sub autonomous deep worker
+// ----------------------------------------------------------------
+
+function buildExecutorIntentGate(): string {
+  return `### Do NOT Ask - Just Do
+
+**FORBIDDEN:**
+- Asking permission ("Should I proceed?", "Would you like me to...?") → JUST DO IT.
+- "Do you want me to run tests?" → RUN THEM.
+- "I noticed Y, should I fix it?" → FIX IT OR NOTE IN FINAL MESSAGE.
+- Stopping after partial implementation → 100% OR NOTHING.
+- Answering a question then stopping → The question implies action. DO THE ACTION.
+- "I'll do X" then ending turn → You COMMITTED to X. DO X NOW before ending.
+- Explaining findings without acting → ACT immediately.
+
+**CORRECT:**
+- Keep going until COMPLETELY done
+- Run verification (lint, tests, build) WITHOUT asking
+- Make decisions. Course-correct only on CONCRETE failure
+- Note assumptions in final message, not as questions mid-work
+- Need context? Fire Researcher via \`call_omo_agent\` IMMEDIATELY — continue only with non-overlapping work while it searches
+- User asks a question implying work → Answer briefly, DO the implied work in the same turn
+
+### Executor Intent Mapping
+
+**Surface → Intent (act on TRUE intent, not surface):**
+- "Did you do X?" (and you didn't) → Acknowledge → DO X immediately
+- "How does X work?" → Explore → Implement/Fix
+- "Can you look into Y?" → Investigate → Resolve
+- "What's the best way to do Z?" → Decide → Implement best way
+- "Why is A broken?" / "I'm seeing error B" → Diagnose → Fix
+- "What do you think about C?" → Evaluate → Implement best option
+
+**Pure question (NO action) ONLY when ALL of these are true:**
+- User explicitly says "just explain" / "don't change anything" / "I'm just curious"
+- No actionable codebase context in the message
+- No problem, bug, or improvement is mentioned or implied
+
+**DEFAULT: Message implies action unless explicitly stated otherwise.**`
+}
+
+// ----------------------------------------------------------------
+// Public API
+// ----------------------------------------------------------------
+
+export function buildIntentGate(role: IntentGateRole): string {
+  if (role === "router") {
+    return buildRouterIntentGate()
+  }
+  return buildExecutorIntentGate()
+}

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

@@ -1,60 +1,60 @@
-import type {
-  AvailableAgent,
-  AvailableCategory,
-  AvailableTool,
-} from "../dynamic-agent-prompt-types";
-import { getToolsPromptDisplay } from "../dynamic-agent-tool-categorization";
-
-export function buildKeyTriggersSection(agents: AvailableAgent[]): 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[] = [],
-): 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] ?? 0) - (costOrder[right.metadata.cost] ?? 0),
-    );
-
-  for (const agent of sortedAgents) {
-    const shortDescription = agent.description.split(".")[0] || agent.description;
-    rows.push(
-      `- \`${agent.name}\` agent - **${agent.metadata.cost}** - ${shortDescription}`,
-    );
-  }
-
-  return rows.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");
-}
+import type {
+  AvailableAgent,
+  AvailableCategory,
+  AvailableTool,
+} from "../dynamic-agent-prompt-types";
+import { getToolsPromptDisplay } from "../dynamic-agent-tool-categorization";
+
+export function buildKeyTriggersSection(agents: AvailableAgent[]): 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[] = [],
+): 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] ?? 0) - (costOrder[right.metadata.cost] ?? 0),
+    );
+
+  for (const agent of sortedAgents) {
+    const shortDescription = agent.description.split(".")[0] || agent.description;
+    rows.push(
+      `- \`${agent.name}\` agent - **${agent.metadata.cost}** - ${shortDescription}`,
+    );
+  }
+
+  return rows.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");
+}

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

@@ -1,36 +1,36 @@
-import { platformAgents } from "../platform-adapter";
-
-export function buildPlatformManagerPrompt(): string {
-  const ledger = platformAgents["ledger-creator"]?.prompt || "";
-  const bootstrapper = platformAgents["bootstrapper"]?.prompt || "";
-  const initializer = platformAgents["project-initializer"]?.prompt || "";
-  const mindmodel = platformAgents["mindmodel"]?.prompt || "";
-
-  return `
-<Platform_Manager_Identity>
-# Platform Manager
-You are the Unified Platform Manager, responsible for orchestration, session continuity, and project initialization.
-You consolidate the capabilities of the Ledger Creator, Bootstrapper, Project Initializer, and Mindmodel Orchestrator.
-</Platform_Manager_Identity>
-
-<Capability_Ledger>
-## Mode: Session Continuity (Ledger)
-${ledger}
-</Capability_Ledger>
-
-<Capability_Exploration>
-## Mode: Exploration & Brainstorming (Bootstrapper)
-${bootstrapper}
-</Capability_Exploration>
-
-<Capability_Initialization>
-## Mode: Project Initialization
-${initializer}
-</Capability_Initialization>
-
-<Capability_Mindmodel>
-## Mode: Mindmodel Orchestration
-${mindmodel}
-</Capability_Mindmodel>
-`;
-}
+import { platformAgents } from "../platform-adapter";
+
+export function buildPlatformManagerPrompt(): string {
+  const ledger = platformAgents["ledger-creator"]?.prompt || "";
+  const bootstrapper = platformAgents["bootstrapper"]?.prompt || "";
+  const initializer = platformAgents["project-initializer"]?.prompt || "";
+  const mindmodel = platformAgents["mindmodel"]?.prompt || "";
+
+  return `
+<Platform_Manager_Identity>
+# Platform Manager
+You are the Unified Platform Manager, responsible for orchestration, session continuity, and project initialization.
+You consolidate the capabilities of the Ledger Creator, Bootstrapper, Project Initializer, and Mindmodel Orchestrator.
+</Platform_Manager_Identity>
+
+<Capability_Ledger>
+## Mode: Session Continuity (Ledger)
+${ledger}
+</Capability_Ledger>
+
+<Capability_Exploration>
+## Mode: Exploration & Brainstorming (Bootstrapper)
+${bootstrapper}
+</Capability_Exploration>
+
+<Capability_Initialization>
+## Mode: Project Initialization
+${initializer}
+</Capability_Initialization>
+
+<Capability_Mindmodel>
+## Mode: Mindmodel Orchestration
+${mindmodel}
+</Capability_Mindmodel>
+`;
+}

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

@@ -1,39 +1,39 @@
-import type { AvailableAgent } from "../dynamic-agent-prompt-types";
-
-export type ResearcherMode = "internal" | "external" | "both";
-
-/**
- * Specialized researcher section builder.
- * The canonical buildResearcherSection lives in dynamic-agent-core-sections.ts;
- * this module exists for specialized/complementary researcher descriptions
- * when mode-specific variants are needed.
- */
-export function buildResearcherSection(
-  agents: AvailableAgent[],
-  mode: ResearcherMode = "both",
-): string {
-  const researcherAgent = agents.find((agent) => agent.name === "researcher");
-  if (!researcherAgent) return "";
-
-  const useWhen = researcherAgent.metadata.useWhen || [];
-
-  if (mode === "internal") {
-    return `### Researcher = Internal Codebase Discovery
-Use it for discovery in this repo.
-${useWhen.map((entry) => `- ${entry}`).join("\n")}`;
-  }
-
-  if (mode === "external") {
-    return `### Researcher = External Docs and OSS Research
-Search official references, API docs, OSS examples, and the web when needed.
-${useWhen.map((entry) => `- "${entry}"`).join("\n")}`;
-  }
-
-  // "both" mode — use the canonical full section from dynamic-agent-core-sections.ts
-  // This function is provided for callers that need mode-specific variants.
-  // For the full researcher description, import buildResearcherSection from
-  // dynamic-agent-core-sections.ts directly.
-  return `### Researcher = Internal + External Research
-Use it for both codebase discovery (internal) and external docs/OSS research.
-${useWhen.map((entry) => `- ${entry}`).join("\n")}`;
-}
+import type { AvailableAgent } from "../dynamic-agent-prompt-types";
+
+export type ResearcherMode = "internal" | "external" | "both";
+
+/**
+ * Specialized researcher section builder.
+ * The canonical buildResearcherSection lives in dynamic-agent-core-sections.ts;
+ * this module exists for specialized/complementary researcher descriptions
+ * when mode-specific variants are needed.
+ */
+export function buildResearcherSection(
+  agents: AvailableAgent[],
+  mode: ResearcherMode = "both",
+): string {
+  const researcherAgent = agents.find((agent) => agent.name === "researcher");
+  if (!researcherAgent) return "";
+
+  const useWhen = researcherAgent.metadata.useWhen || [];
+
+  if (mode === "internal") {
+    return `### Researcher = Internal Codebase Discovery
+Use it for discovery in this repo.
+${useWhen.map((entry) => `- ${entry}`).join("\n")}`;
+  }
+
+  if (mode === "external") {
+    return `### Researcher = External Docs and OSS Research
+Search official references, API docs, OSS examples, and the web when needed.
+${useWhen.map((entry) => `- "${entry}"`).join("\n")}`;
+  }
+
+  // "both" mode — use the canonical full section from dynamic-agent-core-sections.ts
+  // This function is provided for callers that need mode-specific variants.
+  // For the full researcher description, import buildResearcherSection from
+  // dynamic-agent-core-sections.ts directly.
+  return `### Researcher = Internal + External Research
+Use it for both codebase discovery (internal) and external docs/OSS research.
+${useWhen.map((entry) => `- ${entry}`).join("\n")}`;
+}