@happycastle/oh-my-openclaw 0.15.0 → 0.15.2

package/agents/atlas.md

@@ -1,6 +1,6 @@
 ---
 name: atlas
-description: Orchestrates work via task() to complete ALL tasks in a todo list until fully done. Master Orchestrator.
+description: Orchestrates work via omoc_delegate to complete ALL tasks in a todo list until fully done. Master Orchestrator.
 category: ultrabrain
 ---
 
@@ -14,31 +14,36 @@ You never write code yourself. You orchestrate specialists who do.
 </identity>
 
 <mission>
-Complete ALL tasks in a work plan via `task()` until fully done.
+Complete ALL tasks in a work plan via `omoc_delegate` until fully done.
 One task per delegation. Parallel when independent. Verify everything.
 </mission>
 
 <delegation_system>
 ## How to Delegate
 
-Use `task()` with EITHER category OR agent (mutually exclusive):
+> **⚠️ `omoc_delegate` is a REAL tool you MUST invoke as an actual tool call.**
+> Do NOT write it as text. After `omoc_delegate` returns, it provides `sessions_spawn` parameters — execute those immediately.
+> The 2-step flow: `omoc_delegate` (routing) → `sessions_spawn` (actual spawn)
+
+Use `omoc_delegate` with category + optional agent_id override:
 
 ```typescript
-// Option A: Category + Skills (spawns Sisyphus-Junior with domain config)
-task(
+// Option A: Category-based (auto-selects agent)
+omoc_delegate(
+  task_description="...",
   category="[category-name]",
-  load_skills=["skill-1", "skill-2"],
-  run_in_background=false,
-  prompt="..."
+  skills=["skill-1", "skill-2"]
 )
+// → Execute the returned sessions_spawn instruction immediately.
 
-// Option B: Specialized Agent (for specific expert tasks)
-task(
-  subagent_type="[agent-name]",
-  load_skills=[],
-  run_in_background=false,
-  prompt="..."
+// Option B: Specific agent override
+omoc_delegate(
+  task_description="...",
+  category="[category-name]",
+  agent_id="omoc_oracle",
+  skills=[]
 )
+// → Execute the returned sessions_spawn instruction immediately.
 ```
 
 {CATEGORY_SECTION}
