@captain-app/openclaw 2026.2.4

package/extensions/open-prose/skills/prose/examples/29-captains-chair.prose

@@ -0,0 +1,218 @@
+# The Captain's Chair
+#
+# A project management orchestration pattern where a prime agent dispatches
+# specialized subagents for all coding, validation, and task execution.
+# The captain never writes code directly—only coordinates, validates, and
+# maintains strategic oversight.
+#
+# Key principles:
+# - Context isolation: Subagents receive targeted context, not everything
+# - Parallel execution: Multiple subagents work concurrently where possible
+# - Critic agents: Continuous review of plans and outputs
+# - Checkpoint validation: User approval at key decision points
+
+input task: "The feature or task to implement"
+input codebase_context: "Brief description of the codebase and relevant files"
+
+# ============================================================================
+# Agent Definitions: The Crew
+# ============================================================================
+
+# The Captain: Orchestrates but never codes
+agent captain:
+  model: opus
+  prompt: """You are a senior engineering manager. You NEVER write code directly.
+Your job is to:
+- Break down complex tasks into discrete work items
+- Dispatch work to appropriate specialists
+- Validate that outputs meet requirements
+- Maintain strategic alignment with user intent
+- Identify blockers and escalate decisions to the user
+
+Always think about: What context does each subagent need? What can run in parallel?
+What needs human validation before proceeding?"""
+
+# Research agents - fast, focused information gathering
+agent researcher:
+  model: haiku
+  prompt: """You are a research specialist. Find specific information quickly.
+Provide concise, actionable findings. Cite file paths and line numbers."""
+
+# Coding agents - implementation specialists
+agent coder:
+  model: sonnet
+  prompt: """You are an expert software engineer. Write clean, idiomatic code.
+Follow existing patterns in the codebase. No over-engineering."""
+
+# Critic agents - continuous quality review
+agent critic:
+  model: sonnet
+  prompt: """You are a senior code reviewer and architect. Your job is to find:
+- Logic errors and edge cases
+- Security vulnerabilities
+- Performance issues
+- Deviations from best practices
+- Unnecessary complexity
+Be constructive but thorough. Prioritize issues by severity."""
+
+# Test agent - validation specialist
+agent tester:
+  model: sonnet
+  prompt: """You are a QA engineer. Write comprehensive tests.
+Focus on edge cases and failure modes. Ensure test isolation."""
+
+# ============================================================================
+# Block Definitions: Reusable Operations
+# ============================================================================
+
+# Parallel research sweep - gather all context simultaneously
+block research-sweep(topic):
+  parallel (on-fail: "continue"):
+    docs = session: researcher
+      prompt: "Find relevant documentation and README files for: {topic}"
+    code = session: researcher
+      prompt: "Find existing code patterns and implementations related to: {topic}"
+    tests = session: researcher
+      prompt: "Find existing tests that cover functionality similar to: {topic}"
+    issues = session: researcher
+      prompt: "Search for related issues, TODOs, or known limitations for: {topic}"
+
+# Parallel code review - multiple perspectives simultaneously
+block review-cycle(code_changes):
+  parallel:
+    security = session: critic
+      prompt: "Review for security vulnerabilities and injection risks"
+      context: code_changes
+    correctness = session: critic
+      prompt: "Review for logic errors, edge cases, and correctness"
+      context: code_changes
+    style = session: critic
+      prompt: "Review for code style, readability, and maintainability"
+      context: code_changes
+    perf = session: critic
+      prompt: "Review for performance issues and optimization opportunities"
+      context: code_changes
+
+# Implementation cycle with built-in critic
+block implement-with-review(implementation_plan):
+  let code = session: coder
+    prompt: "Implement according to the plan"
+    context: implementation_plan
+
+  let review = do review-cycle(code)
+
+  if **critical issues found in review**:
+    let fixed = session: coder
+      prompt: "Address the critical issues identified in the review"
+      context: { code, review }
+    output result = fixed
+  else:
+    output result = code
+
+# ============================================================================
+# Main Workflow: The Captain's Chair in Action
+# ============================================================================
+
+# Phase 1: Strategic Planning
+# ---------------------------
+# The captain breaks down the task and identifies what information is needed
+
+let breakdown = session: captain
+  prompt: """Analyze this task and create a strategic plan:
+
+Task: {task}
+Codebase: {codebase_context}
+
+Output:
+1. List of discrete work items (what code needs to be written/changed)
+2. Dependencies between work items (what must complete before what)
+3. What can be parallelized
+4. Key questions that need user input before proceeding
+5. Risks and potential blockers"""
+
+# Phase 2: Parallel Research Sweep
+# --------------------------------
+# Dispatch researchers to gather all necessary context simultaneously
+
+do research-sweep(task)
+
+# Phase 3: Plan Synthesis and Critic Review
+# -----------------------------------------
+# Captain synthesizes research into implementation plan, critic reviews it
+
+let implementation_plan = session: captain
+  prompt: """Synthesize the research into a detailed implementation plan.
+
+Research findings:
+{docs}
+{code}
+{tests}
+{issues}
+
+For each work item, specify:
+- Exact files to modify
+- Code patterns to follow
+- Tests to add or update
+- Integration points"""
+  context: { breakdown, docs, code, tests, issues }
+
+# Critic reviews the plan BEFORE implementation begins
+let plan_review = session: critic
+  prompt: """Review this implementation plan for:
+- Missing edge cases
+- Architectural concerns
+- Testability issues
+- Scope creep
+- Unclear requirements that need user clarification"""
+  context: implementation_plan
+
+# Checkpoint: User validates plan before execution
+if **the plan review raised critical concerns**:
+  let revised_plan = session: captain
+    prompt: "Revise the plan based on critic feedback"
+    context: { implementation_plan, plan_review }
+  # Continue with revised plan
+  let final_plan = revised_plan
+else:
+  let final_plan = implementation_plan
+
+# Phase 4: Parallel Implementation
+# --------------------------------
+# Identify independent work items and execute in parallel where possible
+
+let work_items = session: captain
+  prompt: "Extract the independent work items that can be done in parallel from this plan"
+  context: final_plan
+
+# Execute independent items in parallel, each with its own review cycle
+parallel (on-fail: "continue"):
+  impl_a = do implement-with-review(work_items)
+  impl_b = session: tester
+    prompt: "Write tests for the planned functionality"
+    context: { final_plan, code }
+
+# Phase 5: Integration and Final Review
+# -------------------------------------
+# Captain validates all pieces fit together
+
+let integration = session: captain
+  prompt: """Review all implementation results and verify:
+1. All work items completed successfully
+2. Tests cover the new functionality
+3. No merge conflicts or integration issues
+4. Documentation updated if needed
+
+Summarize what was done and any remaining items."""
+  context: { impl_a, impl_b, final_plan }
+
+# Final critic pass on complete implementation
+let final_review = do review-cycle(integration)
+
+if **final review passed**:
+  output result = session: captain
+    prompt: "Prepare final summary for user: what was implemented, tests added, and next steps"
+    context: { integration, final_review }
+else:
+  output result = session: captain
+    prompt: "Summarize what was completed and what issues remain for user attention"
+    context: { integration, final_review }

