opencode-multiagent 0.2.1 → 0.3.0-next.1

package/skills/cek-thought-based-reasoning/SKILL.md

@@ -9,19 +9,18 @@ description: Use when tackling complex reasoning tasks requiring step-by-step lo
 
 Chain-of-Thought (CoT) prompting and its variants encourage LLMs to generate intermediate reasoning steps before arriving at a final answer, significantly improving performance on complex reasoning tasks. These techniques transform how models approach problems by making implicit reasoning explicit.
 
-
 ## Quick Reference
 
-| Technique | When to Use | Complexity | Accuracy Gain |
-|-----------|-------------|------------|---------------|
-| Zero-shot CoT | Quick reasoning, no examples available | Low | +20-60% |
-| Few-shot CoT | Have good examples, consistent format needed | Medium | +30-70% |
-| Self-Consistency | High-stakes decisions, need confidence | Medium | +10-20% over CoT |
-| Tree of Thoughts | Complex problems requiring exploration | High | +50-70% on hard tasks |
-| Least-to-Most | Multi-step problems with subproblems | Medium | +30-80% |
-| ReAct | Tasks requiring external information | Medium | +15-35% |
-| PAL | Mathematical/computational problems | Medium | +10-15% |
-| Reflexion | Iterative improvement, learning from errors | High | +10-20% |
+| Technique        | When to Use                                  | Complexity | Accuracy Gain         |
+| ---------------- | -------------------------------------------- | ---------- | --------------------- |
+| Zero-shot CoT    | Quick reasoning, no examples available       | Low        | +20-60%               |
+| Few-shot CoT     | Have good examples, consistent format needed | Medium     | +30-70%               |
+| Self-Consistency | High-stakes decisions, need confidence       | Medium     | +10-20% over CoT      |
+| Tree of Thoughts | Complex problems requiring exploration       | High       | +50-70% on hard tasks |
+| Least-to-Most    | Multi-step problems with subproblems         | Medium     | +30-80%               |
+| ReAct            | Tasks requiring external information         | Medium     | +15-35%               |
+| PAL              | Mathematical/computational problems          | Medium     | +10-15%               |
+| Reflexion        | Iterative improvement, learning from errors  | High       | +10-20%               |
 
 ---
 
@@ -33,12 +32,14 @@ Chain-of-Thought (CoT) prompting and its variants encourage LLMs to generate int
 **Citations**: 14,255+
 
 #### When to Use
+
 - Multi-step arithmetic or math word problems
 - Commonsense reasoning requiring logical deduction
 - Symbolic reasoning tasks
 - When you have good exemplars showing reasoning
 
 #### How It Works
+
 Provide few-shot examples that include intermediate reasoning steps, not just question-answer pairs. The model learns to generate similar step-by-step reasoning.
 
 #### Prompt Template
@@ -55,11 +56,13 @@ A:
 ```
 
 #### Strengths
+
 - Significant accuracy improvements on reasoning tasks
 - Interpretable intermediate steps
 - Works well with large models (>100B parameters)
 
 #### Limitations
+
 - Requires crafting good exemplars
 - Less effective on smaller models
 - Can still make calculation errors
@@ -72,12 +75,14 @@ A:
 **Citations**: 5,985+
 
 #### When to Use
+
 - No exemplars available
 - Quick reasoning needed
 - General-purpose reasoning across task types
 - Prototyping before creating few-shot examples
 
 #### How It Works
+
 Simply append "Let's think step by step" (or similar phrase) to the prompt. This triggers the model to generate reasoning steps without any examples.
 
 #### Prompt Template
@@ -89,6 +94,7 @@ Let's think step by step.
 ```
 
 **Alternative trigger phrases**:
+
 - "Let's work this out step by step to be sure we have the right answer."
 - "Let's break this down."
 - "Let's approach this systematically."
@@ -97,23 +103,27 @@ Let's think step by step.
 #### Two-Stage Approach (More Robust)
 
 **Stage 1 - Reasoning Extraction**:
+
 ```
 Q: [QUESTION]
 A: Let's think step by step.
 ```
 
 **Stage 2 - Answer Extraction**:
+
 ```
 [REASONING FROM STAGE 1]
 Therefore, the answer is
 ```
 
 #### Strengths
+
 - No exemplar crafting required
 - Generalizes across task types
 - Simple to implement
 
 #### Limitations
+
 - Less effective than few-shot CoT
 - Can produce verbose or irrelevant reasoning
 - Sensitive to exact phrasing
@@ -126,12 +136,14 @@ Therefore, the answer is
 **Citations**: 5,379+
 
 #### When to Use
+
 - High-stakes decisions requiring confidence
 - Problems with multiple valid reasoning paths
 - When you need to reduce variance in outputs
 - Verification of reasoning correctness
 
 #### How It Works