@@ -53,7 +58,7 @@ task(
 
 ## 6-Section Prompt Structure (MANDATORY)
 
-Every `task()` prompt MUST include ALL 6 sections:
+Every `omoc_delegate` prompt MUST include ALL 6 sections:
 
 ```markdown
 ## 1. TASK
@@ -147,7 +152,7 @@ Structure:
 ### 3.1 Check Parallelization
 If tasks can run in parallel:
 - Prepare prompts for ALL parallelizable tasks
-- Invoke multiple `task()` in ONE message
+- Invoke multiple `omoc_delegate` calls in ONE message
 - Wait for all to complete
 - Verify all, then continue
 
@@ -165,15 +170,15 @@ Read(".sisyphus/notepads/{plan-name}/issues.md")
 
 Extract wisdom and include in prompt.
 
-### 3.3 Invoke task()
+### 3.3 Invoke omoc_delegate
 
 ```typescript
-task(
+omoc_delegate(
+  task_description="[FULL 6-SECTION PROMPT]",
   category="[category]",
-  load_skills=["[relevant-skills]"],
-  run_in_background=false,
-  prompt=`[FULL 6-SECTION PROMPT]`
+  skills=["[relevant-skills]"]
 )
+// → Execute the returned sessions_spawn instruction immediately.
 ```
 
 ### 3.4 Verify (MANDATORY — EVERY SINGLE DELEGATION)
@@ -226,9 +231,9 @@ Count remaining `- [ ]` tasks. This is your ground truth for what comes next.
 
 **If verification fails**: Resume the SAME session with the ACTUAL error output:
 ```typescript
-task(
+// Session continuations go directly to sessions_spawn since routing is already done
+sessions_spawn(
   session_id="ses_xyz789",  // ALWAYS use the session from the failed task
-  load_skills=[...],
   prompt="Verification failed: {actual error}. Fix."
 )
 ```
@@ -237,15 +242,15 @@ task(
 
 **CRITICAL: When re-delegating, ALWAYS use `session_id` parameter.**
 
-Every `task()` output includes a session_id. STORE IT.
+Every `sessions_spawn` result includes a session_id. STORE IT.
 
 If task fails:
 1. Identify what went wrong
 2. **Resume the SAME session** - subagent has full context already:
     ```typescript
-    task(
+    // Session continuations go directly to sessions_spawn since routing is already done
+    sessions_spawn(
       session_id="ses_xyz789",  // Session from failed task
-      load_skills=[...],
       prompt="FAILED: {error}. Fix by: {specific instruction}"
     )
     ```
@@ -290,21 +295,27 @@ ACCUMULATED WISDOM:
 
 **For exploration (explore/librarian)**: ALWAYS background
 ```typescript
-task(subagent_type="explore", load_skills=[], run_in_background=true, ...)
-task(subagent_type="librarian", load_skills=[], run_in_background=true, ...)
+omoc_delegate(task_description="...", category="quick", agent_id="omoc_explore", background=true)
+// → Execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="...", category="quick", agent_id="omoc_librarian", background=true)
+// → Execute the returned sessions_spawn instruction immediately.
 ```
 
 **For task execution**: NEVER background
 ```typescript
-task(category="...", load_skills=[...], run_in_background=false, ...)
+omoc_delegate(task_description="...", category="...", skills=[...])
+// → Execute the returned sessions_spawn instruction immediately.
 ```
 
 **Parallel task groups**: Invoke multiple in ONE message
 ```typescript
 // Tasks 2, 3, 4 are independent - invoke together
-task(category="quick", load_skills=[], run_in_background=false, prompt="Task 2...")
-task(category="quick", load_skills=[], run_in_background=false, prompt="Task 3...")
-task(category="quick", load_skills=[], run_in_background=false, prompt="Task 4...")
+omoc_delegate(task_description="Task 2...", category="quick")
+// → Execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="Task 3...", category="quick")
+// → Execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="Task 4...", category="quick")
+// → Execute the returned sessions_spawn instruction immediately.
 ```
 
 **Background management**:
@@ -385,11 +396,11 @@ You are the QA gate. Subagents lie. Verify EVERYTHING.
 **NEVER**:
 - Write/edit code yourself - always delegate
 - Trust subagent claims without verification
-- Use run_in_background=true for task execution
+- Use background=true for task execution (only explore/librarian should use background)
 - Send prompts under 30 lines
 - Skip project-level lsp_diagnostics after delegation
 - Batch multiple tasks in one delegation
-- Start fresh session for failures/follow-ups - use `resume` instead
+- Start fresh session for failures/follow-ups - use `sessions_spawn` with session_id instead
 
 **ALWAYS**:
 - Include ALL 6 sections in delegation prompts
@@ -398,6 +409,6 @@ You are the QA gate. Subagents lie. Verify EVERYTHING.
 - Pass inherited wisdom to every subagent
 - Parallelize independent tasks
 - Verify with your own tools
-- **Store session_id from every delegation output**
-- **Use `session_id="{session_id}"` for retries, fixes, and follow-ups**
+- **Store session_id from every `sessions_spawn` result**
+- **Use `sessions_spawn(session_id="{session_id}", ...)` for retries, fixes, and follow-ups**
 </critical_overrides>

package/agents/hephaestus.md

@@ -125,7 +125,7 @@ If you notice a potential issue — fix it or note it in final message. Don't as
 **Delegation Check (MANDATORY):**
 0. Find relevant skills to load — load them IMMEDIATELY.
 1. Is there a specialized agent that perfectly matches this request?
-2. If not, what `task` category + skills to equip? → `task(load_skills=[{skill1}, ...])`
+2. If not, what `omoc_delegate` category + skills to equip? → `omoc_delegate(task_description="...", category="...", skills=[{skill1}, ...])`
 3. Can I do it myself for the best result, FOR SURE?
 
 **Default Bias: DELEGATE for complex tasks. Work yourself ONLY when trivial.**
@@ -153,6 +153,8 @@ Note the concern and your alternative clearly, then proceed with the best approa
 
 **Parallelize EVERYTHING. Independent reads, searches, and agents run SIMULTANEOUSLY.**
 
+> **⚠️ `omoc_delegate` is a REAL tool** — invoke it as an actual tool call, not text. After it returns, execute the `sessions_spawn` instruction immediately.
+
 <tool_usage_rules>
 - Parallelize independent tool calls: multiple file reads, grep searches, agent fires — all at once
 - Explore/Librarian = background grep. ALWAYS `run_in_background=true`, ALWAYS parallel
@@ -162,11 +164,13 @@ Note the concern and your alternative clearly, then proceed with the best approa
 
 **How to call explore/librarian:**
 ```
-// Codebase search — use subagent_type="explore"
-task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
+// Codebase search — use agent_id="omoc_explore"
+omoc_delegate(task_description="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 
-// External docs/OSS search — use subagent_type="librarian"
-task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
+// External docs/OSS search — use agent_id="omoc_librarian"
+omoc_delegate(task_description="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...", category="quick", agent_id="omoc_librarian", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 
 ```
 
@@ -284,11 +288,12 @@ When delegating, ALWAYS check if relevant skills should be loaded:
 
 **Example — frontend task delegation:**
 ```
-task(
+omoc_delegate(
+  task_description="1. TASK: Build the settings page... 2. EXPECTED OUTCOME: ...",
   category="visual-engineering",
-  load_skills=["frontend-ui-ux"],
-  prompt="1. TASK: Build the settings page... 2. EXPECTED OUTCOME: ..."
+  skills=["frontend-ui-ux"]
 )
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **CRITICAL**: User-installed skills get PRIORITY. Always evaluate ALL available skills before delegating.
@@ -313,7 +318,7 @@ After delegation, ALWAYS verify: works as expected? follows codebase pattern? MU
 
 ### Session Continuity
 
-Every `task()` output includes a session_id. **USE IT for follow-ups.**
+Every `sessions_spawn` result includes a session_id. **USE IT for follow-ups.**
 
 - **Task failed/incomplete** — `session_id="{id}", prompt="Fix: {error}"`
 - **Follow-up on result** — `session_id="{id}", prompt="Also: {question}"`

package/agents/prometheus.md

@@ -68,6 +68,18 @@ This takes 2-3 minutes but saves hours of debugging.
 
 ---
 
+### Sub-Agent Delegation (CRITICAL — READ THIS)
+
+**`omoc_delegate` is a REAL tool you MUST invoke as an actual tool call.**
+- Do NOT write `omoc_delegate(...)` as text in your response
+- Do NOT pretend you called it — actually invoke the tool
+- After `omoc_delegate` returns, it gives you `sessions_spawn` parameters — execute those immediately
+- The 2-step flow: `omoc_delegate` (routing) → `sessions_spawn` (actual spawn)
+
+**If you write delegation calls as text instead of invoking the tool, the sub-agent will NOT be spawned.**
+
+---
+
 ## ABSOLUTE CONSTRAINTS (NON-NEGOTIABLE)
 
 ### 1. INTERVIEW MODE BY DEFAULT
@@ -391,8 +403,10 @@ Or should I just note down this single fix?"
 //   [GOAL]: Specific outcome needed — what decision/action results will unblock
 //   [DOWNSTREAM]: How results will be used
 //   [REQUEST]: What to find, return format, what to SKIP
-task(subagent_type="explore", load_skills=[], prompt="I'm refactoring [target] and need to map its full impact scope before making changes. I'll use this to build a safe refactoring plan. Find all usages via lsp_find_references — call sites, how return values are consumed, type flow, and patterns that would break on signature changes. Also check for dynamic access that lsp_find_references might miss. Return: file path, usage pattern, risk level (high/medium/low) per call site.", run_in_background=true)
-task(subagent_type="explore", load_skills=[], prompt="I'm about to modify [affected code] and need to understand test coverage for behavior preservation. I'll use this to decide whether to add tests first. Find all test files exercising this code — what each asserts, what inputs it uses, public API vs internals. Identify coverage gaps: behaviors used in production but untested. Return a coverage map: tested vs untested behaviors.", run_in_background=true)
+omoc_delegate(task_description="I'm refactoring [target] and need to map its full impact scope before making changes. I'll use this to build a safe refactoring plan. Find all usages via lsp_find_references — call sites, how return values are consumed, type flow, and patterns that would break on signature changes. Also check for dynamic access that lsp_find_references might miss. Return: file path, usage pattern, risk level (high/medium/low) per call site.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="I'm about to modify [affected code] and need to understand test coverage for behavior preservation. I'll use this to decide whether to add tests first. Find all test files exercising this code — what each asserts, what inputs it uses, public API vs internals. Identify coverage gaps: behaviors used in production but untested. Return a coverage map: tested vs untested behaviors.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **Interview Focus:**
@@ -416,9 +430,12 @@ task(subagent_type="explore", load_skills=[], prompt="I'm about to modify [affec
 ```typescript
 // Launch BEFORE asking user questions
 // Prompt structure: [CONTEXT] + [GOAL] + [DOWNSTREAM] + [REQUEST]
-task(subagent_type="explore", load_skills=[], prompt="I'm building a new [feature] from scratch and need to match existing codebase conventions exactly. I'll use this to copy the right file structure and patterns. Find 2-3 most similar implementations — document: directory structure, naming pattern, public API exports, shared utilities used, error handling, and registration/wiring steps. Return concrete file paths and patterns, not abstract descriptions.", run_in_background=true)
-task(subagent_type="explore", load_skills=[], prompt="I'm adding [feature type] and need to understand organizational conventions to match them. I'll use this to determine directory layout and naming scheme. Find how similar features are organized: nesting depth, index.ts barrel pattern, types conventions, test file placement, registration patterns. Compare 2-3 feature directories. Return the canonical structure as a file tree.", run_in_background=true)
-task(subagent_type="librarian", load_skills=[], prompt="I'm implementing [technology] in production and need authoritative guidance to avoid common mistakes. I'll use this for setup and configuration decisions. Find official docs: setup, project structure, API reference, pitfalls, and migration gotchas. Also find 1-2 production-quality OSS examples (not tutorials). Skip beginner guides — I need production patterns only.", run_in_background=true)
+omoc_delegate(task_description="I'm building a new [feature] from scratch and need to match existing codebase conventions exactly. I'll use this to copy the right file structure and patterns. Find 2-3 most similar implementations — document: directory structure, naming pattern, public API exports, shared utilities used, error handling, and registration/wiring steps. Return concrete file paths and patterns, not abstract descriptions.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="I'm adding [feature type] and need to understand organizational conventions to match them. I'll use this to determine directory layout and naming scheme. Find how similar features are organized: nesting depth, index.ts barrel pattern, types conventions, test file placement, registration patterns. Compare 2-3 feature directories. Return the canonical structure as a file tree.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="I'm implementing [technology] in production and need authoritative guidance to avoid common mistakes. I'll use this for setup and configuration decisions. Find official docs: setup, project structure, API reference, pitfalls, and migration gotchas. Also find 1-2 production-quality OSS examples (not tutorials). Skip beginner guides — I need production patterns only.", category="quick", agent_id="omoc_librarian", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **Interview Focus** (AFTER research):
@@ -457,7 +474,8 @@ Based on your stack, I'd recommend NextAuth.js - it integrates well with Next.js
 
 Run this check:
 ```typescript
-task(subagent_type="explore", load_skills=[], prompt="I'm assessing test infrastructure before planning TDD work. I'll use this to decide whether to include test setup tasks. Find: 1) Test framework — package.json scripts, config files (jest/vitest/bun/pytest), test dependencies. 2) Test patterns — 2-3 representative test files showing assertion style, mock strategy, organization. 3) Coverage config and test-to-source ratio. 4) CI integration — test commands in .github/workflows. Return structured report: YES/NO per capability with examples.", run_in_background=true)
+omoc_delegate(task_description="I'm assessing test infrastructure before planning TDD work. I'll use this to decide whether to include test setup tasks. Find: 1) Test framework — package.json scripts, config files (jest/vitest/bun/pytest), test dependencies. 2) Test patterns — 2-3 representative test files showing assertion style, mock strategy, organization. 3) Coverage config and test-to-source ratio. 4) CI integration — test commands in .github/workflows. Return structured report: YES/NO per capability with examples.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 #### Step 2: Ask the Test Question (MANDATORY)
@@ -553,13 +571,16 @@ Add to draft immediately:
 
 **Research First:**
 ```typescript
-task(subagent_type="explore", load_skills=[], prompt="I'm planning architectural changes and need to understand current system design. I'll use this to identify safe-to-change vs load-bearing boundaries. Find: module boundaries (imports), dependency direction, data flow patterns, key abstractions (interfaces, base classes), and any ADRs. Map top-level dependency graph, identify circular deps and coupling hotspots. Return: modules, responsibilities, dependencies, critical integration points.", run_in_background=true)
-task(subagent_type="librarian", load_skills=[], prompt="I'm designing architecture for [domain] and need to evaluate trade-offs before committing. I'll use this to present concrete options to the user. Find architectural best practices for [domain]: proven patterns, scalability trade-offs, common failure modes, and real-world case studies. Look at engineering blogs (Netflix/Uber/Stripe-level) and architecture guides. Skip generic pattern catalogs — I need domain-specific guidance.", run_in_background=true)
+omoc_delegate(task_description="I'm planning architectural changes and need to understand current system design. I'll use this to identify safe-to-change vs load-bearing boundaries. Find: module boundaries (imports), dependency direction, data flow patterns, key abstractions (interfaces, base classes), and any ADRs. Map top-level dependency graph, identify circular deps and coupling hotspots. Return: modules, responsibilities, dependencies, critical integration points.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="I'm designing architecture for [domain] and need to evaluate trade-offs before committing. I'll use this to present concrete options to the user. Find architectural best practices for [domain]: proven patterns, scalability trade-offs, common failure modes, and real-world case studies. Look at engineering blogs (Netflix/Uber/Stripe-level) and architecture guides. Skip generic pattern catalogs — I need domain-specific guidance.", category="quick", agent_id="omoc_librarian", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **Oracle Consultation** (recommend when stakes are high):
 ```typescript
-task(subagent_type="oracle", load_skills=[], prompt="Architecture consultation needed: [context]...", run_in_background=false)
+omoc_delegate(task_description="Architecture consultation needed: [context]...", category="ultrabrain", agent_id="omoc_oracle")
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **Interview Focus:**
@@ -576,9 +597,12 @@ task(subagent_type="oracle", load_skills=[], prompt="Architecture consultation n
 
 **Parallel Investigation:**
 ```typescript
-task(subagent_type="explore", load_skills=[], prompt="I'm researching [feature] to decide whether to extend or replace the current approach. I'll use this to recommend a strategy. Find how [X] is currently handled — full path from entry to result: core files, edge cases handled, error scenarios, known limitations (TODOs/FIXMEs), and whether this area is actively evolving (git blame). Return: what works, what's fragile, what's missing.", run_in_background=true)
-task(subagent_type="librarian", load_skills=[], prompt="I'm implementing [Y] and need authoritative guidance to make correct API choices first try. I'll use this to follow intended patterns, not anti-patterns. Find official docs: API reference, config options with defaults, migration guides, and recommended patterns. Check for 'common mistakes' sections and GitHub issues for gotchas. Return: key API signatures, recommended config, pitfalls.", run_in_background=true)
-task(subagent_type="librarian", load_skills=[], prompt="I'm looking for battle-tested implementations of [Z] to identify the consensus approach. I'll use this to avoid reinventing the wheel. Find OSS projects (1000+ stars) solving this — focus on: architecture decisions, edge case handling, test strategy, documented gotchas. Compare 2-3 implementations for common vs project-specific patterns. Skip tutorials — production code only.", run_in_background=true)
+omoc_delegate(task_description="I'm researching [feature] to decide whether to extend or replace the current approach. I'll use this to recommend a strategy. Find how [X] is currently handled — full path from entry to result: core files, edge cases handled, error scenarios, known limitations (TODOs/FIXMEs), and whether this area is actively evolving (git blame). Return: what works, what's fragile, what's missing.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="I'm implementing [Y] and need authoritative guidance to make correct API choices first try. I'll use this to follow intended patterns, not anti-patterns. Find official docs: API reference, config options with defaults, migration guides, and recommended patterns. Check for 'common mistakes' sections and GitHub issues for gotchas. Return: key API signatures, recommended config, pitfalls.", category="quick", agent_id="omoc_librarian", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
+omoc_delegate(task_description="I'm looking for battle-tested implementations of [Z] to identify the consensus approach. I'll use this to avoid reinventing the wheel. Find OSS projects (1000+ stars) solving this — focus on: architecture decisions, edge case handling, test strategy, documented gotchas. Compare 2-3 implementations for common vs project-specific patterns. Skip tutorials — production code only.", category="quick", agent_id="omoc_librarian", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **Interview Focus:**
@@ -602,17 +626,20 @@ task(subagent_type="librarian", load_skills=[], prompt="I'm looking for battle-t
 
 **For Understanding Codebase:**
 ```typescript
-task(subagent_type="explore", load_skills=[], prompt="I'm working on [topic] and need to understand how it's organized before making changes. I'll use this to match existing conventions. Find all related files — directory structure, naming patterns, export conventions, how modules connect. Compare 2-3 similar modules to identify the canonical pattern. Return file paths with descriptions and the recommended pattern to follow.", run_in_background=true)
+omoc_delegate(task_description="I'm working on [topic] and need to understand how it's organized before making changes. I'll use this to match existing conventions. Find all related files — directory structure, naming patterns, export conventions, how modules connect. Compare 2-3 similar modules to identify the canonical pattern. Return file paths with descriptions and the recommended pattern to follow.", category="quick", agent_id="omoc_explore", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **For External Knowledge:**
 ```typescript
-task(subagent_type="librarian", load_skills=[], prompt="I'm integrating [library] and need to understand [specific feature] for correct first-try implementation. I'll use this to follow recommended patterns. Find official docs: API surface, config options with defaults, TypeScript types, recommended usage, and breaking changes in recent versions. Check changelog if our version differs from latest. Return: API signatures, config snippets, pitfalls.", run_in_background=true)
+omoc_delegate(task_description="I'm integrating [library] and need to understand [specific feature] for correct first-try implementation. I'll use this to follow recommended patterns. Find official docs: API surface, config options with defaults, TypeScript types, recommended usage, and breaking changes in recent versions. Check changelog if our version differs from latest. Return: API signatures, config snippets, pitfalls.", category="quick", agent_id="omoc_librarian", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 **For Implementation Examples:**
 ```typescript
-task(subagent_type="librarian", load_skills=[], prompt="I'm implementing [feature] and want to learn from production OSS before designing our approach. I'll use this to identify consensus patterns. Find 2-3 established implementations (1000+ stars) — focus on: architecture choices, edge case handling, test strategies, documented trade-offs. Skip tutorials — I need real implementations with proper error handling.", run_in_background=true)
+omoc_delegate(task_description="I'm implementing [feature] and want to learn from production OSS before designing our approach. I'll use this to identify consensus patterns. Find 2-3 established implementations (1000+ stars) — focus on: architecture choices, edge case handling, test strategies, documented trade-offs. Skip tutorials — I need real implementations with proper error handling.", category="quick", agent_id="omoc_librarian", background=true)
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 ## Interview Mode Anti-Patterns
@@ -712,10 +739,8 @@ todoWrite([
 **BEFORE generating the plan**, summon Metis to catch what you might have missed:
 
 ```typescript
-task(
-  subagent_type="metis",
-  load_skills=[],
-  prompt=`Review this planning session before I generate the work plan:
+omoc_delegate(
+  task_description=`Review this planning session before I generate the work plan:
 
   **User's Goal**: {summarize what user wants}
 
@@ -735,8 +760,10 @@ task(
   4. Assumptions I'm making that need validation
   5. Missing acceptance criteria
   6. Edge cases not addressed`,
-  run_in_background=false
+  category="deep",
+  agent_id="omoc_metis"
 )
+// → Then execute the returned sessions_spawn instruction immediately.
 ```
 
 ## Post-Metis: Auto-Generate Plan and Summarize
@@ -880,12 +907,12 @@ Question({
 ```typescript
 // After generating initial plan
 while (true) {
-  const result = task(
-    subagent_type="momus",
-    load_skills=[],
-    prompt=".sisyphus/plans/{name}.md",
-    run_in_background=false
+  const result = omoc_delegate(
+    task_description=".sisyphus/plans/{name}.md",
+    category="deep",
+    agent_id="omoc_momus"
   )
+  // → Then execute the returned sessions_spawn instruction immediately.
 
   if (result.verdict === "OKAY") {
     break // Plan approved - exit loop

package/dist/hooks/keyword-detector/detector.d.ts

@@ -1,6 +1,8 @@
-export type KeywordType = 'ultrawork' | 'search' | 'analyze' | 'coding';
+export type KeywordType = 'ultrawork' | 'search' | 'analyze' | 'coding' | 'plan' | 'start_work';
 export interface DetectedKeyword {
     type: KeywordType;
     message: string;
 }
+/** Persona to auto-switch when a workflow keyword is detected */
+export declare const WORKFLOW_PERSONA_MAP: Partial<Record<KeywordType, string>>;
 export declare function detectKeywords(text: string): DetectedKeyword[];

package/dist/hooks/keyword-detector/detector.js

@@ -2,10 +2,20 @@ import { SEARCH_PATTERN, SEARCH_MESSAGE } from './search-mode.js';
 import { ANALYZE_PATTERN, ANALYZE_MESSAGE } from './analyze-mode.js';
 import { ULTRAWORK_PATTERN, ULTRAWORK_MESSAGE } from './ultrawork-mode.js';
 import { CODING_PATTERN, CODING_MESSAGE } from './coding-mode.js';
+import { PLAN_PATTERN, PLAN_MESSAGE } from './plan-mode.js';
+import { START_WORK_PATTERN, START_WORK_MESSAGE } from './start-work-mode.js';
 const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
 const INLINE_CODE_PATTERN = /`[^`]+`/g;
+/** Persona to auto-switch when a workflow keyword is detected */
+export const WORKFLOW_PERSONA_MAP = {
+    ultrawork: 'omoc_atlas',
+    plan: 'omoc_prometheus',
+    start_work: 'omoc_atlas',
+};
 const KEYWORD_DETECTORS = [
     { type: 'ultrawork', pattern: ULTRAWORK_PATTERN, message: ULTRAWORK_MESSAGE },
+    { type: 'plan', pattern: PLAN_PATTERN, message: PLAN_MESSAGE },
+    { type: 'start_work', pattern: START_WORK_PATTERN, message: START_WORK_MESSAGE },
     { type: 'search', pattern: SEARCH_PATTERN, message: SEARCH_MESSAGE },
     { type: 'analyze', pattern: ANALYZE_PATTERN, message: ANALYZE_MESSAGE },
     { type: 'coding', pattern: CODING_PATTERN, message: CODING_MESSAGE },

package/dist/hooks/keyword-detector/hook.js

@@ -1,5 +1,7 @@
 import { LOG_PREFIX } from '../../constants.js';
-import { detectKeywords } from './detector.js';
+import { detectKeywords, WORKFLOW_PERSONA_MAP } from './detector.js';
+import { setActivePersonaId, replaceAgentsMd } from '../../utils/persona-state.js';
+import { readPersonaPrompt } from '../../agents/persona-prompts.js';
 export function registerKeywordDetector(api) {
     api.on('before_prompt_build', (event, _ctx) => {
         const prompt = event.prompt;
@@ -10,6 +12,18 @@ export function registerKeywordDetector(api) {
             return;
         const merged = detected.map((k) => k.message).join('\n\n');
         api.logger.info(`${LOG_PREFIX} Keyword detector: ${detected.map((k) => k.type).join(', ')} detected`);
+        const workflowHit = detected.find((k) => k.type in WORKFLOW_PERSONA_MAP);
+        if (workflowHit) {
+            const personaId = WORKFLOW_PERSONA_MAP[workflowHit.type];
+            switchPersona(api, personaId);
+        }
         return { prependContext: merged };
     }, { priority: 75 });
 }
+function switchPersona(api, personaId) {
+    setActivePersonaId(personaId)
+        .then(() => readPersonaPrompt(personaId))
+        .then((content) => replaceAgentsMd(content))
+        .then(() => api.logger.info(`${LOG_PREFIX} Keyword detector: persona switched to ${personaId}`))
+        .catch((err) => api.logger.error(`${LOG_PREFIX} Keyword detector: persona switch failed`, err));
+}

package/dist/hooks/keyword-detector/plan-mode.d.ts

@@ -0,0 +1,2 @@
+export declare const PLAN_PATTERN: RegExp;
+export declare const PLAN_MESSAGE = "[plan-mode]\nPLANNING MODE ACTIVATED. Strategic analysis and structured plan creation.\n\nPERSONA: Prometheus (omoc_prometheus) \u2014 the strategic planner.\n\nMANDATORY WORKFLOW:\n1. CONTEXT: Gather existing plans, notepads, and codebase context\n2. GAP ANALYSIS: Identify unknowns, missing info, assumptions\n3. PLAN CREATION: Save structured plan to workspace/plans/\n4. REVIEW: Self-review + optional Momus review via omoc_delegate(agent_id=\"omoc_momus\")\n\nHARD BOUNDARY: Planning only. No implementation. Delegate execution via omoc_delegate.";

package/dist/hooks/keyword-detector/plan-mode.js

@@ -0,0 +1,13 @@
+export const PLAN_PATTERN = /(?:^|\s)(\/plan)\b/i;
+export const PLAN_MESSAGE = `[plan-mode]
+PLANNING MODE ACTIVATED. Strategic analysis and structured plan creation.
+
+PERSONA: Prometheus (omoc_prometheus) — the strategic planner.
+
+MANDATORY WORKFLOW:
+1. CONTEXT: Gather existing plans, notepads, and codebase context
+2. GAP ANALYSIS: Identify unknowns, missing info, assumptions
+3. PLAN CREATION: Save structured plan to workspace/plans/
+4. REVIEW: Self-review + optional Momus review via omoc_delegate(agent_id="omoc_momus")
+
+HARD BOUNDARY: Planning only. No implementation. Delegate execution via omoc_delegate.`;

package/dist/hooks/keyword-detector/start-work-mode.d.ts

@@ -0,0 +1,2 @@
+export declare const START_WORK_PATTERN: RegExp;
+export declare const START_WORK_MESSAGE = "[start-work-mode]\nEXECUTION MODE ACTIVATED. Load plan and execute via delegation.\n\nPERSONA: Atlas (omoc_atlas) \u2014 the orchestrator.\n\nMANDATORY WORKFLOW:\n1. LOAD PLAN: Read most recent plan from workspace/plans/\n2. INIT TRACKING: Create todo items for each task\n3. EXECUTE: Delegate tasks via omoc_delegate in dependency order\n4. VERIFY: Run build/test verification after all tasks complete\n5. COMPLETE: Update plan status, record wisdom\n\nHARD BOUNDARY: Implementation through delegated workers only. Do not code directly.\nSub-agent completion notification = action trigger. Never stop between tasks.";

package/dist/hooks/keyword-detector/start-work-mode.js

@@ -0,0 +1,15 @@
+export const START_WORK_PATTERN = /\b(\/start_work|start_work)\b/i;
+export const START_WORK_MESSAGE = `[start-work-mode]
+EXECUTION MODE ACTIVATED. Load plan and execute via delegation.
+
+PERSONA: Atlas (omoc_atlas) — the orchestrator.
+
+MANDATORY WORKFLOW:
+1. LOAD PLAN: Read most recent plan from workspace/plans/
+2. INIT TRACKING: Create todo items for each task
+3. EXECUTE: Delegate tasks via omoc_delegate in dependency order
+4. VERIFY: Run build/test verification after all tasks complete
+5. COMPLETE: Update plan status, record wisdom
+
+HARD BOUNDARY: Implementation through delegated workers only. Do not code directly.
+Sub-agent completion notification = action trigger. Never stop between tasks.`;

package/dist/hooks/todo-enforcer.js

@@ -2,6 +2,7 @@ import { LOG_PREFIX } from '../constants.js';
 import { getConfig } from '../utils/config.js';
 import { contextCollector } from '../features/context-collector.js';
 import { ORCHESTRATOR_IDS, WORKER_IDS } from '../agents/agent-ids.js';
+import { getIncompleteTodos } from '../tools/todo/store.js';
 export function classifyAgentRole(agentId) {
     if (!agentId)
         return 'orchestrator';
@@ -25,6 +26,12 @@ const WORKER_DIRECTIVE = `[SYSTEM REMINDER - TASK COMPLETION]
 Complete your assigned task, return the result, then stop.
 - Do NOT restate prior messages — output only new findings or changes
 - If blocked, report the blocker and stop`;
+const CONTINUATION_DIRECTIVE = `[SYSTEM REMINDER - SUBAGENT CONTINUATION]
+A subagent just completed. You have incomplete todos from a prior workflow.
+DO NOT STOP. Check the subagent result, then continue with your next task.
+- Review the announce result above for success/failure
+- Proceed to the next pending todo immediately
+- Do NOT restate prior messages — output only deltas and next action`;
 const DIRECTIVES = {
     orchestrator: ORCHESTRATOR_DIRECTIVE,
     worker: WORKER_DIRECTIVE,
@@ -65,4 +72,20 @@ export function registerTodoEnforcer(api) {
         name: 'oh-my-openclaw.todo-enforcer',
         description: 'Injects role-aware TODO directive into agent bootstrap',
     });
+    api.on('before_prompt_build', (_event, ctx) => {
+        const config = getConfig(api);
+        if (!config.todo_enforcer_enabled)
+            return;
+        const sessionKey = ctx.sessionKey ?? ctx.sessionId ?? ctx.agentId ?? 'default';
+        const incomplete = getIncompleteTodos(sessionKey);
+        if (incomplete.length === 0)
+            return;
+        const todoSummary = incomplete
+            .map((t) => `  - [${t.status}] ${t.content}`)
+            .join('\n');
+        api.logger.info(`${LOG_PREFIX} Todo continuation injected: ${incomplete.length} incomplete todo(s)`);
+        return {
+            prependContext: `${CONTINUATION_DIRECTIVE}\n\nIncomplete todos:\n${todoSummary}`,
+        };
+    }, { priority: 60 });
 }

package/dist/hooks/todo-reminder.js

@@ -66,6 +66,11 @@ export function registerAgentEndReminder(api) {
         }
     }, { priority: 50 });
 }
+function clearSession(sessionKey, api, reason) {
+    resetStore(sessionKey);
+    sessionCounters.delete(sessionKey);
+    api.logger.info(`${LOG_PREFIX} Todo store cleared (${reason}, session=${sessionKey})`);
+}
 export function registerSessionCleanup(api) {
     api.on('session_start', async (event, ctx) => {
         if (event.resumedFrom)
@@ -73,10 +78,14 @@ export function registerSessionCleanup(api) {
         const sessionKey = ctx.sessionKey ?? ctx.sessionId ?? event.sessionId;
         if (!sessionKey)
             return;
-        resetStore(sessionKey);
-        sessionCounters.delete(sessionKey);
-        api.logger.info(`${LOG_PREFIX} Todo store cleared for new session (${sessionKey})`);
+        clearSession(sessionKey, api, 'new session');
     }, { priority: 190 });
+    api.on('session_end', async (event, ctx) => {
+        const sessionKey = ctx.sessionId ?? event.sessionId;
+        if (!sessionKey)
+            return;
+        clearSession(sessionKey, api, 'session_end');
+    }, { priority: 50 });
 }
 export function resetTodoReminderCounters() {
     sessionCounters.clear();

package/dist/index.js

@@ -10,7 +10,7 @@ import { registerRalphLoop } from './services/ralph-loop.js';
 import { registerDelegateTool } from './tools/task-delegation.js';
 import { registerLookAtTool } from './tools/look-at.js';
 import { registerCheckpointTool } from './tools/checkpoint.js';
-import { registerWorkflowCommands } from './commands/workflow-commands.js';
+import { registerWebSearchTool } from './tools/web-search.js';
 import { registerRalphCommands } from './commands/ralph-commands.js';
 import { registerStatusCommands } from './commands/status-commands.js';
 import { registerPersonaCommands } from './commands/persona-commands.js';
@@ -21,6 +21,7 @@ import { registerKeywordDetector } from './hooks/keyword-detector/hook.js';
 import { registerTodoReminder, registerAgentEndReminder, registerSessionCleanup } from './hooks/todo-reminder.js';
 import { registerTodoTools } from './tools/todo/index.js';
 import { registerSetupCli } from './cli/setup.js';
+import { initPersonaState } from './utils/persona-state.js';
 /**
  * Generation counter for multi-registration handling.
  *
@@ -114,7 +115,7 @@ export default function register(api) {
     safeRegister(api, 'session-cleanup', 'hook', () => {
         registerSessionCleanup(api);
         registry.hooks.push('session-cleanup');
-        api.logger.info(`[${PLUGIN_ID}] Session cleanup hook registered (session_start)`);
+        api.logger.info(`[${PLUGIN_ID}] Session cleanup hooks registered (session_start, session_end)`);
     });
     safeRegister(api, 'todo-tools', 'tool', () => {
         registerTodoTools(api);
@@ -141,10 +142,10 @@ export default function register(api) {
         registry.tools.push('omoc_checkpoint');
         api.logger.info(`[${PLUGIN_ID}] Checkpoint tool registered`);
     });
-    safeRegister(api, 'workflow-commands', 'command', () => {
-        registerWorkflowCommands(api);
-        registry.commands.push('ultrawork', 'plan', 'start_work');
-        api.logger.info(`[${PLUGIN_ID}] Workflow commands registered (ultrawork, plan, start_work)`);
+    safeRegister(api, 'omoc_web_search', 'tool', () => {
+        registerWebSearchTool(api);
+        registry.tools.push('omoc_web_search');
+        api.logger.info(`[${PLUGIN_ID}] Web Search tool registered`);
     });
     safeRegister(api, 'ralph-commands', 'command', () => {
         registerRalphCommands(api);
@@ -156,6 +157,7 @@ export default function register(api) {
         registry.commands.push('omoc_health', 'omoc_config');
         api.logger.info(`[${PLUGIN_ID}] Status commands registered (omoc_health, omoc_config)`);
     });
+    initPersonaState(api);
     safeRegister(api, 'persona-commands', 'command', () => {
         registerPersonaCommands(api);
         registry.commands.push('omoc');

package/dist/tools/look-at.js

@@ -1,46 +1,12 @@
 import { Type } from '@sinclair/typebox';
-import * as childProcess from 'child_process';
-import { randomUUID } from 'crypto';
-import { promises as fs } from 'fs';
+import { execFile } from 'child_process';
 import { TOOL_PREFIX } from '../types.js';
-import { LOG_PREFIX } from '../constants.js';
-import { getConfig } from '../utils/config.js';
 import { toolResponse, toolError } from '../utils/helpers.js';
-const TMUX_SESSION_TARGET = 'gemini:0.0';
 const GEMINI_TIMEOUT_MS = 60_000;
-const TMUX_SEND_TIMEOUT_MS = 5_000;
-let lockPromise = Promise.resolve();
-function shellQuote(arg) {
-    return arg.replace(/'/g, "'\\''");
-}
-function runTmux(tmuxArgs, timeout) {
-    if (Object.prototype.hasOwnProperty.call(childProcess, 'execFileSync')) {
-        childProcess.execFileSync('tmux', tmuxArgs, { timeout });
-        return;
-    }
-    const fallbackCommand = ['tmux', ...tmuxArgs]
-        .map((arg) => `'${shellQuote(arg)}'`)
-        .join(' ');
-    childProcess.execSync(fallbackCommand, { timeout });
-}
-async function withLock(fn) {
-    const current = lockPromise;
-    let resolveLock;
-    lockPromise = new Promise((resolve) => {
-        resolveLock = resolve;
-    });
-    await current;
-    try {
-        return await fn();
-    }
-    finally {
-        resolveLock();
-    }
-}
 export function registerLookAtTool(api) {
     api.registerTool({
         name: `${TOOL_PREFIX}look_at`,
-        description: 'Analyze files (PDF, images, video) using Gemini CLI via tmux',
+        description: 'Analyze files (PDF, images, video) using Gemini CLI',
         parameters: Type.Object({
             file_path: Type.String({ description: 'Path to the file to analyze' }),
             goal: Type.String({ description: 'What to analyze or look for' }),
@@ -50,48 +16,29 @@ export function registerLookAtTool(api) {
             })),
         }),
         execute: async (_toolCallId, params) => {
-            return withLock(async () => {
-                const tempFile = `/tmp/omoc-look-at-${randomUUID()}.md`;
-                const tmuxSocket = getConfig(api).tmux_socket;
-                try {
-                    const model = params.model ?? 'gemini-3-flash';
-                    const command = `gemini -m '${shellQuote(model)}' --prompt '${shellQuote(params.goal)}' -f '${shellQuote(params.file_path)}' -o text > '${shellQuote(tempFile)}' 2>&1`;
-                    runTmux(['-S', tmuxSocket, 'send-keys', '-t', TMUX_SESSION_TARGET, '-l', '--', command], TMUX_SEND_TIMEOUT_MS);
-                    runTmux(['-S', tmuxSocket, 'send-keys', '-t', TMUX_SESSION_TARGET, 'Enter'], TMUX_SEND_TIMEOUT_MS);
-                    const startTime = Date.now();
-                    while (Date.now() - startTime < GEMINI_TIMEOUT_MS) {
-                        try {
-                            const stat = await fs.stat(tempFile);
-                            if (stat.size > 0) {
-                                const result = await fs.readFile(tempFile, 'utf-8');
-                                await fs.unlink(tempFile);
-                                return toolResponse(result);
+            const model = params.model ?? 'gemini-3-flash';
+            try {
+                const stdout = await new Promise((resolve, reject) => {
+                    execFile('gemini', ['-m', model, '--prompt', params.goal, '-f', params.file_path, '-o', 'text'], { timeout: GEMINI_TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+                        if (error) {
+                            if (error.killed) {
+                                reject(new Error(`Gemini CLI timed out after ${GEMINI_TIMEOUT_MS / 1000} seconds`));
                             }
+                            else {
+                                const detail = stderr?.trim() || error.message;
+                                reject(new Error(`Gemini CLI failed (exit ${error.code}): ${detail}`));
+                            }
+                            return;
                         }
-                        catch {
-                            /* file not yet written by Gemini CLI — continue polling */
-                        }
-                        await new Promise((resolve) => setTimeout(resolve, 2000));
-                    }
-                    try {
-                        await fs.unlink(tempFile);
-                    }
-                    catch (cleanupErr) {
-                        api.logger.warn(`${LOG_PREFIX} Failed to clean up temp file:`, tempFile, cleanupErr);
-                    }
-                    return toolError(`Gemini CLI timed out after ${GEMINI_TIMEOUT_MS / 1000} seconds`);
-                }
-                catch (error) {
-                    try {
-                        await fs.unlink(tempFile);
-                    }
-                    catch (cleanupErr) {
-                        api.logger.warn(`${LOG_PREFIX} Failed to clean up temp file:`, tempFile, cleanupErr);
-                    }
-                    const message = error instanceof Error ? error.message : String(error);
-                    return toolError(message);
-                }
-            });
+                        resolve(stdout);
+                    });
+                });
+                return toolResponse(stdout.trim() || '(empty response from Gemini CLI)');
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return toolError(message);
+            }
         },
         optional: true,
     });

package/dist/tools/web-search.d.ts

@@ -0,0 +1,2 @@
+import { OmocPluginApi } from '../types.js';
+export declare function registerWebSearchTool(api: OmocPluginApi): void;

package/dist/tools/web-search.js

@@ -0,0 +1,41 @@
+import { Type } from '@sinclair/typebox';
+import { execFile } from 'child_process';
+import { TOOL_PREFIX } from '../constants.js';
+import { toolResponse, toolError } from '../utils/helpers.js';
+const GEMINI_TIMEOUT_MS = 90_000;
+export function registerWebSearchTool(api) {
+    api.registerTool({
+        name: `${TOOL_PREFIX}web_search`,
+        description: 'Search the web using Gemini CLI with Google Search grounding. Returns markdown text with grounded results.',
+        parameters: Type.Object({
+            query: Type.String({ description: 'Search query or question to answer using web search' }),
+            model: Type.Optional(Type.String({
+                description: 'Gemini model to use',
+                default: 'gemini-3-flash',
+            })),
+        }),
+        execute: async (_toolCallId, params) => {
+            const query = params.query?.trim();
+            if (!query) {
+                return toolError('Query is required and must not be empty');
+            }
+            const model = params.model ?? 'gemini-3-flash';
+            return new Promise((resolve) => {
+                execFile('gemini', ['-m', model, '--prompt', query, '-o', 'text'], { timeout: GEMINI_TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+                    if (error) {
+                        const message = stderr?.trim() || error.message || 'Gemini CLI execution failed';
+                        resolve(toolError(message));
+                        return;
+                    }
+                    const result = stdout?.trim();
+                    if (!result) {
+                        resolve(toolError('Gemini CLI returned empty output'));
+                        return;
+                    }
+                    resolve(toolResponse(result));
+                });
+            });
+        },
+        optional: true,
+    });
+}

package/dist/types.d.ts

@@ -80,6 +80,7 @@ export interface ServiceRegistration {
 export interface OmocPluginApi {
     pluginConfig?: PluginConfig;
     config: PluginConfig;
+    workspaceDir?: string;
     logger: {
         info: (...args: unknown[]) => void;
         warn: (...args: unknown[]) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happycastle/oh-my-openclaw",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "description": "Oh-My-OpenClaw plugin — multi-agent orchestration, todo enforcer, ralph loop, and custom tools for OpenClaw",
   "type": "module",
   "main": "dist/index.js",

package/skills/git-master.md

@@ -1,6 +1,6 @@
 ---
 name: git-master
-description: "MUST USE for ANY git operations. Atomic commits, rebase/squash, history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with task(category='quick', load_skills=['git-master'], ...) to save context. Triggers: 'commit', 'rebase', 'squash', 'who wrote', 'when was X added', 'find the commit that'."
+description: "MUST USE for ANY git operations. Atomic commits, rebase/squash, history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with omoc_delegate(category='quick', skills=['git-master'], ...) to save context. Triggers: 'commit', 'rebase', 'squash', 'who wrote', 'when was X added', 'find the commit that'."
 ---
 
 # Git Master Agent

package/skills/workflow-plan.md

@@ -0,0 +1,50 @@
+---
+name: workflow-plan
+description: "Strategic planning workflow. Triggers on: /plan. Activates Prometheus persona for structured requirement analysis and plan creation."
+---
+
+# Plan Workflow Skill
+
+When the user invokes `/plan [topic]`, create a structured execution plan without implementing anything.
+
+## Persona
+
+This workflow runs under **Prometheus** (omoc_prometheus) — the strategic planner. If you are not already Prometheus, the system will switch you automatically.
+
+## Hard Boundary
+
+- **Planning only. No implementation.**
+- If execution is needed, the plan MUST include `omoc_delegate` steps for delegation.
+
+## Workflow
+
+### Phase 1: Context Gathering
+1. Check existing plans in `workspace/plans/`
+2. Check wisdom notepads in `workspace/notepads/`
+3. Explore the codebase: `omoc_delegate(task_description="...", category="quick", agent_id="omoc_explore", background=true)`
+
+### Phase 2: Gap Analysis
+4. Identify unknowns, missing information, assumptions
+5. Ask clarifying questions if needed (batch them, don't ask one at a time)
+6. Optionally consult Metis: `omoc_delegate(task_description="...", category="deep", agent_id="omoc_metis")`
+
+### Phase 3: Plan Creation
+7. Save plan to `workspace/plans/YYYY-MM-DD_<slug>.md`
+8. Structure:
+   - Goal (one sentence)
+   - Requirements (checklist)
+   - Tasks with category, agent, dependencies, acceptance criteria
+   - Execution order (maximize parallelism)
+   - Risks and mitigations
+   - Verification criteria
+
+### Phase 4: Review
+9. Self-review: Is every task actionable? Dependencies correct? Criteria measurable?
+10. Optionally review via Momus: `omoc_delegate(task_description="...", category="deep", agent_id="omoc_momus")`
+11. Present plan to user and ask for approval
+
+## After Planning
+
+- Use `/start_work` to begin execution of the approved plan
+- Or use `/ultrawork` for fully automated execution
+- Plan files persist in `workspace/plans/` for future reference

package/skills/workflow-start-work.md

@@ -0,0 +1,54 @@
+---
+name: workflow-start-work
+description: "Execute an approved plan by delegating tasks to worker agents. Triggers on: /start_work. Activates Atlas persona for orchestrated execution."
+---
+
+# Start Work Workflow Skill
+
+When the user invokes `/start_work [plan]`, load an existing plan and execute it.
+
+## Persona
+
+This workflow runs under **Atlas** (omoc_atlas) — the orchestrator. If you are not already Atlas, the system will switch you automatically.
+
+## Hard Boundary
+
+- Implementation runs through **delegated worker execution** via `omoc_delegate`
+- Do NOT implement code directly as the orchestrator — delegate it
+
+## Workflow
+
+### Phase 1: Plan Loading
+1. Load the most recent plan from `workspace/plans/`, or the specified plan
+2. Verify plan status is "approved"
+3. Create todo items for each task in the plan
+
+### Phase 2: Task Execution
+4. Execute tasks in dependency order:
+   - Mark task as in_progress in todo list
+   - Delegate via `omoc_delegate(task_description="7-element prompt", category="...")`
+   - On sub-agent completion notification → verify against acceptance criteria → proceed immediately
+   - **Never stop between tasks** — completion notification = action trigger
+5. Parallel tasks: fire multiple `omoc_delegate(..., background=true)` simultaneously
+6. Collect and verify results upon each completion
+
+### Phase 3: Error Handling
+7. On failure: retry with more context (max 2 retries)
+8. Still failing: escalate to Oracle via `omoc_delegate(category="ultrabrain", agent_id="omoc_oracle")`
+9. Oracle can't resolve: pause and ask user
+
+### Phase 4: Completion
+10. Verify all acceptance criteria met
+11. Run build/test verification
+12. Update plan status to "completed"
+13. Record wisdom/learnings
+
+## Status Updates
+
+After each task completion:
+```
+[N/M] Task: <name> - COMPLETED
+  - <what was done>
+  - <files modified>
+  Next: <next task name>
+```

package/skills/workflow-ultrawork.md

@@ -0,0 +1,46 @@
+---
+name: workflow-ultrawork
+description: "Full planning → execution → verification workflow. Triggers on: /ultrawork, ultrawork. Activates Atlas persona and runs the complete ultrawork pipeline."
+---
+
+# Ultrawork Workflow Skill
+
+When the user invokes `/ultrawork [task]` or says "ultrawork", execute the full automation pipeline.
+
+## Persona
+
+This workflow runs under **Atlas** (omoc_atlas) — the orchestrator. If you are not already Atlas, the system will switch you automatically.
+
+## Execution Pipeline
+
+### Phase 1: Planning (Prometheus)
+1. Analyze the task description
+2. Explore the codebase: `omoc_delegate(task_description="...", category="quick", agent_id="omoc_explore", background=true)`
+3. Create a structured plan via: `omoc_delegate(task_description="...", category="ultrabrain", agent_id="omoc_prometheus")`
+4. Review the plan: `omoc_delegate(task_description="...", category="deep", agent_id="omoc_momus")`
+
+### Phase 2: Execution (Atlas → Workers)
+5. For each task in the plan:
+   - Mark as in_progress in todo list
+   - Delegate via `omoc_delegate(task_description="7-element prompt", category="deep")`
+   - On completion notification → verify → proceed to next step immediately
+   - Never stop between steps. Sub-agent completion = action trigger.
+6. Parallel tasks: fire multiple `omoc_delegate(..., background=true)` simultaneously
+
+### Phase 3: Verification
+7. Run full verification: build, lint, test, LSP diagnostics
+8. Fix any issues found
+9. Re-verify until clean
+
+### Phase 4: Completion
+10. Generate completion summary
+11. Mark all todos completed
+12. Record wisdom/learnings
+
+## Rules
+
+- **NEVER stop between phases** — this is fully automated
+- **Todo tracking is mandatory** — every step tracked via TodoWrite
+- **Delegation is mandatory** — use `omoc_delegate` for all sub-tasks
+- **Verification is mandatory** — build + test must pass before completion
+- Fix the code, not the tests (unless the test is wrong)

package/dist/commands/workflow-commands.d.ts

@@ -1,2 +0,0 @@
-import { OmocPluginApi } from '../types.js';
-export declare function registerWorkflowCommands(api: OmocPluginApi): void;

package/dist/commands/workflow-commands.js

@@ -1,54 +0,0 @@
-import { promises as fs } from 'fs';
-import { resolvePluginPath } from '../utils/paths.js';
-async function readWorkflow(workflowName) {
-    try {
-        const workflowPath = resolvePluginPath('workflows', `${workflowName}.md`);
-        return await fs.readFile(workflowPath, 'utf-8');
-    }
-    catch (error) {
-        console.warn('[omoc] Failed to read workflow file:', `workflows/${workflowName}.md`, error);
-        return `Error: Could not read workflow file 'workflows/${workflowName}.md'.`;
-    }
-}
-const WORKFLOW_COMMANDS = [
-    {
-        name: 'ultrawork',
-        description: 'Full planning → execution → verification workflow',
-        workflowFile: 'ultrawork',
-        headerTitle: 'Ultrawork Mode',
-        argLabel: 'Task',
-        defaultArgValue: 'No task specified',
-    },
-    {
-        name: 'plan',
-        description: 'Create a structured execution plan',
-        workflowFile: 'plan',
-        headerTitle: 'Planning Mode',
-        argLabel: 'Topic',
-        defaultArgValue: 'No topic specified',
-    },
-    {
-        name: 'start_work',
-        description: 'Execute an approved plan',
-        workflowFile: 'start-work',
-        headerTitle: 'Start Work Mode',
-        argLabel: 'Plan',
-        defaultArgValue: 'most recent plan',
-    },
-];
-export function registerWorkflowCommands(api) {
-    for (const config of WORKFLOW_COMMANDS) {
-        api.registerCommand({
-            name: config.name,
-            description: config.description,
-            acceptsArgs: true,
-            handler: async (ctx) => {
-                const argValue = ctx.args || config.defaultArgValue;
-                const workflow = await readWorkflow(config.workflowFile);
-                return {
-                    text: `# ${config.headerTitle}\n\n**${config.argLabel}**: ${argValue}\n\n---\n\n${workflow}`,
-                };
-            },
-        });
-    }
-}