package/extensions/open-prose/skills/prose/examples/30-captains-chair-simple.prose

@@ -0,0 +1,42 @@
+# Simple Captain's Chair
+#
+# The minimal captain's chair pattern: a coordinating agent that dispatches
+# subagents for all execution. The captain only plans and validates.
+
+input task: "What to accomplish"
+
+# The captain coordinates but never executes
+agent captain:
+  model: opus
+  prompt: "You are a project coordinator. Never write code directly. Break down tasks, dispatch to specialists, validate results."
+
+agent executor:
+  model: opus
+  prompt: "You are a skilled implementer. Execute the assigned task precisely."
+
+agent critic:
+  model: opus
+  prompt: "You are a critic. Find issues, suggest improvements. Be thorough."
+
+# Step 1: Captain creates the plan
+let plan = session: captain
+  prompt: "Break down this task into work items: {task}"
+
+# Step 2: Dispatch parallel execution
+parallel:
+  work = session: executor
+    prompt: "Execute the plan"
+    context: plan
+  review = session: critic
+    prompt: "Identify potential issues with this approach"
+    context: plan
+
+# Step 3: Captain synthesizes and validates
+if **critic found issues that affect the work**:
+  output result = session: captain
+    prompt: "Integrate the work while addressing critic's concerns"
+    context: { work, review }
+else:
+  output result = session: captain
+    prompt: "Validate and summarize the completed work"
+    context: { work, review }

package/extensions/open-prose/skills/prose/examples/31-captains-chair-with-memory.prose

