@happycastle/oh-my-openclaw 0.3.0 → 0.3.1

package/dist/commands/workflow-commands.js

@@ -1,12 +1,17 @@
 import { readFileSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// From dist/commands/ → plugin root is ../../
+const PLUGIN_ROOT = join(__dirname, '..', '..');
 function readWorkflow(workflowName) {
     try {
-        const workflowPath = join(process.cwd(), 'workflows', `${workflowName}.md`);
+        const workflowPath = join(PLUGIN_ROOT, 'workflows', `${workflowName}.md`);
         return readFileSync(workflowPath, 'utf-8');
     }
     catch {
-        return `Error: Could not read workflow file 'workflows/${workflowName}.md'. Make sure the oh-my-openclaw skill directory is accessible.`;
+        return `Error: Could not read workflow file 'workflows/${workflowName}.md'. Plugin root: ${PLUGIN_ROOT}`;
     }
 }
 export function registerWorkflowCommands(api) {

package/dist/index.js

@@ -11,7 +11,7 @@ import { registerWorkflowCommands } from './commands/workflow-commands.js';
 import { registerRalphCommands } from './commands/ralph-commands.js';
 export default function register(api) {
     const config = getConfig(api);
-    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v0.3.0`);
+    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v0.3.1`);
     try {
         registerTodoEnforcer(api);
         api.logger.info(`[${PLUGIN_ID}] Todo Enforcer hook registered (enabled: ${config.todo_enforcer_enabled})`);
@@ -79,7 +79,7 @@ export default function register(api) {
         return {
             ok: true,
             plugin: PLUGIN_ID,
-            version: '0.3.0',
+            version: '0.3.1',
             hooks: ['todo-enforcer', 'comment-checker', 'message-monitor'],
             services: ['ralph-loop'],
             tools: ['omoc_delegate', 'omoc_look_at', 'omoc_checkpoint'],

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "oh-my-openclaw",
   "name": "Oh-My-OpenClaw",
   "description": "Multi-agent orchestration plugin \u2014 10 agents, category-based model routing, todo enforcer, ralph loop, and custom tools",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "skills": ["skills"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happycastle/oh-my-openclaw",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Oh-My-OpenClaw plugin — multi-agent orchestration, todo enforcer, ralph loop, and custom tools for OpenClaw",
   "type": "module",
   "main": "dist/index.js",
@@ -36,6 +36,7 @@
     "dist",
     "bin",
     "skills",
+    "workflows",
     "openclaw.plugin.json"
   ],
   "keywords": [

package/workflows/plan.md

@@ -0,0 +1,115 @@
+---
+description: Strategic planning workflow - analyze requirements and create execution plan
+---
+
+# Plan Workflow
+
+Strategic planning workflow that analyzes requirements and creates a structured execution plan before any implementation begins.
+
+## When to Use
+
+- Starting a new feature or project
+- Complex multi-step tasks
+- When requirements are ambiguous and need clarification
+- Before any `/ultrawork` or `/start-work` invocation
+
+## Workflow Steps
+
+### Phase 1: Context Gathering
+
+1. **Read existing context**
+   - Check workspace for existing plans: `workspace/plans/`
+   - Check wisdom notepads: `workspace/notepads/`
+   - Review any relevant AGENTS.md or project documentation
+
+2. **Analyze the request**
+   - What is the user asking for?
+   - What are the explicit requirements?
+   - What are the implicit requirements?
+   - What constraints exist?
+
+### Phase 2: Gap Analysis
+
+3. **Identify unknowns**
+   - What information is missing?
+   - What assumptions are being made?
+   - What dependencies exist?
+
+4. **Ask clarifying questions** (if needed)
+   - Only ask questions that materially affect the plan
+   - Batch questions together, don't ask one at a time
+   - Provide default assumptions if the user doesn't respond
+
+### Phase 3: Plan Creation
+
+5. **Create the execution plan**
+   - Save to `workspace/plans/YYYY-MM-DD_<slug>.md`
+   - Use the following structure:
+
+```markdown
+# Plan: <Title>
+
+**Created**: YYYY-MM-DD HH:MM
+**Status**: draft | approved | in-progress | completed
+**Category**: quick | deep | ultrabrain | visual-engineering
+
+## Goal
+<One sentence description of what we're building>
+
+## Requirements
+- [ ] Requirement 1
+- [ ] Requirement 2
+
+## Tasks
+### Task 1: <Name>
+- **Category**: quick | deep
+- **Agent**: sisyphus-junior | oracle | explore | librarian
+- **Dependencies**: none | Task N
+- **Description**: What needs to be done
+- **Acceptance Criteria**:
+  - [ ] Criterion 1
+  - [ ] Criterion 2
+
+### Task 2: <Name>
+...
+
+## Execution Order
+1. Task 1 (no dependencies)
+2. Task 2, Task 3 (parallel, depend on Task 1)
+3. Task 4 (depends on Task 2 + Task 3)
+
+## Risks
+- Risk 1: mitigation strategy
+- Risk 2: mitigation strategy
+
+## Verification
+- [ ] All acceptance criteria met
+- [ ] Code builds without errors
+- [ ] Tests pass (if applicable)
+```
+
+### Phase 4: Plan Review
+
+6. **Self-review the plan**
+   - Is every task actionable and specific?
+   - Are dependencies correctly identified?
+   - Is the execution order optimal (maximize parallelism)?
+   - Are acceptance criteria measurable?
+
+7. **Present plan to user**
+   - Show the plan summary
+   - Highlight any risks or assumptions
+   - Ask for approval before proceeding
+
+## Integration with Other Workflows
+
+- After plan approval, use `/start-work` to begin execution
+- Or use `/ultrawork` for fully automated execution without stops
+- Plan files persist in `workspace/plans/` for future reference
+
+## Wisdom Integration
+
+After planning, record any insights:
+- New patterns discovered → `workspace/notepads/learnings.md`
+- Key decisions made → `workspace/notepads/decisions.md`
+- Potential issues identified → `workspace/notepads/issues.md`

package/workflows/start-work.md

@@ -0,0 +1,110 @@
+---
+description: Start execution from an approved plan - delegate tasks to worker agents
+---
+
+# Start Work Workflow
+
+Execute an approved plan by delegating tasks to appropriate worker agents, tracking progress, and verifying completion.
+
+## Prerequisites
+
+- An approved plan exists in `workspace/plans/`
+- Plan status is "approved" or "in-progress"
+
+## Workflow Steps
+
+### Phase 1: Plan Loading
+
+1. **Load the plan**
+   - Read the most recent plan from `workspace/plans/`
+   - Or specify a plan: `/start-work <plan-file>`
+   - Verify plan status is "approved"
+   - Update plan status to "in-progress"
+
+2. **Initialize tracking**
+   - Create todo items for each task in the plan
+   - Set up wisdom notepads if not already present
+
+### Phase 2: Task Execution
+
+3. **Execute tasks in dependency order**
+
+   For each task (respecting execution order from plan):
+
+   a. **Mark task as in-progress** in todo list
+
+   b. **Select the right agent** based on task category:
+   
+   | Category | Agent | Model |
+   |----------|-------|-------|
+   | quick | sisyphus-junior | claude-sonnet-4-6 |
+   | deep | sisyphus-junior | claude-opus-4-6-thinking |
+   | ultrabrain | oracle | claude-opus-4-5-thinking |
+   | visual-engineering | sisyphus-junior | claude-opus-4-6-thinking |
+
+   c. **Delegate the task** with clear instructions:
+   ```
+   Task: <task name>
+   Description: <from plan>
+   Acceptance Criteria:
+   - <criterion 1>
+   - <criterion 2>
+   Context: <relevant files, dependencies>
+   ```
+
+   d. **Verify task completion** against acceptance criteria
+
+   e. **Mark task as completed** in todo list
+
+   f. **Record wisdom** if any insights were gained
+
+4. **Handle parallel tasks**
+   - Tasks with no mutual dependencies can run in parallel
+   - Use multiple agent spawns simultaneously
+   - Wait for all parallel tasks before moving to dependent tasks
+
+### Phase 3: Error Handling
+
+5. **On task failure**
+   - Record the error in `workspace/notepads/issues.md`
+   - Attempt retry with more context (max 2 retries)
+   - If still failing, escalate to oracle agent for debugging
+   - If oracle can't resolve, pause and ask user
+
+6. **On blocking dependency**
+   - Skip blocked tasks, continue with independent tasks
+   - Return to blocked tasks when dependency resolves
+
+### Phase 4: Completion
+
+7. **Verify all tasks**
+   - Check all acceptance criteria are met
+   - Run build/test verification if applicable
+   - Review overall coherence of changes
+
+8. **Update plan status**
+   - Mark plan as "completed"
+   - Record completion time
+   - Summarize what was accomplished
+
+9. **Final wisdom capture**
+   - Record learnings in `workspace/notepads/learnings.md`
+   - Record any decisions in `workspace/notepads/decisions.md`
+   - Note any remaining issues in `workspace/notepads/issues.md`
+
+## Status Update Format
+
+After each task completion, output:
+
+```
+[N/M] Task: <name> - COMPLETED
+  - <what was done>
+  - <files modified>
+  Next: <next task name>
+```
+
+## Integration
+
+- Plans come from `/plan` workflow
+- `/ultrawork` combines `/plan` + `/start-work` automatically
+- Wisdom notepads persist across sessions for future reference

package/workflows/ultrawork.md

@@ -0,0 +1,90 @@
+---
+description: One-command full automation workflow. Analyzes task, creates plan, executes all steps, verifies results.
+---
+
+# Ultrawork Workflow
+
+Complete automation workflow that takes a task from analysis to verified completion.
+
+## Trigger
+When the user invokes `/ultrawork [task description]` or ultrawork mode is activated.
+
+## Prerequisites
+- Task description must be clear and actionable
+- Working directory must be a valid project
+
+## Workflow Steps
+
+### Phase 1: Analysis (Prometheus)
+```
+1. Read the task description carefully
+2. Analyze the current codebase state
+   - Run `git status` to check working tree
+   - Read relevant files to understand context
+   - Identify affected modules and dependencies
+3. Create a structured plan with:
+   - Clear task breakdown (numbered steps)
+   - Dependencies between steps
+   - Category assignment for each step (quick/deep/ultrabrain/visual-engineering)
+   - Verification criteria for each step
+4. Save plan to `workspace/plans/ultrawork-[timestamp].md`
+```
+
+### Phase 2: Execution (Atlas + Workers)
+```
+5. For each step in the plan:
+   a. Mark step as in_progress in todo list
+   b. Execute the step using appropriate tools
+   c. Verify the step's completion criteria
+   d. Record any learnings in wisdom notepad
+   e. Mark step as completed
+   f. If step fails:
+      - Analyze the failure
+      - Attempt fix (max 3 retries)
+      - If still failing, record issue and continue with next independent step
+```
+
+### Phase 3: Verification
+```
+6. Run full verification:
+   - Build check (if applicable): `npm run build`, `cargo build`, `go build`, etc.
+   - Lint check (if applicable)
+   - Test check (if applicable)
+   - LSP diagnostics check
+7. Fix any issues found during verification
+8. Run verification again until clean
+```
+
+### Phase 4: Completion
+```
+9. Generate completion summary:
+   - What was done
+   - What was changed (files modified/created/deleted)
+   - Any issues encountered and how they were resolved
+   - Wisdom accumulated
+10. Update wisdom notepads with final learnings
+11. Mark all todos as completed
+```
+
+## Todo Enforcer Integration
+
+During ultrawork execution, the following directive is active:
+
+> You MUST use TodoWrite to track every task. Mark tasks in_progress when starting,
+> completed when done. NEVER leave tasks unmarked. If you discover new subtasks,
+> add them immediately. Do not stop until all tasks are completed.
+
+## Error Handling
+
+- **Build failures**: Fix immediately, re-verify
+- **Test failures**: Fix the code, not the test (unless test is wrong)
+- **Lint errors**: Auto-fix where possible, manual fix otherwise
+- **Timeout**: Save progress, report partial completion with clear next steps
+
+## Output
+
+The workflow produces:
+1. Completed task with all changes applied
+2. Plan file in `workspace/plans/`
+3. Updated wisdom notepads (if learnings occurred)
+4. Completion summary in the conversation