This commit is contained in:
39
packages/sdk/src/starter-skills/brainstorm.md
Normal file
39
packages/sdk/src/starter-skills/brainstorm.md
Normal file
@@ -0,0 +1,39 @@
|
||||
# Brainstorm — Structured Ideation with Convergence
|
||||
|
||||
Facilitate a structured brainstorming session that moves from wide-open ideation to prioritized, actionable ideas.
|
||||
|
||||
## What to do
|
||||
|
||||
Run three distinct phases. Announce each phase transition clearly.
|
||||
|
||||
### Phase 1: Diverge (Generate)
|
||||
|
||||
- Generate as many ideas as possible related to the topic
|
||||
- No filtering, no judgment — quantity over quality
|
||||
- Include obvious ideas, wild ideas, and combinations
|
||||
- Build on workspace context and memory for relevant starting points
|
||||
- Aim for 15-25 ideas minimum
|
||||
- Present as a rapid-fire numbered list
|
||||
|
||||
### Phase 2: Cluster (Organize)
|
||||
|
||||
- Group related ideas into 3-6 themes
|
||||
- Name each cluster with a clear label
|
||||
- Identify which ideas overlap or reinforce each other
|
||||
- Note outlier ideas that do not fit any cluster — these are sometimes the most interesting
|
||||
- Present clusters with their member ideas
|
||||
|
||||
### Phase 3: Converge (Prioritize)
|
||||
|
||||
- Evaluate each cluster on feasibility and impact
|
||||
- Rank the top 3-5 ideas overall with brief rationale
|
||||
- For the top idea, sketch a rough next step
|
||||
- Ask the user which direction resonates most
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Keep the energy high in Phase 1 — do not self-censor
|
||||
- In Phase 2, let the user adjust clusters before moving on
|
||||
- In Phase 3, be honest about tradeoffs — do not oversell any idea
|
||||
- Pull from workspace context to ground ideas in what the user is actually working on
|
||||
- If the topic is vague, ask one clarifying question before starting Phase 1
|
||||
28
packages/sdk/src/starter-skills/catch-up.md
Normal file
28
packages/sdk/src/starter-skills/catch-up.md
Normal file
@@ -0,0 +1,28 @@
|
||||
# Catch-Up — Workspace Restart Summary
|
||||
|
||||
When the user returns to a workspace after time away, provide an instant orientation summary.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Check session history** — Review the most recent sessions in this workspace. Identify what was being worked on, where things left off, and any unfinished threads.
|
||||
|
||||
2. **Surface key decisions** — Pull any decisions made in recent sessions. State each decision clearly: what was decided, why, and what alternatives were considered.
|
||||
|
||||
3. **List open threads** — Identify work that was started but not completed. For each thread: what it is, where it stands, and what the next step would be.
|
||||
|
||||
4. **Suggest next actions** — Based on open threads and recent momentum, recommend 2-3 concrete next steps the user could take right now.
|
||||
|
||||
## Output format
|
||||
|
||||
Structure your response as:
|
||||
|
||||
- **Last active**: When the workspace was last used
|
||||
- **Context**: 2-3 sentence summary of what this workspace is about
|
||||
- **Recent progress**: Bullet list of what was accomplished
|
||||
- **Key decisions**: Any decisions made with brief rationale
|
||||
- **Open threads**: Unfinished work with status
|
||||
- **Suggested next steps**: 2-3 actionable items, ordered by priority
|
||||
|
||||
## Tone
|
||||
|
||||
Be concise and oriented toward action. The user wants to get back into flow quickly, not read a novel. Lead with the most important information. If nothing significant has happened, say so briefly.
|
||||
44
packages/sdk/src/starter-skills/code-review.md
Normal file
44
packages/sdk/src/starter-skills/code-review.md
Normal file
@@ -0,0 +1,44 @@
|
||||
---
|
||||
permissions:
|
||||
fileSystem: true
|
||||
---
|
||||
|
||||
# Code Review — Structured Code Analysis
|
||||
|
||||
Perform a thorough, structured code review with actionable feedback organized by priority.
|
||||
|
||||
## What to do
|
||||
|
||||
When the user shares code or points to files, review systematically across these dimensions:
|
||||
|
||||
1. **Correctness** — Does the code do what it claims to do? Check logic errors, off-by-one errors, null/undefined handling, async/await correctness, error propagation.
|
||||
|
||||
2. **Edge cases** — What inputs or conditions could break this? Empty arrays, null values, concurrent access, very large inputs, network failures, timeout scenarios.
|
||||
|
||||
3. **Naming and clarity** — Are variables, functions, and types named clearly? Could someone unfamiliar with the codebase understand the intent?
|
||||
|
||||
4. **Tests** — Are there tests? Do they cover the important paths? Are edge cases tested? Suggest specific test cases that are missing.
|
||||
|
||||
5. **Security** — Input validation, injection risks, authentication checks, sensitive data exposure, dependency vulnerabilities.
|
||||
|
||||
6. **Performance** — Unnecessary loops, N+1 queries, missing indexes, large allocations, blocking operations in async contexts.
|
||||
|
||||
## Output structure
|
||||
|
||||
Organize findings by severity:
|
||||
|
||||
- **Critical**: Bugs, security issues, data loss risks — must fix
|
||||
- **Important**: Logic issues, missing error handling, test gaps — should fix
|
||||
- **Suggestion**: Style improvements, refactoring opportunities, alternative approaches — nice to fix
|
||||
|
||||
For each finding:
|
||||
- **Location**: File and line reference
|
||||
- **Issue**: What is wrong
|
||||
- **Fix**: Specific suggestion for how to resolve it
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Be specific — reference exact lines and provide concrete fix suggestions
|
||||
- Praise good patterns too, not just problems
|
||||
- Keep suggestions proportional — do not nitpick style in code with logic bugs
|
||||
- If the code is solid, say so confidently
|
||||
35
packages/sdk/src/starter-skills/compare-docs.md
Normal file
35
packages/sdk/src/starter-skills/compare-docs.md
Normal file
@@ -0,0 +1,35 @@
|
||||
# Compare Docs — Side-by-Side Document Comparison
|
||||
|
||||
Identify and highlight differences between two documents or versions of content.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Accept two inputs** — Ask the user for the two documents, text blocks, or file references to compare. These can be different versions of the same document, competing proposals, or any two pieces of text.
|
||||
|
||||
2. **Analyze differences** — Compare the documents and categorize changes:
|
||||
- **Additions**: Content present in the second but not the first
|
||||
- **Removals**: Content present in the first but not the second
|
||||
- **Changes**: Content that exists in both but was modified
|
||||
- **Moved**: Content that appears in both but in different locations
|
||||
|
||||
3. **Highlight significance** — Not all changes matter equally. Flag:
|
||||
- **Substantive changes**: Meaning, facts, or commitments that changed
|
||||
- **Structural changes**: Reorganization, new/removed sections
|
||||
- **Minor edits**: Wording, formatting, typos
|
||||
|
||||
4. **Identify conflicts** — If the documents represent parallel edits, note where changes conflict and suggest a resolution.
|
||||
|
||||
## Output structure
|
||||
|
||||
- **Overview**: Summary of change magnitude (minor edits / significant revision / major rewrite)
|
||||
- **Key changes**: The most important differences, explained
|
||||
- **Detailed comparison**: Section-by-section breakdown
|
||||
- **Conflicts**: Any contradictions between the documents
|
||||
- **Recommendation**: If applicable, which version is stronger and why
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Present the most significant changes first
|
||||
- Use clear formatting to distinguish additions, removals, and changes
|
||||
- If documents are very similar, focus on the few meaningful differences
|
||||
- If documents are very different, summarize themes rather than listing every change
|
||||
40
packages/sdk/src/starter-skills/daily-plan.md
Normal file
40
packages/sdk/src/starter-skills/daily-plan.md
Normal file
@@ -0,0 +1,40 @@
|
||||
# Daily Plan — Morning Planning from Context
|
||||
|
||||
Help the user plan their day by reviewing workspace context, recent progress, and priorities.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Review yesterday** — Check recent session history and memory. Summarize what was accomplished and what was left unfinished.
|
||||
|
||||
2. **Surface priorities** — Identify the most important items based on:
|
||||
- Unfinished tasks from yesterday
|
||||
- Upcoming deadlines mentioned in workspace context
|
||||
- Open threads that need attention
|
||||
- Blockers that need resolution
|
||||
|
||||
3. **Build today's plan** — Create a prioritized task list for the day. For each item:
|
||||
- What to do (specific and actionable)
|
||||
- Why it matters (priority rationale)
|
||||
- Estimated time needed
|
||||
- Best time to tackle it (deep work vs. quick win)
|
||||
|
||||
4. **Suggest time allocation** — Recommend how to structure the day:
|
||||
- Start with a quick win for momentum, or
|
||||
- Start with the hardest item while energy is high
|
||||
- Group related tasks together
|
||||
- Leave buffer time for unexpected items
|
||||
|
||||
## Output structure
|
||||
|
||||
- **Yesterday's progress**: Brief recap (3-5 bullets)
|
||||
- **Carry-over items**: Unfinished work from yesterday
|
||||
- **Today's priorities**: Ranked list with time estimates
|
||||
- **Suggested schedule**: Rough time blocks
|
||||
- **End-of-day goal**: What "a good day" looks like
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Keep the plan realistic — do not overload the day
|
||||
- Account for meetings and interruptions (ask if the user has any)
|
||||
- Highlight the single most important thing to accomplish today
|
||||
- If the workspace is sparse, ask the user what they want to focus on
|
||||
34
packages/sdk/src/starter-skills/decision-matrix.md
Normal file
34
packages/sdk/src/starter-skills/decision-matrix.md
Normal file
@@ -0,0 +1,34 @@
|
||||
# Decision Matrix — Weighted Option Comparison
|
||||
|
||||
Help the user compare options systematically using weighted criteria and structured scoring.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Identify the decision** — Clarify what is being decided. What are the options? If the user is vague, ask focused questions to surface the real choices.
|
||||
|
||||
2. **Define criteria** — Work with the user to list evaluation criteria (e.g., cost, speed, quality, risk, effort). Aim for 4-8 criteria.
|
||||
|
||||
3. **Weight criteria** — Ask the user to assign importance weights (1-5 or percentages). If they are unsure, suggest reasonable defaults based on the context.
|
||||
|
||||
4. **Score each option** — Rate each option against each criterion on a 1-5 scale. Explain the rationale for each score briefly.
|
||||
|
||||
5. **Calculate and present** — Compute weighted scores. Present as a table with options as rows and criteria as columns. Show raw scores, weighted scores, and totals.
|
||||
|
||||
6. **Make a recommendation** — State which option scores highest and why. Flag any criteria where the top option is notably weak. Mention if scores are very close.
|
||||
|
||||
## Output format
|
||||
|
||||
```
|
||||
| Criteria (weight) | Option A | Option B | Option C |
|
||||
|-------------------|----------|----------|----------|
|
||||
| Cost (5) | 4 (20) | 2 (10) | 3 (15) |
|
||||
| Speed (3) | 3 (9) | 5 (15) | 4 (12) |
|
||||
| Total | 29 | 25 | 27 |
|
||||
```
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Surface hidden criteria the user may not have considered
|
||||
- Call out when a decision is clear-cut vs. genuinely close
|
||||
- Note if any option has a dealbreaker score on a critical criterion
|
||||
- Offer sensitivity analysis: "If you weighted X higher, Option B wins instead"
|
||||
30
packages/sdk/src/starter-skills/draft-memo.md
Normal file
30
packages/sdk/src/starter-skills/draft-memo.md
Normal file
@@ -0,0 +1,30 @@
|
||||
# Draft Memo — Structured Document from Context
|
||||
|
||||
Turn accumulated workspace context into a polished, structured memo ready for sharing or review.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Gather context** — Pull from workspace memory, recent conversations, files, and session history. Identify the core topic and key information.
|
||||
|
||||
2. **Organize into sections** — Structure the memo with clear headings. Default structure:
|
||||
- **Summary** — 2-3 sentence executive overview
|
||||
- **Key Points** — The essential takeaways (bulleted)
|
||||
- **Details** — Supporting information, evidence, data
|
||||
- **Next Steps** — Recommended actions with owners if known
|
||||
|
||||
3. **Synthesize, don't just copy** — Combine information from multiple sources into a coherent narrative. Resolve contradictions. Highlight where information is uncertain or incomplete.
|
||||
|
||||
4. **Match the audience** — Ask who the memo is for if unclear. Adjust tone and detail level: executive (brief, decision-focused), team (action-focused), technical (detail-rich).
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Keep sentences short and direct
|
||||
- Use bullet points for lists of 3+ items
|
||||
- Bold key terms and decisions
|
||||
- Include dates and specifics where available
|
||||
- Flag assumptions explicitly
|
||||
- If workspace context is thin, say what additional information would strengthen the memo
|
||||
|
||||
## Output
|
||||
|
||||
Produce the memo in clean markdown. Offer to adjust tone, length, or structure after the first draft.
|
||||
30
packages/sdk/src/starter-skills/explain-concept.md
Normal file
30
packages/sdk/src/starter-skills/explain-concept.md
Normal file
@@ -0,0 +1,30 @@
|
||||
# Explain Concept — Adjustable-Depth Explanation
|
||||
|
||||
Explain concepts clearly at the depth level the user needs, with examples and connections to existing knowledge.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Identify the concept** — Clarify exactly what the user wants to understand. If the topic is broad, ask which aspect they care about most.
|
||||
|
||||
2. **Choose depth level** — Ask the user or infer from context:
|
||||
- **ELI5**: Simple analogy, no jargon, core idea only. Suitable for complete beginners or quick orientation.
|
||||
- **Technical**: Accurate terminology, how it works, tradeoffs, practical usage. Suitable for practitioners.
|
||||
- **Expert**: Deep mechanics, edge cases, comparison with alternatives, academic or engineering depth.
|
||||
|
||||
3. **Explain** — Structure the explanation as:
|
||||
- **One-sentence summary**: The concept in a single clear sentence
|
||||
- **Core explanation**: The main explanation at the chosen depth
|
||||
- **Example**: A concrete, relatable example
|
||||
- **Analogy**: A comparison to something familiar (especially for ELI5)
|
||||
- **Common misconceptions**: What people often get wrong about this
|
||||
|
||||
4. **Connect to context** — Check workspace memory for related concepts the user has explored. Link this concept to things they already know.
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Start simple, then add complexity — do not front-load jargon
|
||||
- Use concrete examples before abstract definitions
|
||||
- If the user asks a follow-up, adjust depth accordingly
|
||||
- Admit when a concept is genuinely complex — do not oversimplify to the point of being wrong
|
||||
- For technical concepts, include when and why you would use this in practice
|
||||
- Offer to go deeper on any sub-topic
|
||||
42
packages/sdk/src/starter-skills/extract-actions.md
Normal file
42
packages/sdk/src/starter-skills/extract-actions.md
Normal file
@@ -0,0 +1,42 @@
|
||||
# Extract Actions — Pull Action Items from Text
|
||||
|
||||
Extract actionable tasks from unstructured text such as meeting notes, emails, conversations, or documents.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Accept the text** — Take meeting notes, email threads, conversation logs, or any text containing implicit or explicit action items.
|
||||
|
||||
2. **Identify action items** — Scan for:
|
||||
- Explicit commitments ("I will...", "We need to...", "Action: ...")
|
||||
- Implicit tasks ("We should consider...", "It would be good to...")
|
||||
- Follow-ups ("Let's revisit...", "Circle back on...")
|
||||
- Decisions that require implementation
|
||||
- Questions that need answers
|
||||
|
||||
3. **Structure each action** — For every action item, extract:
|
||||
- **Action**: Clear, specific task description (start with a verb)
|
||||
- **Owner**: Who is responsible (name or role, or "Unassigned" if unclear)
|
||||
- **Deadline**: When it is due (or "No deadline" if not specified)
|
||||
- **Priority**: High / Medium / Low based on context and urgency
|
||||
- **Context**: The original quote or reference that generated this action
|
||||
|
||||
4. **Organize by priority** — Group actions by priority level, then by owner.
|
||||
|
||||
## Output format
|
||||
|
||||
```
|
||||
## High Priority
|
||||
- [ ] [Action] — Owner: [name] — Due: [date]
|
||||
Context: "[relevant quote]"
|
||||
|
||||
## Medium Priority
|
||||
...
|
||||
```
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Be thorough — catch implicit actions, not just explicit ones
|
||||
- Do not invent actions that are not supported by the text
|
||||
- If ownership is ambiguous, flag it and suggest who might own it
|
||||
- Merge duplicate or overlapping actions
|
||||
- Ask the user to confirm owners and deadlines for ambiguous items
|
||||
56
packages/sdk/src/starter-skills/index.ts
Normal file
56
packages/sdk/src/starter-skills/index.ts
Normal file
@@ -0,0 +1,56 @@
|
||||
import * as fs from 'node:fs';
|
||||
import * as path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
/**
|
||||
* Get the directory containing starter skill files.
|
||||
* Resolves to the source directory containing .md files.
|
||||
*/
|
||||
export function getStarterSkillsDir(): string {
|
||||
// When running from compiled output (dist/), go up to package root then into src/
|
||||
// When running from source (src/), we're already in the right place
|
||||
const srcDir = path.resolve(__dirname, '..', '..', 'src', 'starter-skills');
|
||||
if (fs.existsSync(srcDir) && fs.readdirSync(srcDir).some(f => f.endsWith('.md'))) {
|
||||
return srcDir;
|
||||
}
|
||||
// Fallback: same directory (running directly from source)
|
||||
return __dirname;
|
||||
}
|
||||
|
||||
/**
|
||||
* List all starter skill names (without .md extension).
|
||||
*/
|
||||
export function listStarterSkills(): string[] {
|
||||
const dir = getStarterSkillsDir();
|
||||
if (!fs.existsSync(dir)) return [];
|
||||
return fs.readdirSync(dir)
|
||||
.filter(f => f.endsWith('.md'))
|
||||
.map(f => f.replace(/\.md$/, ''))
|
||||
.sort();
|
||||
}
|
||||
|
||||
/**
|
||||
* Install starter skills into a target directory (e.g., ~/.waggle/skills/).
|
||||
* Only installs skills that don't already exist (no overwrite).
|
||||
* Returns list of installed skill names.
|
||||
*/
|
||||
export function installStarterSkills(targetDir: string): string[] {
|
||||
const sourceDir = getStarterSkillsDir();
|
||||
if (!fs.existsSync(sourceDir)) return [];
|
||||
if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
|
||||
|
||||
const installed: string[] = [];
|
||||
const files = fs.readdirSync(sourceDir).filter(f => f.endsWith('.md'));
|
||||
|
||||
for (const file of files) {
|
||||
const targetPath = path.join(targetDir, file);
|
||||
if (!fs.existsSync(targetPath)) {
|
||||
fs.copyFileSync(path.join(sourceDir, file), targetPath);
|
||||
installed.push(file.replace(/\.md$/, ''));
|
||||
}
|
||||
}
|
||||
|
||||
return installed;
|
||||
}
|
||||
34
packages/sdk/src/starter-skills/meeting-prep.md
Normal file
34
packages/sdk/src/starter-skills/meeting-prep.md
Normal file
@@ -0,0 +1,34 @@
|
||||
# Meeting Prep — Context-Aware Meeting Preparation
|
||||
|
||||
Prepare for meetings by pulling relevant context from the workspace and generating structured preparation materials.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Identify the meeting** — Ask for meeting topic, attendees, and purpose if not provided. Check workspace memory for related prior discussions.
|
||||
|
||||
2. **Generate agenda items** — Based on workspace context, suggest 3-7 agenda items ordered by priority. Include time estimates if the user specifies meeting duration.
|
||||
|
||||
3. **Build talking points** — For each agenda item, provide:
|
||||
- Key point to make (1-2 sentences)
|
||||
- Supporting data or context from workspace
|
||||
- Potential questions others might raise
|
||||
|
||||
4. **Prepare questions to ask** — Generate 3-5 questions the user should ask, based on gaps in current knowledge or decisions that need to be made.
|
||||
|
||||
5. **Pull relevant background** — Search workspace memory for related decisions, open threads, and prior meeting outcomes that provide context.
|
||||
|
||||
## Output structure
|
||||
|
||||
- **Meeting**: Topic and purpose
|
||||
- **Suggested agenda**: Numbered items with time estimates
|
||||
- **Talking points**: Per agenda item
|
||||
- **Questions to ask**: With rationale for each
|
||||
- **Background context**: Relevant prior decisions and open items
|
||||
- **Pre-meeting actions**: Anything to prepare or send beforehand
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Prioritize actionable items over informational ones
|
||||
- Flag decisions that need to be made in this meeting
|
||||
- Note any conflicts or tensions that may arise based on workspace context
|
||||
- Keep talking points concise — the user needs glanceable notes, not scripts
|
||||
27
packages/sdk/src/starter-skills/plan-execute.md
Normal file
27
packages/sdk/src/starter-skills/plan-execute.md
Normal file
@@ -0,0 +1,27 @@
|
||||
---
|
||||
permissions:
|
||||
codeExecution: true
|
||||
fileSystem: true
|
||||
---
|
||||
|
||||
# Plan & Execute — Structured Task Decomposition
|
||||
|
||||
A multi-agent workflow: planner breaks down the task, executors work on sub-tasks, summarizer consolidates results.
|
||||
|
||||
## When to use
|
||||
- Complex tasks that benefit from decomposition
|
||||
- Work that has multiple independent sub-tasks
|
||||
- When you want structured progress through a large task
|
||||
|
||||
## How it works
|
||||
This skill uses the `orchestrate_workflow` tool with the `plan-execute` template:
|
||||
1. **Planner** — Analyzes the task and breaks it into concrete sub-tasks
|
||||
2. **Executor** — Works through each sub-task methodically
|
||||
3. **Summarizer** — Consolidates all executor results into a final deliverable
|
||||
|
||||
## Usage
|
||||
Tell the agent: "Use the plan-execute workflow to handle [complex task]"
|
||||
Or directly: `orchestrate_workflow` with template `plan-execute` and the task description.
|
||||
|
||||
## Output
|
||||
A comprehensive result combining all sub-task outputs with a structured summary.
|
||||
35
packages/sdk/src/starter-skills/research-synthesis.md
Normal file
35
packages/sdk/src/starter-skills/research-synthesis.md
Normal file
@@ -0,0 +1,35 @@
|
||||
# Research Synthesis — Multi-Source Investigation
|
||||
|
||||
Conduct structured research across available sources, organize findings, and provide a coherent synthesis.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Clarify the research question** — Restate the question precisely. Identify what the user actually needs to know vs. what they asked literally. Confirm scope boundaries.
|
||||
|
||||
2. **Gather from all sources** — Search workspace memory for prior context. Check files in the workspace. Use web search if available. Note what each source contributes.
|
||||
|
||||
3. **Organize findings** — Group information by theme or sub-question, not by source. For each theme:
|
||||
- Key findings
|
||||
- Supporting evidence
|
||||
- Source attribution
|
||||
- Confidence level (strong, moderate, weak)
|
||||
|
||||
4. **Identify gaps** — Explicitly state what you could not find or verify. Note where sources conflict and which seems more reliable.
|
||||
|
||||
5. **Synthesize** — Provide a unified answer that integrates all sources. Do not just list what each source says. Draw conclusions where the evidence supports them.
|
||||
|
||||
## Output structure
|
||||
|
||||
- **Research question**: Restated clearly
|
||||
- **Key findings**: The most important discoveries (3-5 bullets)
|
||||
- **Detailed findings**: Organized by theme with source attribution
|
||||
- **Gaps and limitations**: What is missing or uncertain
|
||||
- **Synthesis**: Your integrated conclusion
|
||||
- **Suggested follow-ups**: What to research next if needed
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Always cite which source each finding came from
|
||||
- Distinguish between facts, expert opinions, and your inferences
|
||||
- Be honest about uncertainty — do not present weak evidence as strong
|
||||
- Prioritize recency and reliability of sources
|
||||
26
packages/sdk/src/starter-skills/research-team.md
Normal file
26
packages/sdk/src/starter-skills/research-team.md
Normal file
@@ -0,0 +1,26 @@
|
||||
---
|
||||
permissions:
|
||||
network: true
|
||||
---
|
||||
|
||||
# Research Team — Multi-Agent Investigation
|
||||
|
||||
A coordinated 3-agent research workflow: researcher gathers information, synthesizer combines findings, reviewer validates quality.
|
||||
|
||||
## When to use
|
||||
- Complex research questions requiring multiple source types
|
||||
- Topics where quality validation matters
|
||||
- When you need structured, verified research output
|
||||
|
||||
## How it works
|
||||
This skill uses the `orchestrate_workflow` tool with the `research-team` template:
|
||||
1. **Researcher** — Searches web, memory, and files for relevant information
|
||||
2. **Synthesizer** — Combines the researcher's raw findings into a coherent report
|
||||
3. **Reviewer** — Validates accuracy, identifies gaps, and suggests improvements
|
||||
|
||||
## Usage
|
||||
Tell the agent: "Use the research team workflow to investigate [topic]"
|
||||
Or directly: `orchestrate_workflow` with template `research-team` and topic as the task.
|
||||
|
||||
## Output
|
||||
A validated research report with findings organized by theme, source attribution, and identified gaps.
|
||||
48
packages/sdk/src/starter-skills/retrospective.md
Normal file
48
packages/sdk/src/starter-skills/retrospective.md
Normal file
@@ -0,0 +1,48 @@
|
||||
# Retrospective — Team or Solo Reflection
|
||||
|
||||
Facilitate a structured retrospective to learn from recent work and generate improvement actions.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Set the scope** — Clarify the time period or project being reviewed. Check workspace memory for relevant context about what happened during this period.
|
||||
|
||||
2. **Gather observations** — Walk through three categories:
|
||||
|
||||
**What went well**
|
||||
- Successes, good decisions, effective processes
|
||||
- Things to continue doing
|
||||
- Unexpected wins
|
||||
|
||||
**What did not go well**
|
||||
- Problems encountered, delays, frustrations
|
||||
- Process breakdowns, communication gaps
|
||||
- Things that took longer than expected
|
||||
|
||||
**What to change**
|
||||
- Specific process improvements
|
||||
- Tools or workflows to adopt or drop
|
||||
- Habits to build or break
|
||||
|
||||
3. **Generate action items** — For each "what to change" item, create a concrete action:
|
||||
- What specifically will change
|
||||
- Who owns it
|
||||
- When it starts
|
||||
- How to measure if it worked
|
||||
|
||||
4. **Identify patterns** — Look across retrospective items for recurring themes. If the same issues keep appearing, escalate them as systemic problems.
|
||||
|
||||
## Output structure
|
||||
|
||||
- **Period reviewed**: Date range and context
|
||||
- **Went well**: Bulleted list with brief context
|
||||
- **Did not go well**: Bulleted list with brief context
|
||||
- **Changes**: Bulleted list of proposed improvements
|
||||
- **Action items**: Specific, owned, time-bound commitments
|
||||
- **Patterns**: Recurring themes worth addressing structurally
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Keep the tone constructive — focus on improvement, not blame
|
||||
- Be specific — "communication was bad" is not useful; "stakeholder updates were missed in weeks 2-3" is
|
||||
- Limit action items to 3-5 — too many means none get done
|
||||
- Reference workspace history to ground observations in facts
|
||||
21
packages/sdk/src/starter-skills/review-pair.md
Normal file
21
packages/sdk/src/starter-skills/review-pair.md
Normal file
@@ -0,0 +1,21 @@
|
||||
# Review Pair — Writer + Reviewer Cycle
|
||||
|
||||
A 2-agent workflow with revision: writer produces a draft, reviewer critiques, writer revises.
|
||||
|
||||
## When to use
|
||||
- Document drafting that benefits from review
|
||||
- When quality and accuracy matter more than speed
|
||||
- Any writing task where a second opinion improves output
|
||||
|
||||
## How it works
|
||||
This skill uses the `orchestrate_workflow` tool with the `review-pair` template:
|
||||
1. **Writer** — Creates an initial draft based on the task
|
||||
2. **Reviewer** — Critiques the draft for accuracy, clarity, completeness
|
||||
3. **Reviser** — Incorporates reviewer feedback into a final version
|
||||
|
||||
## Usage
|
||||
Tell the agent: "Use the review pair workflow to write [document]"
|
||||
Or directly: `orchestrate_workflow` with template `review-pair` and the writing task.
|
||||
|
||||
## Output
|
||||
A polished document that has been through a draft-review-revise cycle.
|
||||
41
packages/sdk/src/starter-skills/risk-assessment.md
Normal file
41
packages/sdk/src/starter-skills/risk-assessment.md
Normal file
@@ -0,0 +1,41 @@
|
||||
# Risk Assessment — Project Risk Identification and Ranking
|
||||
|
||||
Systematically identify, evaluate, and plan mitigations for project risks.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Understand the project context** — Review workspace memory and recent sessions to understand the project scope, timeline, dependencies, and goals.
|
||||
|
||||
2. **Identify risks** — Scan for risks across these categories:
|
||||
- **Technical**: Technology failures, integration issues, performance problems, security vulnerabilities
|
||||
- **Schedule**: Delays, dependencies, resource constraints, scope creep
|
||||
- **External**: Vendor dependencies, market changes, regulatory issues, third-party API changes
|
||||
- **People**: Key-person dependency, skill gaps, availability, communication breakdowns
|
||||
- **Scope**: Unclear requirements, changing priorities, feature creep
|
||||
|
||||
3. **Evaluate each risk** — For every identified risk:
|
||||
- **Likelihood**: Low (unlikely) / Medium (possible) / High (probable)
|
||||
- **Impact**: Low (minor inconvenience) / Medium (significant delay or cost) / High (project failure or major setback)
|
||||
- **Risk score**: Likelihood x Impact (use 1/2/3 scale, so max score is 9)
|
||||
|
||||
4. **Plan mitigations** — For each medium and high risk:
|
||||
- **Mitigation strategy**: How to reduce likelihood or impact
|
||||
- **Owner**: Who is responsible for monitoring and acting
|
||||
- **Trigger**: What signals that this risk is materializing
|
||||
- **Contingency**: What to do if the risk occurs despite mitigation
|
||||
|
||||
5. **Build risk matrix** — Present as a visual grid:
|
||||
|
||||
```
|
||||
| Low Impact | Medium Impact | High Impact |
|
||||
High Likely | | | [Risk 1] |
|
||||
Med Likely | | [Risk 3] | [Risk 2] |
|
||||
Low Likely | [Risk 5] | [Risk 4] | |
|
||||
```
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Be thorough but realistic — do not list catastrophic scenarios with negligible likelihood
|
||||
- Focus mitigation effort on high-score risks
|
||||
- Review workspace context for risks already identified or encountered
|
||||
- Revisit the assessment periodically — risks change as the project evolves
|
||||
31
packages/sdk/src/starter-skills/status-update.md
Normal file
31
packages/sdk/src/starter-skills/status-update.md
Normal file
@@ -0,0 +1,31 @@
|
||||
# Status Update — Project Progress Report
|
||||
|
||||
Generate a project status update from recent workspace activity, memory, and session history.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Scan recent activity** — Review sessions, memory entries, and files from the reporting period. Default to the last week if no timeframe is specified.
|
||||
|
||||
2. **Categorize progress** — Group accomplishments into logical categories (features, fixes, decisions, research, etc.). Be specific about what was done, not vague.
|
||||
|
||||
3. **Identify blockers** — Surface anything that is preventing progress. Distinguish between active blockers (stuck now) and risks (might block soon).
|
||||
|
||||
4. **Project next steps** — Based on current momentum and open threads, list what comes next in priority order.
|
||||
|
||||
## Output structure
|
||||
|
||||
- **Period**: Date range covered
|
||||
- **Summary**: 1-2 sentence overall status (on track / at risk / behind)
|
||||
- **Progress**: Bulleted list of accomplishments, grouped by category
|
||||
- **Blockers**: Active blockers with impact description
|
||||
- **Risks**: Potential future blockers
|
||||
- **Next steps**: Prioritized list of upcoming work
|
||||
- **Timeline**: Any relevant deadlines or milestones
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Be factual and specific — "Completed API auth module" not "Made progress on backend"
|
||||
- Quantify where possible — number of tasks, percentage complete, time spent
|
||||
- Do not pad thin progress with filler language
|
||||
- If the workspace has little recent activity, say so directly
|
||||
- Match the tone to the audience: brief for executives, detailed for team leads
|
||||
38
packages/sdk/src/starter-skills/task-breakdown.md
Normal file
38
packages/sdk/src/starter-skills/task-breakdown.md
Normal file
@@ -0,0 +1,38 @@
|
||||
# Task Breakdown — Large Task Decomposition
|
||||
|
||||
Break a large, ambiguous task into concrete, actionable steps with clear deliverables and dependencies.
|
||||
|
||||
## What to do
|
||||
|
||||
1. **Understand the goal** — Restate the task and its definition of done. If the goal is vague, ask clarifying questions before proceeding.
|
||||
|
||||
2. **Identify major phases** — Break the work into 2-5 logical phases that represent distinct stages of progress.
|
||||
|
||||
3. **Decompose into steps** — For each phase, create specific tasks. Each task must have:
|
||||
- **Title**: Clear, action-oriented (starts with a verb)
|
||||
- **Deliverable**: What artifact or outcome marks this as done
|
||||
- **Effort estimate**: Small (< 1 hour), Medium (1-4 hours), Large (4-8 hours), XL (multiple days)
|
||||
- **Dependencies**: Which other tasks must be done first (if any)
|
||||
- **Acceptance criteria**: How to verify the task is complete
|
||||
|
||||
4. **Identify the critical path** — Highlight which sequence of tasks determines the minimum total time.
|
||||
|
||||
5. **Flag risks** — Note tasks that are uncertain, have external dependencies, or could take longer than estimated.
|
||||
|
||||
## Output format
|
||||
|
||||
```
|
||||
## Phase 1: [Name]
|
||||
- [ ] Task 1.1: [Title] — [Effort] — Depends: none
|
||||
Deliverable: [what]
|
||||
Acceptance: [criteria]
|
||||
- [ ] Task 1.2: [Title] — [Effort] — Depends: 1.1
|
||||
```
|
||||
|
||||
## Guidelines
|
||||
|
||||
- Tasks should be completable in one sitting (max 1 day)
|
||||
- If a task is larger than XL, break it down further
|
||||
- Order tasks so the user can start immediately with task 1.1
|
||||
- Check workspace memory for prior context on the work
|
||||
- Be realistic about effort — pad estimates for uncertainty
|
||||
Reference in New Issue
Block a user