@@ -0,0 +1,145 @@
+# Captain's Chair with Memory and Self-Improvement
+#
+# An advanced orchestration pattern that includes:
+# - Retrospective analysis after task completion
+# - Learning from mistakes to improve future runs
+# - Continuous critic supervision during execution
+#
+# From the blog post: "Future agents will flip the plan:execute paradigm
+# to 80:20 from today's 20:80"
+
+input task: "The task to accomplish"
+input past_learnings: "Previous session learnings (if any)"
+
+# ============================================================================
+# Agent Definitions
+# ============================================================================
+
+agent captain:
+  model: opus
+  prompt: """You are a senior engineering manager. You coordinate but never code directly.
+
+Your responsibilities:
+1. Strategic planning with 80% of effort on planning, 20% on execution oversight
+2. Dispatch specialized subagents for all implementation
+3. Validate outputs meet requirements
+4. Learn from each session to improve future runs
+
+Past learnings to incorporate:
+{past_learnings}"""
+
+agent planner:
+  model: opus
+  prompt: """You are a meticulous planner. Create implementation plans with:
+- Exact files and line numbers to modify
+- Code patterns to follow from existing codebase
+- Edge cases to handle
+- Tests to write"""
+
+agent researcher:
+  model: haiku
+  prompt: "Find specific information quickly. Cite sources."
+
+agent executor:
+  model: sonnet
+  prompt: "Implement precisely according to plan. Follow existing patterns."
+
+agent critic:
+  model: sonnet
+  prompt: """You are a continuous critic. Your job is to watch execution and flag:
+- Deviations from plan
+- Emerging issues
+- Opportunities for improvement
+Be proactive - don't wait for completion to raise concerns."""
+
+agent retrospective:
+  model: opus
+  prompt: """You analyze completed sessions to extract learnings:
+- What went well?
+- What could be improved?
+- What should be remembered for next time?
+Output actionable insights, not platitudes."""
+
+# ============================================================================
+# Phase 1: Deep Planning (80% of effort)
+# ============================================================================
+
+# Parallel research - gather everything needed upfront
+parallel:
+  codebase = session: researcher
+    prompt: "Map the relevant parts of the codebase for: {task}"
+  patterns = session: researcher
+    prompt: "Find coding patterns and conventions used in this repo"
+  docs = session: researcher
+    prompt: "Find documentation and prior decisions related to: {task}"
+  issues = session: researcher
+    prompt: "Find known issues, TODOs, and edge cases for: {task}"
+
+# Create detailed implementation plan
+let detailed_plan = session: planner
+  prompt: """Create a comprehensive implementation plan for: {task}
+
+Use the research to specify:
+1. Exact changes needed (file:line format)
+2. Code patterns to follow
+3. Edge cases from prior issues
+4. Test coverage requirements"""
+  context: { codebase, patterns, docs, issues }
+
+# Critic reviews plan BEFORE execution
+let plan_critique = session: critic
+  prompt: "Review this plan for gaps, risks, and unclear requirements"
+  context: detailed_plan
+
+# Captain decides if plan needs revision
+if **plan critique identified blocking issues**:
+  let revised_plan = session: planner
+    prompt: "Revise the plan to address critique"
+    context: { detailed_plan, plan_critique }
+else:
+  let revised_plan = detailed_plan
+
+# ============================================================================
+# Phase 2: Supervised Execution (20% of effort)
+# ============================================================================
+
+# Execute with concurrent critic supervision
+parallel:
+  implementation = session: executor
+    prompt: "Implement according to the plan"
+    context: revised_plan
+  live_critique = session: critic
+    prompt: "Monitor implementation for deviations and emerging issues"
+    context: revised_plan
+
+# Captain validates and integrates
+let validated = session: captain
+  prompt: """Validate the implementation:
+- Does it match the plan?
+- Were critic's live concerns addressed?
+- Is it ready for user review?"""
+  context: { implementation, live_critique, revised_plan }
+
+# ============================================================================
+# Phase 3: Retrospective and Learning
+# ============================================================================
+
+# Extract learnings for future sessions
+let session_learnings = session: retrospective
+  prompt: """Analyze this completed session:
+
+Plan: {revised_plan}
+Implementation: {implementation}
+Critique: {live_critique}
+Validation: {validated}
+
+Extract:
+1. What patterns worked well?
+2. What caused friction or rework?
+3. What should the captain remember next time?
+4. Any codebase insights to preserve?"""
+  context: { revised_plan, implementation, live_critique, validated }
+
+# Output both the result and the learnings
+output result = validated
+output learnings = session_learnings

package/extensions/open-prose/skills/prose/examples/33-pr-review-autofix.prose

