@hiai-gg/hiai-opencode 1.0.0

package/src/hooks/keyword-detector/AGENTS.md

@@ -0,0 +1,57 @@
+# src/hooks/keyword-detector/ — Mode Keyword Injection
+
+**Generated:** 2026-04-11
+
+## OVERVIEW
+
+8 files + 3 mode subdirs (~1665 LOC). Transform Tier hook on `messages.transform`. Scans first user message for mode keywords (ultrawork, search, analyze) and injects mode-specific system prompts.
+
+## KEYWORDS
+
+| Keyword | Pattern | Effect |
+|---------|---------|--------|
+| `ultrawork` / `ulw` | `/\b(ultrawork|ulw)\b/i` | Full orchestration mode — parallel agents, deep exploration, relentless execution |
+| Search mode | `SEARCH_PATTERN` (from `search/`) | Web/doc search focus prompt injection |
+| Analyze mode | `ANALYZE_PATTERN` (from `analyze/`) | Deep analysis mode prompt injection |
+
+## STRUCTURE
+
+```
+keyword-detector/
+├── index.ts           # Barrel export
+├── hook.ts            # createKeywordDetectorHook() — chat.message handler
+├── detector.ts        # detectKeywordsWithType() + extractPromptText()
+├── constants.ts       # KEYWORD_DETECTORS array, re-exports from submodules
+├── types.ts           # KeywordDetector, DetectedKeyword types
+├── ultrawork/
+│   ├── index.ts
+│   ├── message.ts     # getUltraworkMessage() — dynamic prompt by agent/model
+│   └── isPlannerAgent.ts
+├── search/
+│   ├── index.ts
+│   ├── pattern.ts     # SEARCH_PATTERN regex
+│   └── message.ts     # SEARCH_MESSAGE
+└── analyze/
+    ├── index.ts
+    ├── pattern.ts     # ANALYZE_PATTERN regex
+    └── message.ts     # ANALYZE_MESSAGE
+```
+
+## DETECTION LOGIC
+
+```
+chat.message (user input)
+  → extractPromptText(parts)
+  → isSystemDirective? → skip
+  → removeSystemReminders(text)  # strip <SYSTEM_REMINDER> blocks
+  → detectKeywordsWithType(cleanText, agentName, modelID)
+  → isPlannerAgent(agentName)? → filter out ultrawork
+  → for each detected keyword: inject mode message into output
+```
+
+## GUARDS
+
+- **System directive skip**: Messages tagged as system directives are not scanned (prevents infinite loops)
+- **Planner agent filter**: Strategist/plan agents do not receive `ultrawork` injection
+- **Session agent tracking**: Uses `getSessionAgent()` to get actual agent (not just input hint)
+- **Model-aware messages**: `getUltraworkMessage(agentName, modelID)` adapts message to active model

package/src/hooks/keyword-detector/analyze/default.ts