+
 Sample multiple diverse reasoning paths, then select the most consistent answer via majority voting. The intuition: correct answers can be reached through multiple reasoning paths.
 
 #### Prompt Template
@@ -161,11 +173,13 @@ def self_consistency(prompt, n_samples=5, temperature=0.7):
 ```
 
 #### Strengths
+
 - Significant accuracy boost over single-path CoT
 - Provides confidence measure (agreement level)
 - Task-agnostic improvement
 
 #### Limitations
+
 - Higher computational cost (N times more generations)
 - Requires extractable discrete answers
 - Diminishing returns beyond ~10-20 samples
@@ -178,17 +192,20 @@ def self_consistency(prompt, n_samples=5, temperature=0.7):
 **Citations**: 3,026+
 
 #### When to Use
+
 - Complex problems requiring exploration/backtracking
 - Tasks where initial decisions are pivotal
 - Creative problem-solving (writing, puzzles)
 - When CoT alone achieves <50% accuracy
 
 #### How It Works
+
 Generalize CoT to a tree structure where each node is a "thought" (coherent language unit). Uses search algorithms (BFS/DFS) with self-evaluation to explore and select promising reasoning paths.
 
 #### Prompt Template
 
 **Thought Generation**:
+
 ```
 Given the current state:
 [STATE]
@@ -197,6 +214,7 @@ Generate 3-5 possible next steps to solve this problem.
 ```
 
 **State Evaluation**:
+
 ```
 Evaluate if the following partial solution is:
 - "sure" (definitely leads to solution)
@@ -208,6 +226,7 @@ Partial solution:
 ```
 
 **BFS/DFS Search**:
+
 ```python
 def tree_of_thoughts(problem, max_depth=3, beam_width=3):
     queue = [(problem, [])]  # (state, thought_path)
@@ -249,11 +268,13 @@ Evaluation: "impossible" - no way to get 24 from these
 ```
 
 #### Strengths
+
 - Dramatically improves performance on hard tasks (4% → 74% on Game of 24)
 - Enables backtracking and exploration
 - Self-evaluation catches errors early
 
 #### Limitations
+
 - Significantly higher computational cost
 - Requires task-specific thought decomposition
 - Complex to implement
@@ -266,19 +287,23 @@ Evaluation: "impossible" - no way to get 24 from these
 **Citations**: 1,466+
 
 #### When to Use
+
 - Problems harder than your exemplars
 - Compositional generalization tasks
 - Multi-step problems with clear subproblems
 - Symbol manipulation and SCAN-like tasks
 
 #### How It Works
+
 Two-stage process:
+
 1. **Decomposition**: Break complex problem into simpler subproblems
 2. **Sequential Solving**: Solve subproblems in order, using previous answers
 
 #### Prompt Template
 
 **Stage 1: Decomposition**
+
 ```
 Q: Four years ago, Kody was only half as old as Mohamed. If Mohamed is currently twice as old as 30 years old, how old is Kody?
 
@@ -289,6 +314,7 @@ Then we need to solve:
 ```
 
 **Stage 2: Sequential Solving**
+
 ```
 Q: If Mohamed is currently twice as old as 30 years old, how old is Mohamed?
 A: Mohamed is twice as old as 30, so Mohamed is 30 * 2 = 60 years old.
@@ -300,11 +326,13 @@ The answer is 32.
 ```
 
 #### Strengths
+
 - Excellent at generalizing to harder problems
 - Works well on compositional tasks
 - Explicit problem decomposition aids interpretability
 
 #### Limitations
+
 - Requires two-stage prompting
 - Decomposition step can fail on novel structures
 - More complex setup than single-stage CoT
@@ -317,12 +345,14 @@ The answer is 32.
 **Citations**: 5,012+
 
 #### When to Use
+
 - Tasks requiring external information (search, APIs)
 - Interactive decision-making environments
 - Multi-hop question answering
 - When pure reasoning leads to hallucination
 
 #### How It Works
+
 Interleave reasoning traces ("Thought") with actions ("Action") and observations ("Observation"). Reasoning helps plan actions; actions provide new information for reasoning.
 
 #### Prompt Template
@@ -351,16 +381,19 @@ Action 5: Finish[1,800 to 7,000 ft]
 ```
 
 #### Action Types
+
 - `Search[query]` - Search for information
 - `Lookup[keyword]` - Look up keyword in current context
 - `Finish[answer]` - Return final answer
 
 #### Strengths
+
 - Reduces hallucination by grounding in external knowledge
 - Interpretable action traces
 - Handles exceptions through adaptive reasoning
 
 #### Limitations
+
 - Requires integration with external tools
 - More complex orchestration
 - Action space must be defined
@@ -373,12 +406,14 @@ Action 5: Finish[1,800 to 7,000 ft]
 **Citations**: 608+
 
 #### When to Use