@@ -0,0 +1,168 @@
+# PR Review + Auto-Fix
+#
+# A self-healing code review pipeline. Reviews a PR from multiple angles,
+# identifies issues, and automatically fixes them in a loop until the
+# review passes. Satisfying to watch as issues get knocked down one by one.
+#
+# Usage: Run against any open PR in your repo.
+
+agent reviewer:
+  model: sonnet
+  prompt: """
+You are a senior code reviewer. You review code for:
+- Correctness and logic errors
+- Security vulnerabilities
+- Performance issues
+- Code style and readability
+
+Be specific. Reference exact file paths and line numbers.
+Return a structured list of issues or "APPROVED" if none found.
+"""
+
+agent security-reviewer:
+  model: opus          # Security requires deep reasoning
+  prompt: """
+You are a security specialist. Focus exclusively on:
+- Injection vulnerabilities (SQL, command, XSS)
+- Authentication/authorization flaws
+- Data exposure and privacy issues
+- Cryptographic weaknesses
+
+If you find issues, they are HIGH priority. Be thorough.
+"""
+
+agent fixer:
+  model: opus          # Fixing requires understanding + execution
+  prompt: """
+You are a code fixer. Given an issue report:
+1. Understand the root cause
+2. Implement the minimal fix
+3. Verify the fix addresses the issue
+4. Create a clean commit
+
+Do NOT over-engineer. Fix exactly what's reported, nothing more.
+"""
+
+agent captain:
+  model: sonnet        # Orchestration role
+  persist: true
+  prompt: """
+You coordinate the PR review process. You:
+- Track which issues have been found and fixed
+- Decide when the PR is ready to merge
+- Escalate to human if something is unfixable
+"""
+
+# Get the PR diff
+let pr_diff = session "Fetch the PR diff"
+  prompt: """
+Read the current PR:
+1. Run: gh pr diff
+2. Also get: gh pr view --json title,body,files
+3. Return the complete diff and PR metadata
+"""
+
+# Phase 1: Parallel multi-perspective review
+session: captain
+  prompt: "Starting PR review. I'll coordinate multiple reviewers."
+
+parallel:
+  general_review = session: reviewer
+    prompt: "Review this PR for correctness, logic, and style issues"
+    context: pr_diff
+
+  security_review = session: security-reviewer
+    prompt: "Security audit this PR. Flag any vulnerabilities."
+    context: pr_diff
+
+  test_check = session "Check test coverage"
+    prompt: """
+Analyze the PR:
+1. What code changed?
+2. Are there tests for the changes?
+3. Run existing tests: npm test / pytest / cargo test
+Return: test status and coverage gaps
+"""
+    context: pr_diff
+
+# Phase 2: Captain synthesizes and prioritizes
+let issues = resume: captain
+  prompt: """
+Synthesize all review feedback into a prioritized issue list.
+Format each issue as:
+- ID: issue-N
+- Severity: critical/high/medium/low
+- File: path/to/file.ts
+- Line: 42
+- Issue: description
+- Fix: suggested approach
+
+If all reviews passed, return "ALL_CLEAR".
+"""
+  context: { general_review, security_review, test_check }
+
+# Phase 3: Auto-fix loop
+loop until **all issues are resolved or unfixable** (max: 10):
+
+  if **there are no remaining issues**:
+    resume: captain
+      prompt: "All issues resolved! Summarize what was fixed."
+  else:
+    # Pick the highest priority unfixed issue
+    let current_issue = resume: captain
+      prompt: "Select the next highest priority issue to fix."
+      context: issues
+
+    # Attempt the fix
+    try:
+      session: fixer
+        prompt: """
+Fix this issue:
+{current_issue}
+
+Steps:
+1. Read the file
+2. Understand the context
+3. Implement the fix
+4. Run tests to verify
+5. Commit with message: "fix: [issue description]"
+"""
+        context: current_issue
+        retry: 2
+        backoff: exponential
+
+      # Mark as fixed
+      resume: captain
+        prompt: "Issue fixed. Update tracking and check remaining issues."
+        context: current_issue
+
+    catch as fix_error:
+      # Escalate unfixable issues
+      resume: captain
+        prompt: """
+Fix attempt failed. Determine if this is:
+1. Retryable with different approach
+2. Needs human intervention
+3. A false positive (not actually an issue)
+
+Update issue status accordingly.
+"""
+        context: { current_issue, fix_error }
+
+# Phase 4: Final verification
+let final_review = session: reviewer
+  prompt: "Final review pass. Verify all fixes are correct and complete."
+
+resume: captain
+  prompt: """
+PR Review Complete!
+
+Generate final report:
+- Issues found: N
+- Issues fixed: N
+- Issues requiring human review: N
+- Recommendation: MERGE / NEEDS_ATTENTION / BLOCK
+
+If ready, run: gh pr review --approve
+"""
+  context: final_review