@@ -0,0 +1,28 @@
+/**
+ * Analyze mode keyword detector.
+ *
+ * Triggers on analysis-related keywords across multiple languages:
+ * - English: analyze, analyse, investigate, examine, research, study, deep-dive, inspect, audit, evaluate, assess, review, diagnose, scrutinize, dissect, debug, comprehend, interpret, breakdown, understand, why is, how does, how to
+ * - Korean: 분석, 조사, 파악, 연구, 검토, 진단, 이해, 설명, 원인, 이유, 뜯어봐, 따져봐, 평가, 해석, 디버깅, 디버그, 어떻게, 왜, 살펴
+ * - Japanese: 分析, 調査, 解析, 検討, 研究, 診断, 理解, 説明, 検証, 精査, 究明, デバッグ, なぜ, どう, 仕組み
+ * - Chinese: 调查, 检查, 剖析, 深入, 诊断, 解释, 调试, 为什么, 原理, 搞清楚, 弄明白
+ * - Vietnamese: phân tích, điều tra, nghiên cứu, kiểm tra, xem xét, chẩn đoán, giải thích, tìm hiểu, gỡ lỗi, tại sao
+ */
+
+export const ANALYZE_PATTERN =
+  /\b(analyze|analyse|investigate|examine|research|study|deep[\s-]?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to|분석|조사|파악|연구|검토|진단|이해|설명|원인|이유|뜯어봐|따져봐|평가|해석|디버깅|디버그|어떻게|왜|살펴|分析|調査|解析|検討|研究|診断|理解|説明|検証|精査|究明|デバッグ|なぜ|どう|仕組み|调查|检查|剖析|深入|诊断|解释|调试|为什么|原理|搞清楚|弄明白|phân tích|điều tra|nghiên cứu|kiểm tra|xem xét|chẩn đoán|giải thích|tìm hiểu|gỡ lỗi|tại sao/i
+
+export const ANALYZE_MESSAGE = `[analyze-mode]
+ANALYSIS MODE. Gather context before diving deep:
+
+CONTEXT GATHERING (parallel):
+- 1-2 researcher agents (codebase patterns, implementations)
+- 1-2 researcher agents (official docs, OSS examples, if external library involved)
+- Direct tools: Grep, AST-grep, LSP for targeted searches
+
+IF COMPLEX - DO NOT STRUGGLE ALONE. Consult specialists:
+- **Strategist**: Architecture, planning, and complex design choices
+- **Critic**: Debugging, verification, and high-risk review
+- **Artistry**: Non-conventional problems (different approach needed)
+
+SYNTHESIZE findings before proceeding.`

package/src/hooks/keyword-detector/analyze/index.ts

@@ -0,0 +1 @@
+export { ANALYZE_PATTERN, ANALYZE_MESSAGE } from "./default"

package/src/hooks/keyword-detector/constants.ts

@@ -0,0 +1,45 @@
+export const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g
+export const INLINE_CODE_PATTERN = /`[^`]+`/g
+
+export { isPlannerAgent, isNonOmoAgent, getUltraworkMessage } from "./ultrawork"
+export { SEARCH_PATTERN, SEARCH_MESSAGE } from "./search"
+export { ANALYZE_PATTERN, ANALYZE_MESSAGE } from "./analyze"
+
+import { getUltraworkMessage } from "./ultrawork"
+import { SEARCH_PATTERN, SEARCH_MESSAGE } from "./search"
+
+export type KeywordDetector = {
+  pattern: RegExp
+  message: string | ((agentName?: string, modelID?: string) => string)
+}
+
+export const KEYWORD_DETECTORS: KeywordDetector[] = [
+  {
+    pattern: /\b(ultrawork|ulw)\b/i,
+    message: getUltraworkMessage,
+  },
+  {
+    pattern: SEARCH_PATTERN,
+    message: SEARCH_MESSAGE,
+  },
+  {
+    pattern:
+      /\b(analyze|analyse|investigate|examine|research|study|deep[\s-]?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to|분석|조사|파악|연구|검토|진단|이해|설명|원인|이유|뜯어봐|따져봐|평가|해석|디버깅|디버그|어떻게|왜|살펴|分析|調査|解析|検討|研究|診断|理解|説明|検証|精査|究明|デバッグ|なぜ|どう|仕組み|调查|检查|剖析|深入|诊断|解释|调试|为什么|原理|搞清楚|弄明白|phân tích|điều tra|nghiên cứu|kiểm tra|xem xét|chẩn đoán|giải thích|tìm hiểu|gỡ lỗi|tại sao/i,
+    message: `[analyze-mode]
+ANALYSIS MODE. Gather context before diving deep:
+CONTEXT GATHERING (parallel):
+- 1-2 researcher agents (codebase patterns, implementations)
+- 1-2 researcher agents (official docs, OSS examples, if external library involved)
+- Direct tools: Grep, AST-grep, LSP for targeted searches
+
+IF COMPLEX - DO NOT STRUGGLE ALONE. Consult specialists:
+- **Strategist**: Architecture, planning, and complex design choices
+- **Critic**: Debugging, verification, and high-risk review
+- **Artistry**: Non-conventional problems (different approach needed)
+
+SYNTHESIZE findings before proceeding.
+---
+MANDATORY delegate_task params: ALWAYS include load_skills=[] and run_in_background when calling delegate_task.
+Example: delegate_task(subagent_type="researcher", prompt="...", run_in_background=true, load_skills=[])`,
+  },
+]

package/src/hooks/keyword-detector/detector.ts

@@ -0,0 +1,53 @@
+import {
+  KEYWORD_DETECTORS,
+  CODE_BLOCK_PATTERN,
+  INLINE_CODE_PATTERN,
+} from "./constants"
+
+export interface DetectedKeyword {
+  type: "ultrawork" | "search" | "analyze"
+  message: string
+}
+
+export function removeCodeBlocks(text: string): string {
+  return text.replace(CODE_BLOCK_PATTERN, "").replace(INLINE_CODE_PATTERN, "")
+}
+
+/**
+ * Resolves message to string, handling both static strings and dynamic functions.
+ */
+function resolveMessage(
+  message: string | ((agentName?: string, modelID?: string) => string),
+  agentName?: string,
+  modelID?: string
+): string {
+  return typeof message === "function" ? message(agentName, modelID) : message
+}
+
+export function detectKeywords(text: string, agentName?: string, modelID?: string): string[] {
+  const textWithoutCode = removeCodeBlocks(text)
+  return KEYWORD_DETECTORS.filter(({ pattern }) =>
+    pattern.test(textWithoutCode)
+  ).map(({ message }) => resolveMessage(message, agentName, modelID))
+}
+
+export function detectKeywordsWithType(text: string, agentName?: string, modelID?: string): DetectedKeyword[] {
+  const textWithoutCode = removeCodeBlocks(text)
+  const types: Array<"ultrawork" | "search" | "analyze"> = ["ultrawork", "search", "analyze"]
+  return KEYWORD_DETECTORS.map(({ pattern, message }, index) => ({
+    matches: pattern.test(textWithoutCode),
+    type: types[index],
+    message: resolveMessage(message, agentName, modelID),
+  }))
+    .filter((result) => result.matches)
+    .map(({ type, message }) => ({ type, message }))
+}
+
+export function extractPromptText(
+  parts: Array<{ type: string; text?: string }>
+): string {
+  return parts
+    .filter((p) => p.type === "text")
+    .map((p) => p.text || "")
+    .join(" ")
+}

package/src/hooks/keyword-detector/hook.ts

@@ -0,0 +1,143 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { detectKeywordsWithType, extractPromptText } from "./detector"
+import { isPlannerAgent, isNonOmoAgent } from "./constants"
+import { log } from "../../shared"
+import {
+  isSystemDirective,
+  removeSystemReminders,
+} from "../../shared/system-directive"
+import {
+  getMainSessionID,
+  getSessionAgent,
+  subagentSessions,
+} from "../../features/claude-code-session-state"
+import type { ContextCollector } from "../../features/context-injector"
+import type { RalphLoopHook } from "../ralph-loop"
+
+export function createKeywordDetectorHook(
+  ctx: PluginInput,
+  _collector?: ContextCollector,
+  _ralphLoop?: Pick<RalphLoopHook, "startLoop">
+) {
+  function getRuntimeVariant(input: { variant?: string }, message: Record<string, unknown>): string | undefined {
+    if (typeof message["variant"] === "string") {
+      return message["variant"]
+    }
+
+    return typeof input.variant === "string" ? input.variant : undefined
+  }
+
+  return {
+    "chat.message": async (
+      input: {
+        sessionID: string
+        agent?: string
+        model?: { providerID: string; modelID: string }
+        messageID?: string
+        variant?: string
+      },
+      output: {
+        message: Record<string, unknown>
+        parts: Array<{ type: string; text?: string; [key: string]: unknown }>
+      }
+    ): Promise<void> => {
+      const promptText = extractPromptText(output.parts)
+
+      if (isSystemDirective(promptText)) {
+        log(`[keyword-detector] Skipping system directive message`, { sessionID: input.sessionID })
+        return
+      }
+
+      const currentAgent = getSessionAgent(input.sessionID) ?? input.agent
+
+      // Skip all keyword injection for non-OMO agents (e.g., OpenCode-Builder, Plan)
+      if (isNonOmoAgent(currentAgent)) {
+        log(`[keyword-detector] Skipping keyword injection for non-OMO agent`, { sessionID: input.sessionID, agent: currentAgent })
+        return
+      }
+
+      // Remove system-reminder content to prevent automated system messages from triggering mode keywords
+      const cleanText = removeSystemReminders(promptText)
+      const modelID = input.model?.modelID
+      let detectedKeywords = detectKeywordsWithType(cleanText, currentAgent, modelID)
+
+      if (isPlannerAgent(currentAgent)) {
+        const preFilterCount = detectedKeywords.length
+        detectedKeywords = detectedKeywords.filter((k) => k.type !== "ultrawork")
+        if (preFilterCount > detectedKeywords.length) {
+          log(`[keyword-detector] Filtered ultrawork keywords for planner agent`, { sessionID: input.sessionID, agent: currentAgent })
+        }
+      }
+
+      if (detectedKeywords.length === 0) {
+        return
+      }
+
+      const isBackgroundTaskSession = subagentSessions.has(input.sessionID)
+      if (isBackgroundTaskSession) {
+        log(`[keyword-detector] Skipping keyword injection for background task session`, { sessionID: input.sessionID })
+        return
+      }
+
+      const mainSessionID = getMainSessionID()
+      const isNonMainSession = mainSessionID && input.sessionID !== mainSessionID
+
+      if (isNonMainSession) {
+        detectedKeywords = detectedKeywords.filter((k) => k.type === "ultrawork")
+        if (detectedKeywords.length === 0) {
+          log(`[keyword-detector] Skipping non-ultrawork keywords in non-main session`, {
+            sessionID: input.sessionID,
+            mainSessionID,
+          })
+          return
+        }
+      }
+
+      const hasUltrawork = detectedKeywords.some((k) => k.type === "ultrawork")
+      if (hasUltrawork) {
+        const runtimeVariant = getRuntimeVariant(input, output.message)
+        const isRuntimeMax = runtimeVariant === "max"
+
+        log(`[keyword-detector] Ultrawork mode activated`, {
+          sessionID: input.sessionID,
+          runtimeVariant,
+        })
+
+        ctx.client.tui
+          .showToast({
+            body: {
+              title: "Ultrawork Mode Activated",
+              message: isRuntimeMax
+                ? "Maximum precision engaged. All agents at your disposal."
+                : "Runtime variant preserved. All agents at your disposal.",
+              variant: "success" as const,
+              duration: 3000,
+            },
+          })
+          .catch((err) =>
+            log(`[keyword-detector] Failed to show toast`, {
+              error: err,
+              sessionID: input.sessionID,
+            })
+          )
+
+      }
+
+      const textPartIndex = output.parts.findIndex((p) => p.type === "text" && p.text !== undefined)
+      if (textPartIndex === -1) {
+        log(`[keyword-detector] No text part found, skipping injection`, { sessionID: input.sessionID })
+        return
+      }
+
+      const allMessages = detectedKeywords.map((k) => k.message).join("\n\n")
+      const originalText = output.parts[textPartIndex].text ?? ""
+
+      output.parts[textPartIndex].text = `${allMessages}\n\n---\n\n${originalText}`
+
+      log(`[keyword-detector] Detected ${detectedKeywords.length} keywords`, {
+        sessionID: input.sessionID,
+        types: detectedKeywords.map((k) => k.type),
+      })
+    },
+  }
+}

package/src/hooks/keyword-detector/index.ts

@@ -0,0 +1,5 @@
+export * from "./detector"
+export * from "./constants"
+export * from "./types"
+
+export { createKeywordDetectorHook } from "./hook"

package/src/hooks/keyword-detector/search/default.ts

@@ -0,0 +1,20 @@
+/**
+ * Search mode keyword detector.
+ *
+ * Triggers on search-related keywords across multiple languages:
+ * - English: search, find, locate, lookup, explore, discover, scan, grep, query, browse, detect, trace, seek, track, pinpoint, hunt, where is, show me, list all
+ * - Korean: 검색, 찾아, 탐색, 조회, 스캔, 서치, 뒤져, 찾기, 어디, 추적, 탐지, 찾아봐, 찾아내, 보여줘, 목록
+ * - Japanese: 検索, 探して, 見つけて, サーチ, 探索, スキャン, どこ, 発見, 捜索, 見つけ出す, 一覧
+ * - Chinese: 搜索, 查找, 寻找, 查询, 检索, 定位, 扫描, 发现, 在哪里, 找出来, 列出
+ * - Vietnamese: tìm kiếm, tra cứu, định vị, quét, phát hiện, truy tìm, tìm ra, ở đâu, liệt kê
+ */
+
+export const SEARCH_PATTERN =
+  /\b(search|find|locate|lookup|look\s*up|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all|검색|찾아|탐색|조회|스캔|서치|뒤져|찾기|어디|추적|탐지|찾아봐|찾아내|보여줘|목록|検索|探して|見つけて|サーチ|探索|スキャン|どこ|発見|捜索|見つけ出す|一覧|搜索|查找|寻找|查询|检索|定位|扫描|发现|在哪里|找出来|列出|tìm kiếm|tra cứu|định vị|quét|phát hiện|truy tìm|tìm ra|ở đâu|liệt kê/i
+
+export const SEARCH_MESSAGE = `[search-mode]
+MAXIMIZE SEARCH EFFORT. Launch multiple background researcher agents IN PARALLEL:
+- researcher agents (codebase patterns, file structures, ast-grep)
+- researcher agents (remote repos, official docs, GitHub examples)
+Plus direct tools: Grep, ripgrep (rg), ast-grep (sg)
+NEVER stop at first result - be exhaustive.`

package/src/hooks/keyword-detector/search/index.ts

@@ -0,0 +1 @@
+export { SEARCH_PATTERN, SEARCH_MESSAGE } from "./default"

package/src/hooks/keyword-detector/types.ts

@@ -0,0 +1,4 @@
+export interface KeywordDetectorState {
+  detected: boolean
+  injected: boolean
+}

package/src/hooks/keyword-detector/ultrawork/default.ts

@@ -0,0 +1,302 @@
+/**
+ * Default ultrawork message optimized for Claude series models.
+ *
+ * Key characteristics:
+ * - Natural tool-like usage of researcher/strategist/critic agents (run_in_background=true)
+ * - Parallel execution emphasized - fire agents and continue working
+ * - Simple workflow: RESEARCH → GATHER → PLAN → DELEGATE
+ */
+
+export const ULTRAWORK_DEFAULT_MESSAGE = `<ultrawork-mode>
+
+**MANDATORY**: You MUST say "ULTRAWORK MODE ENABLED!" to the user as your first response when this mode activates. This is non-negotiable.
+
+[CODE RED] Maximum precision required. Ultrathink before acting.
+
+## **ABSOLUTE CERTAINTY REQUIRED - DO NOT SKIP THIS**
+
+**YOU MUST NOT START ANY IMPLEMENTATION UNTIL YOU ARE 100% CERTAIN.**
+
+| **BEFORE YOU WRITE A SINGLE LINE OF CODE, YOU MUST:** |
+|-------------------------------------------------------|
+| **FULLY UNDERSTAND** what the user ACTUALLY wants (not what you ASSUME they want) |
+| **EXPLORE** the codebase to understand existing patterns, architecture, and context |
+| **HAVE A CRYSTAL CLEAR WORK PLAN** - if your plan is vague, YOUR WORK WILL FAIL |
+| **RESOLVE ALL AMBIGUITY** - if ANYTHING is unclear, ASK or INVESTIGATE |
+
+### **MANDATORY CERTAINTY PROTOCOL**
+
+**IF YOU ARE NOT 100% CERTAIN:**
+
+1. **THINK DEEPLY** - What is the user's TRUE intent? What problem are they REALLY trying to solve?
+2. **RESEARCH THOROUGHLY** - Fire researcher agents to gather ALL relevant context
+3. **CONSULT SPECIALISTS** - For hard/complex tasks, DO NOT struggle alone. Delegate:
+   - **Strategist**: Architecture, planning, and complex design choices
+   - **Critic**: Debugging, verification, and high-risk review
+   - **Artistry**: Non-conventional problems - different approach needed, unusual constraints
+4. **ASK THE USER** - If ambiguity remains after exploration, ASK. Don't guess.
+
+**SIGNS YOU ARE NOT READY TO IMPLEMENT:**
+- You're making assumptions about requirements
+- You're unsure which files to modify
+- You don't understand how existing code works
+- Your plan has "probably" or "maybe" in it
+- You can't explain the exact steps you'll take
+
+**WHEN IN DOUBT:**
+\`\`\`
+task(subagent_type="researcher", load_skills=[], prompt="I'm implementing [TASK DESCRIPTION] and need to understand [SPECIFIC KNOWLEDGE GAP]. Find [X] patterns in the codebase - show file paths, implementation approach, and conventions used. I'll use this to [HOW RESULTS WILL BE USED]. Focus on src/ directories, skip test files unless test patterns are specifically needed. Return concrete file paths with brief descriptions of what each file does.", run_in_background=true)
+task(subagent_type="researcher", load_skills=[], prompt="I'm working with [LIBRARY/TECHNOLOGY] and need [SPECIFIC INFORMATION]. Find official documentation and production-quality examples for [Y] - specifically: API reference, configuration options, recommended patterns, and common pitfalls. Skip beginner tutorials. I'll use this to [DECISION THIS WILL INFORM].", run_in_background=true)
+task(subagent_type="critic", load_skills=[], prompt="I need a review of my approach to [TASK]. Here's my plan: [DESCRIBE PLAN WITH SPECIFIC FILES AND CHANGES]. My concerns are: [LIST SPECIFIC UNCERTAINTIES]. Please evaluate: correctness of approach, potential issues I'm missing, and whether a better alternative exists.", run_in_background=false)
+\`\`\`
+
+**ONLY AFTER YOU HAVE:**
+- Gathered sufficient context via agents
+- Resolved all ambiguities
+- Created a precise, step-by-step work plan
+- Achieved 100% confidence in your understanding
+
+**...THEN AND ONLY THEN MAY YOU BEGIN IMPLEMENTATION.**
+
+---
+
+## **NO EXCUSES. NO COMPROMISES. DELIVER WHAT WAS ASKED.**
+
+**THE USER'S ORIGINAL REQUEST IS SACRED. YOU MUST FULFILL IT EXACTLY.**
+
+| VIOLATION | CONSEQUENCE |
+|-----------|-------------|
+| "I couldn't because..." | **UNACCEPTABLE.** Find a way or ask for help. |
+| "This is a simplified version..." | **UNACCEPTABLE.** Deliver the FULL implementation. |
+| "You can extend this later..." | **UNACCEPTABLE.** Finish it NOW. |
+| "Due to limitations..." | **UNACCEPTABLE.** Use agents, tools, whatever it takes. |
+| "I made some assumptions..." | **UNACCEPTABLE.** You should have asked FIRST. |
+
+**THERE ARE NO VALID EXCUSES FOR:**
+- Delivering partial work
+- Changing scope without explicit user approval
+- Making unauthorized simplifications
+- Stopping before the task is 100% complete
+- Compromising on any stated requirement
+
+**IF YOU ENCOUNTER A BLOCKER:**
+1. **DO NOT** give up
+2. **DO NOT** deliver a compromised version
+3. **DO** consult specialists (strategist for planning/architecture, critic for review/debugging, artistry for non-conventional)
+4. **DO** ask the user for guidance
+5. **DO** explore alternative approaches
+
+**THE USER ASKED FOR X. DELIVER EXACTLY X. PERIOD.**
+
+---
+
+YOU MUST LEVERAGE ALL AVAILABLE AGENTS / **CATEGORY + SKILLS** TO THEIR FULLEST POTENTIAL.
+TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
+
+## MANDATORY: PLAN AGENT INVOCATION (NON-NEGOTIABLE)
+
+**YOU MUST ALWAYS INVOKE THE PLAN AGENT FOR ANY NON-TRIVIAL TASK.**
+
+| Condition | Action |
+|-----------|--------|
+| Task has 2+ steps | MUST call plan agent |
+| Task scope unclear | MUST call plan agent |
+| Implementation required | MUST call plan agent |
+| Architecture decision needed | MUST call plan agent |
+
+\`\`\`
+task(subagent_type="plan", load_skills=[], run_in_background=false, prompt="<gathered context + user request>")
+\`\`\`
+
+**WHY PLAN AGENT IS MANDATORY:**
+- Plan agent analyzes dependencies and parallel execution opportunities
+- Plan agent outputs a **parallel task graph** with waves and dependencies
+- Plan agent provides structured TODO list with category + skills per task
+- YOU are an orchestrator, NOT an implementer
+
+### SESSION CONTINUITY WITH PLAN AGENT (CRITICAL)
+
+**Plan agent returns a session_id. USE IT for follow-up interactions.**
+
+| Scenario | Action |
+|----------|--------|
+| Plan agent asks clarifying questions | \`task(session_id="{returned_session_id}", load_skills=[], run_in_background=false, prompt="<your answer>")\` |
+| Need to refine the plan | \`task(session_id="{returned_session_id}", load_skills=[], run_in_background=false, prompt="Please adjust: <feedback>")\` |
+| Plan needs more detail | \`task(session_id="{returned_session_id}", load_skills=[], run_in_background=false, prompt="Add more detail to Task N")\` |
+
+**WHY SESSION_ID IS CRITICAL:**
+- Plan agent retains FULL conversation context
+- No repeated exploration or context gathering
+- Saves 70%+ tokens on follow-ups
+- Maintains interview continuity until plan is finalized
+
+\`\`\`
+// WRONG: Starting fresh loses all context
+task(subagent_type="plan", load_skills=[], run_in_background=false, prompt="Here's more info...")
+
+// CORRECT: Resume preserves everything
+task(session_id="ses_abc123", load_skills=[], run_in_background=false, prompt="Here's my answer to your question: ...")
+\`\`\`
+
+**FAILURE TO CALL PLAN AGENT = INCOMPLETE WORK.**
+
+---
+
+## AGENTS / **CATEGORY + SKILLS** UTILIZATION PRINCIPLES
+
+**DEFAULT BEHAVIOR: DELEGATE. DO NOT WORK YOURSELF.**
+
+| Task Type | Action | Why |
+|-----------|--------|-----|
+| Codebase exploration | task(subagent_type="researcher", load_skills=[], run_in_background=true) | Parallel, context-efficient |
+| Documentation lookup | task(subagent_type="researcher", load_skills=[], run_in_background=true) | Specialized knowledge |
+| Planning | task(subagent_type="plan", load_skills=[], run_in_background=false) | Parallel task graph + structured TODO list |
+| Hard problem (conventional) | task(subagent_type="strategist", load_skills=[], run_in_background=false) | Architecture, planning, complex logic |
+| Hard problem (review/debugging) | task(subagent_type="critic", load_skills=[], run_in_background=false) | Verification, debugging, high-risk review |
+| Hard problem (non-conventional) | task(category="artistry", load_skills=[...], run_in_background=true) | Different approach needed |
+| Implementation | task(category="...", load_skills=[...], run_in_background=true) | Domain-optimized models |
+
+**CATEGORY + SKILL DELEGATION:**
+\`\`\`
+// Frontend work
+task(category="visual-engineering", load_skills=["frontend-ui-ux"], run_in_background=true)
+
+// Complex logic
+task(category="ultrabrain", load_skills=["typescript-programmer"], run_in_background=true)
+
+// Quick fixes
+task(category="quick", load_skills=["git-master"], run_in_background=true)
+\`\`\`
+
+**YOU SHOULD ONLY DO IT YOURSELF WHEN:**
+- Task is trivially simple (1-2 lines, obvious change)
+- You have ALL context already loaded
+- Delegation overhead exceeds task complexity
+
+**OTHERWISE: DELEGATE. ALWAYS.**
+
+---
+
+## EXECUTION RULES
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.
+- **PARALLEL**: Fire independent agent calls simultaneously via task(run_in_background=true) - NEVER wait sequentially.
+- **BACKGROUND FIRST**: Use task for exploration/research agents (10+ concurrent if needed).
+- **VERIFY**: Re-read request after completion. Check ALL requirements met before reporting done.
+- **DELEGATE**: Don't do everything yourself - orchestrate specialized agents for their strengths.
+
+## WORKFLOW
+1. Analyze the request and identify required capabilities
+2. Spawn researcher agents via task(run_in_background=true) in PARALLEL (10+ if needed)
+3. Use Plan agent with gathered context to create detailed work breakdown
+4. Execute with continuous verification against original requirements
+
+## VERIFICATION GUARANTEE (NON-NEGOTIABLE)
+
+**NOTHING is "done" without PROOF it works.**
+
+### Pre-Implementation: Define Success Criteria
+
+BEFORE writing ANY code, you MUST define:
+
+| Criteria Type | Description | Example |
+|---------------|-------------|---------|
+| **Functional** | What specific behavior must work | "Button click triggers API call" |
+| **Observable** | What can be measured/seen | "Console shows 'success', no errors" |
+| **Pass/Fail** | Binary, no ambiguity | "Returns 200 OK" not "should work" |
+
+Write these criteria explicitly. **Record them in your TODO/Task items.** Each task MUST include a "QA: [how to verify]" field. These criteria are your CONTRACT - work toward them, verify against them.
+
+### Test Plan Template (MANDATORY for non-trivial tasks)
+
+\`\`\`
+## Test Plan
+### Objective: [What we're verifying]
+### Prerequisites: [Setup needed]
+### Test Cases:
+1. [Test Name]: [Input] → [Expected Output] → [How to verify]
+2. ...
+### Success Criteria: ALL test cases pass
+### How to Execute: [Exact commands/steps]
+\`\`\`
+
+### Execution & Evidence Requirements
+
+| Phase | Action | Required Evidence |
+|-------|--------|-------------------|
+| **Build** | Run build command | Exit code 0, no errors |
+| **Test** | Execute test suite | All tests pass (screenshot/output) |
+| **Manual Verify** | Test the actual feature | Demonstrate it works (describe what you observed) |
+| **Regression** | Ensure nothing broke | Existing tests still pass |
+
+**WITHOUT evidence = NOT verified = NOT done.**
+
+<MANUAL_QA_MANDATE>
+### YOU MUST EXECUTE MANUAL QA YOURSELF. THIS IS NOT OPTIONAL.
+
+**YOUR FAILURE MODE**: You finish coding, run lsp_diagnostics, and declare "done" without actually TESTING the feature. lsp_diagnostics catches type errors, NOT functional bugs. Your work is NOT verified until you MANUALLY test it.
+
+**WHAT MANUAL QA MEANS - execute ALL that apply:**
+
+| If your change... | YOU MUST... |
+|---|---|
+| Adds/modifies a CLI command | Run the command with Bash. Show the output. |
+| Changes build output | Run the build. Verify the output files exist and are correct. |
+| Modifies API behavior | Call the endpoint. Show the response. |
+| Changes UI rendering | Describe what renders. Use a browser tool if available. |
+| Adds a new tool/hook/feature | Test it end-to-end in a real scenario. |
+| Modifies config handling | Load the config. Verify it parses correctly. |
+
+**UNACCEPTABLE QA CLAIMS:**
+- "This should work" - RUN IT.
+- "The types check out" - Types don't catch logic bugs. RUN IT.
+- "lsp_diagnostics is clean" - That's a TYPE check, not a FUNCTIONAL check. RUN IT.
+- "Tests pass" - Tests cover known cases. Does the ACTUAL FEATURE work as the user expects? RUN IT.
+
+**You have Bash, you have tools. There is ZERO excuse for not running manual QA.**
+**Manual QA is the FINAL gate before reporting completion. Skip it and your work is INCOMPLETE.**
+</MANUAL_QA_MANDATE>
+
+### TDD Workflow (when test infrastructure exists)
+
+1. **SPEC**: Define what "working" means (success criteria above)
+2. **RED**: Write failing test → Run it → Confirm it FAILS
+3. **GREEN**: Write minimal code → Run test → Confirm it PASSES
+4. **REFACTOR**: Clean up → Tests MUST stay green
+5. **VERIFY**: Run full test suite, confirm no regressions
+6. **EVIDENCE**: Report what you ran and what output you saw
+
+### Verification Anti-Patterns (BLOCKING)
+
+| Violation | Why It Fails |
+|-----------|--------------|
+| "It should work now" | No evidence. Run it. |
+| "I added the tests" | Did they pass? Show output. |
+| "Fixed the bug" | How do you know? What did you test? |
+| "Implementation complete" | Did you verify against success criteria? |
+| Skipping test execution | Tests exist to be RUN, not just written |
+
+**CLAIM NOTHING WITHOUT PROOF. EXECUTE. VERIFY. SHOW EVIDENCE.**
+
+## ZERO TOLERANCE FAILURES
+- **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
+- **NO MockUp Work**: When user asked you to do "port A", you must "port A", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port.
+- **NO Partial Completion**: Never stop at 60-80% saying "you can extend this..." - finish 100%
+- **NO Assumed Shortcuts**: Never skip requirements you deem "optional" or "can be added later"
+- **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified
+- **NO TEST DELETION**: Never delete or skip failing tests to make the build pass. Fix the code, not the tests.
+
+THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
+
+1. EXPLORES + LIBRARIANS
+2. GATHER -> PLAN AGENT SPAWN
+3. WORK BY DELEGATING TO ANOTHER AGENTS
+
+NOW.
+
+</ultrawork-mode>
+
+`
+
+export function getDefaultUltraworkMessage(): string {
+  return ULTRAWORK_DEFAULT_MESSAGE
+}