+
 - Mathematical/arithmetic reasoning
 - Problems requiring precise computation
 - Symbolic manipulation
 - When CoT makes calculation errors
 
 #### How It Works
+
 Generate code (typically Python) instead of natural language reasoning. Execute the code to get the answer. The LLM handles decomposition; the interpreter handles computation.
 
 #### Prompt Template
@@ -410,11 +445,13 @@ def solution():
 ```
 
 #### Strengths
+
 - Eliminates arithmetic errors
 - Clear variable naming aids interpretability
 - Leverages code execution for verification
 
 #### Limitations
+
 - Requires code interpreter
 - Not suitable for non-computational reasoning
 - Model must generate syntactically correct code
@@ -427,12 +464,14 @@ def solution():
 **Citations**: 838+
 
 #### When to Use
+
 - No manually crafted exemplars available
 - Want to automate few-shot CoT setup
 - Scaling CoT to many tasks
 - When zero-shot CoT isn't sufficient
 
 #### How It Works
+
 1. Cluster questions by diversity
 2. Use Zero-shot CoT to generate reasoning chains for representative questions
 3. Use these auto-generated chains as few-shot exemplars
@@ -440,6 +479,7 @@ def solution():
 #### Prompt Template
 
 **Step 1: Generate diverse demonstrations**
+
 ```python
 # Cluster questions
 clusters = cluster_questions(all_questions, k=8)
@@ -453,6 +493,7 @@ for cluster in clusters:
 ```
 
 **Step 2: Use as few-shot exemplars**
+
 ```
 Q: [Demo question 1]
 A: Let's think step by step. [Generated reasoning 1]
@@ -467,11 +508,13 @@ A: Let's think step by step.
 ```
 
 #### Strengths
+
 - No manual exemplar creation
 - Diversity sampling improves robustness
 - Matches manual CoT performance
 
 #### Limitations
+
 - Quality depends on zero-shot CoT quality
 - Clustering requires similarity metric
 - Some generated chains contain errors
@@ -484,17 +527,20 @@ A: Let's think step by step.
 **Citations**: 2,179+
 
 #### When to Use
+
 - Iterative improvement over multiple attempts
 - Learning from errors without fine-tuning
 - Complex coding or decision-making tasks
 - When single-pass reasoning is insufficient
 
 #### How It Works
+
 After task failure, the agent generates a verbal "reflection" analyzing what went wrong. This reflection is stored in memory and used in subsequent attempts to avoid repeating mistakes.
 
 #### Prompt Template
 
 **Initial Attempt**:
+
 ```
 Task: [TASK DESCRIPTION]
 
@@ -505,6 +551,7 @@ Result: [FAILURE/PARTIAL SUCCESS]
 ```
 
 **Reflection**:
+
 ```
 The previous attempt failed because:
 1. [SPECIFIC ERROR ANALYSIS]
@@ -515,6 +562,7 @@ Reflection: In the next attempt, I should...
 ```
 
 **Subsequent Attempt (with memory)**:
+
 ```
 Task: [TASK DESCRIPTION]
 
@@ -546,11 +594,13 @@ Test Result: Passed all tests
 ```
 
 #### Strengths
+
 - Learns from errors without weight updates
 - Achieves 91% on HumanEval (surpassing GPT-4's 80%)
 - Builds episodic memory of insights
 
 #### Limitations
+
 - Requires multiple attempts
 - Memory management for long sessions
 - Quality of reflection affects improvement
@@ -600,21 +650,26 @@ Least-to-Most     Need exploration?
 ## Best Practices
 
 ### 1. Start Simple
+
 Begin with Zero-shot CoT ("Let's think step by step"), then progress to more complex techniques if needed.
 
 ### 2. Match Technique to Task
+
 - **Math/Logic**: CoT, PAL, Self-Consistency
 - **Multi-hop QA**: ReAct, Least-to-Most
 - **Creative/Puzzles**: Tree of Thoughts
 - **Iterative Tasks**: Reflexion
 
 ### 3. Combine Techniques
+
 Techniques are often complementary:
+
 - ReAct + Self-Consistency for robust factual answers
 - ToT + PAL for complex computational exploration
 - Least-to-Most + Reflexion for hard multi-step problems
 
 ### 4. Prompt Engineering Tips
+
 - Use clear step markers ("Step 1:", "First,", etc.)
 - Include diverse exemplars covering edge cases
 - Format consistently across examples
@@ -624,16 +679,15 @@ Techniques are often complementary:
 
 ## Common Mistakes
 
-| Mistake | Why It's Wrong | Fix |
-|---------|---------------|-----|
-| Using CoT for simple lookups | Adds unnecessary tokens and latency | Reserve for multi-step reasoning |
-| Too few samples in Self-Consistency | Majority voting needs adequate samples | Use 5-10 samples minimum |
-| Generic "think step by step" without checking output | Model may produce irrelevant reasoning | Validate reasoning quality, not just presence |
-| Mixing techniques without understanding trade-offs | Computational cost without benefit | Understand when each technique adds value |
-| Using PAL without code interpreter | Code generation is useless without execution | Ensure execution environment available |
-| Not testing exemplar quality in few-shot CoT | Poor exemplars lead to poor reasoning | Validate exemplars solve problems correctly |
-| Applying Tree of Thoughts to linear problems | Massive overhead for no benefit | Use ToT only when exploration needed |
-
+| Mistake                                              | Why It's Wrong                               | Fix                                           |
+| ---------------------------------------------------- | -------------------------------------------- | --------------------------------------------- |
+| Using CoT for simple lookups                         | Adds unnecessary tokens and latency          | Reserve for multi-step reasoning              |
+| Too few samples in Self-Consistency                  | Majority voting needs adequate samples       | Use 5-10 samples minimum                      |
+| Generic "think step by step" without checking output | Model may produce irrelevant reasoning       | Validate reasoning quality, not just presence |
+| Mixing techniques without understanding trade-offs   | Computational cost without benefit           | Understand when each technique adds value     |
+| Using PAL without code interpreter                   | Code generation is useless without execution | Ensure execution environment available        |
+| Not testing exemplar quality in few-shot CoT         | Poor exemplars lead to poor reasoning        | Validate exemplars solve problems correctly   |
+| Applying Tree of Thoughts to linear problems         | Massive overhead for no benefit              | Use ToT only when exploration needed          |
 
 ---
 

package/skills/cek-thought-based-reasoning/manifest.json

@@ -9,9 +9,7 @@
     "tree of thoughts",
     "reasoning"
   ],
-  "applicable_agents": [
-    "critic"
-  ],
+  "applicable_agents": ["critic"],
   "max_context_tokens": 2600,
   "entry_file": "SKILL.md"
 }

package/skills/context-degradation/SKILL.md

@@ -10,6 +10,7 @@ Language models exhibit predictable degradation patterns as context length incre
 ## When to Activate
 
 Activate this skill when:
+
 - Agent performance degrades unexpectedly during long conversations
 - Debugging cases where agents produce incorrect or irrelevant outputs
 - Designing systems that must handle large contexts reliably
@@ -159,6 +160,7 @@ Implement these strategies through specific architectural patterns. Use just-in-
 ## Examples
 
 **Example 1: Detecting Degradation**
+
 ```yaml
 # Context grows during long conversation
 turn_1: 1000 tokens
@@ -169,19 +171,23 @@ turn_30: 90000 tokens (significant degradation)
 ```
 
 **Example 2: Mitigating Lost-in-Middle**
+
 ```markdown
 # Organize context with critical info at edges
 
-[CURRENT TASK]                      # At start
+[CURRENT TASK] # At start
+
 - Goal: Generate quarterly report
 - Deadline: End of week
 
-[DETAILED CONTEXT]                  # Middle (less attention)
+[DETAILED CONTEXT] # Middle (less attention)
+
 - 50 pages of data
 - Multiple analysis sections
 - Supporting evidence
 
-[KEY FINDINGS]                     # At end
+[KEY FINDINGS] # At end
+
 - Revenue up 15%
 - Costs down 8%
 - Growth in Region A
@@ -200,23 +206,18 @@ turn_30: 90000 tokens (significant degradation)
 
 ## Integration
 
-This skill builds on context-fundamentals and should be studied after understanding basic context concepts. It connects to:
+This skill builds on understanding basic context mechanics (attention patterns, token budgets, placement strategies) and connects to:
 
-- context-optimization - Techniques for mitigating degradation
-- multi-agent-patterns - Using isolation to prevent degradation
-- evaluation - Measuring and detecting degradation in production
+- **evaluation** - Measuring and detecting degradation in production
 
 ## References
 
-Internal reference:
-- [Degradation Patterns Reference](./references/patterns.md) - Detailed technical reference
-
 Related skills in this collection:
-- context-fundamentals - Context basics
-- context-optimization - Mitigation techniques
-- evaluation - Detection and measurement
+
+- **evaluation** - Detection and measurement
 
 External resources:
+
 - Research on attention mechanisms and context window limitations
 - Studies on the "lost-in-middle" phenomenon
 - Production engineering guides from AI labs

package/skills/context-degradation/manifest.json

@@ -9,9 +9,7 @@
     "context confusion",
     "attention pattern"
   ],
-  "applicable_agents": [
-    "strategist"
-  ],
+  "applicable_agents": ["strategist"],
   "max_context_tokens": 2200,
   "entry_file": "SKILL.md"
 }