takomi 2.0.4

package/assets/.agent/skills/subagent-driven-development/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: subagent-driven-development
+description: Use when executing implementation plans with independent tasks in the current session
+---
+
+# Subagent-Driven Development
+
+Execute plan by dispatching fresh subagent per task, with two-stage review after each: spec compliance review first, then code quality review.
+
+**Core principle:** Fresh subagent per task + two-stage review (spec then quality) = high quality, fast iteration
+
+## When to Use
+
+```dot
+digraph when_to_use {
+    "Have implementation plan?" [shape=diamond];
+    "Tasks mostly independent?" [shape=diamond];
+    "Stay in this session?" [shape=diamond];
+    "subagent-driven-development" [shape=box];
+    "executing-plans" [shape=box];
+    "Manual execution or brainstorm first" [shape=box];
+
+    "Have implementation plan?" -> "Tasks mostly independent?" [label="yes"];
+    "Have implementation plan?" -> "Manual execution or brainstorm first" [label="no"];
+    "Tasks mostly independent?" -> "Stay in this session?" [label="yes"];
+    "Tasks mostly independent?" -> "Manual execution or brainstorm first" [label="no - tightly coupled"];
+    "Stay in this session?" -> "subagent-driven-development" [label="yes"];
+    "Stay in this session?" -> "executing-plans" [label="no - parallel session"];
+}
+```
+
+**vs. Executing Plans (parallel session):**
+- Same session (no context switch)
+- Fresh subagent per task (no context pollution)
+- Two-stage review after each task: spec compliance first, then code quality
+- Faster iteration (no human-in-loop between tasks)
+
+## The Process
+
+```dot
+digraph process {
+    rankdir=TB;
+
+    subgraph cluster_per_task {
+        label="Per Task";
+        "Dispatch implementer subagent (./implementer-prompt.md)" [shape=box];
+        "Implementer subagent asks questions?" [shape=diamond];
+        "Answer questions, provide context" [shape=box];
+        "Implementer subagent implements, tests, commits, self-reviews" [shape=box];
+        "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" [shape=box];
+        "Spec reviewer subagent confirms code matches spec?" [shape=diamond];
+        "Implementer subagent fixes spec gaps" [shape=box];
+        "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" [shape=box];
+        "Code quality reviewer subagent approves?" [shape=diamond];
+        "Implementer subagent fixes quality issues" [shape=box];
+        "Mark task complete in TodoWrite" [shape=box];
+    }
+
+    "Read plan, extract all tasks with full text, note context, create TodoWrite" [shape=box];
+    "More tasks remain?" [shape=diamond];
+    "Dispatch final code reviewer subagent for entire implementation" [shape=box];
+    "Use superpowers:finishing-a-development-branch" [shape=box style=filled fillcolor=lightgreen];
+
+    "Read plan, extract all tasks with full text, note context, create TodoWrite" -> "Dispatch implementer subagent (./implementer-prompt.md)";
+    "Dispatch implementer subagent (./implementer-prompt.md)" -> "Implementer subagent asks questions?";
+    "Implementer subagent asks questions?" -> "Answer questions, provide context" [label="yes"];
+    "Answer questions, provide context" -> "Dispatch implementer subagent (./implementer-prompt.md)";
+    "Implementer subagent asks questions?" -> "Implementer subagent implements, tests, commits, self-reviews" [label="no"];
+    "Implementer subagent implements, tests, commits, self-reviews" -> "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)";
+    "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" -> "Spec reviewer subagent confirms code matches spec?";
+    "Spec reviewer subagent confirms code matches spec?" -> "Implementer subagent fixes spec gaps" [label="no"];
+    "Implementer subagent fixes spec gaps" -> "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" [label="re-review"];
+    "Spec reviewer subagent confirms code matches spec?" -> "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" [label="yes"];
+    "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" -> "Code quality reviewer subagent approves?";
+    "Code quality reviewer subagent approves?" -> "Implementer subagent fixes quality issues" [label="no"];
+    "Implementer subagent fixes quality issues" -> "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" [label="re-review"];
+    "Code quality reviewer subagent approves?" -> "Mark task complete in TodoWrite" [label="yes"];
+    "Mark task complete in TodoWrite" -> "More tasks remain?";
+    "More tasks remain?" -> "Dispatch implementer subagent (./implementer-prompt.md)" [label="yes"];
+    "More tasks remain?" -> "Dispatch final code reviewer subagent for entire implementation" [label="no"];
+    "Dispatch final code reviewer subagent for entire implementation" -> "Use superpowers:finishing-a-development-branch";
+}
+```
+
+## Prompt Templates
+
+- `./implementer-prompt.md` - Dispatch implementer subagent
+- `./spec-reviewer-prompt.md` - Dispatch spec compliance reviewer subagent
+- `./code-quality-reviewer-prompt.md` - Dispatch code quality reviewer subagent
+
+## Example Workflow
+
+```
+You: I'm using Subagent-Driven Development to execute this plan.
+
+[Read plan file once: docs/plans/feature-plan.md]
+[Extract all 5 tasks with full text and context]
+[Create TodoWrite with all tasks]
+
+Task 1: Hook installation script
+
+[Get Task 1 text and context (already extracted)]
+[Dispatch implementation subagent with full task text + context]
+
+Implementer: "Before I begin - should the hook be installed at user or system level?"
+
+You: "User level (~/.config/superpowers/hooks/)"
+
+Implementer: "Got it. Implementing now..."
+[Later] Implementer:
+  - Implemented install-hook command
+  - Added tests, 5/5 passing
+  - Self-review: Found I missed --force flag, added it
+  - Committed
+
+[Dispatch spec compliance reviewer]
+Spec reviewer: ✅ Spec compliant - all requirements met, nothing extra
+
+[Get git SHAs, dispatch code quality reviewer]
+Code reviewer: Strengths: Good test coverage, clean. Issues: None. Approved.
+
+[Mark Task 1 complete]
+
+Task 2: Recovery modes
+
+[Get Task 2 text and context (already extracted)]
+[Dispatch implementation subagent with full task text + context]
+
+Implementer: [No questions, proceeds]
+Implementer:
+  - Added verify/repair modes
+  - 8/8 tests passing
+  - Self-review: All good
+  - Committed
+
+[Dispatch spec compliance reviewer]
+Spec reviewer: ❌ Issues:
+  - Missing: Progress reporting (spec says "report every 100 items")
+  - Extra: Added --json flag (not requested)
+
+[Implementer fixes issues]
+Implementer: Removed --json flag, added progress reporting
+
+[Spec reviewer reviews again]
+Spec reviewer: ✅ Spec compliant now
+
+[Dispatch code quality reviewer]
+Code reviewer: Strengths: Solid. Issues (Important): Magic number (100)
+
+[Implementer fixes]
+Implementer: Extracted PROGRESS_INTERVAL constant
+
+[Code reviewer reviews again]
+Code reviewer: ✅ Approved
+
+[Mark Task 2 complete]
+
+...
+
+[After all tasks]
+[Dispatch final code-reviewer]
+Final reviewer: All requirements met, ready to merge
+
+Done!
+```
+
+## Advantages
+
+**vs. Manual execution:**
+- Subagents follow TDD naturally
+- Fresh context per task (no confusion)
+- Parallel-safe (subagents don't interfere)
+- Subagent can ask questions (before AND during work)
+
+**vs. Executing Plans:**
+- Same session (no handoff)
+- Continuous progress (no waiting)
+- Review checkpoints automatic
+
+**Efficiency gains:**
+- No file reading overhead (controller provides full text)
+- Controller curates exactly what context is needed
+- Subagent gets complete information upfront
+- Questions surfaced before work begins (not after)
+
+**Quality gates:**
+- Self-review catches issues before handoff
+- Two-stage review: spec compliance, then code quality
+- Review loops ensure fixes actually work
+- Spec compliance prevents over/under-building
+- Code quality ensures implementation is well-built
+
+**Cost:**
+- More subagent invocations (implementer + 2 reviewers per task)
+- Controller does more prep work (extracting all tasks upfront)
+- Review loops add iterations
+- But catches issues early (cheaper than debugging later)
+
+## Red Flags
+
+**Never:**
+- Start implementation on main/master branch without explicit user consent
+- Skip reviews (spec compliance OR code quality)
+- Proceed with unfixed issues
+- Dispatch multiple implementation subagents in parallel (conflicts)
+- Make subagent read plan file (provide full text instead)
+- Skip scene-setting context (subagent needs to understand where task fits)
+- Ignore subagent questions (answer before letting them proceed)
+- Accept "close enough" on spec compliance (spec reviewer found issues = not done)
+- Skip review loops (reviewer found issues = implementer fixes = review again)
+- Let implementer self-review replace actual review (both are needed)
+- **Start code quality review before spec compliance is ✅** (wrong order)
+- Move to next task while either review has open issues
+
+**If subagent asks questions:**
+- Answer clearly and completely
+- Provide additional context if needed
+- Don't rush them into implementation
+
+**If reviewer finds issues:**
+- Implementer (same subagent) fixes them
+- Reviewer reviews again
+- Repeat until approved
+- Don't skip the re-review
+
+**If subagent fails task:**
+- Dispatch fix subagent with specific instructions
+- Don't try to fix manually (context pollution)
+
+## Integration
+
+**Required workflow skills:**
+- **superpowers:using-git-worktrees** - REQUIRED: Set up isolated workspace before starting
+- **superpowers:writing-plans** - Creates the plan this skill executes
+- **superpowers:requesting-code-review** - Code review template for reviewer subagents
+- **superpowers:finishing-a-development-branch** - Complete development after all tasks
+
+**Subagents should use:**
+- **superpowers:test-driven-development** - Subagents follow TDD for each task
+
+**Alternative workflow:**
+- **superpowers:executing-plans** - Use for parallel session instead of same-session execution

package/assets/.agent/skills/subagent-driven-development/code-quality-reviewer-prompt.md

@@ -0,0 +1,20 @@
+# Code Quality Reviewer Prompt Template
+
+Use this template when dispatching a code quality reviewer subagent.
+
+**Purpose:** Verify implementation is well-built (clean, tested, maintainable)
+
+**Only dispatch after spec compliance review passes.**
+
+```
+Task tool (superpowers:code-reviewer):
+  Use template at requesting-code-review/code-reviewer.md
+
+  WHAT_WAS_IMPLEMENTED: [from implementer's report]
+  PLAN_OR_REQUIREMENTS: Task N from [plan-file]
+  BASE_SHA: [commit before task]
+  HEAD_SHA: [current commit]
+  DESCRIPTION: [task summary]
+```
+
+**Code reviewer returns:** Strengths, Issues (Critical/Important/Minor), Assessment

package/assets/.agent/skills/subagent-driven-development/implementer-prompt.md

@@ -0,0 +1,78 @@
+# Implementer Subagent Prompt Template
+
+Use this template when dispatching an implementer subagent.
+
+```
+Task tool (general-purpose):
+  description: "Implement Task N: [task name]"
+  prompt: |
+    You are implementing Task N: [task name]
+
+    ## Task Description
+
+    [FULL TEXT of task from plan - paste it here, don't make subagent read file]
+
+    ## Context
+
+    [Scene-setting: where this fits, dependencies, architectural context]
+
+    ## Before You Begin
+
+    If you have questions about:
+    - The requirements or acceptance criteria
+    - The approach or implementation strategy
+    - Dependencies or assumptions
+    - Anything unclear in the task description
+
+    **Ask them now.** Raise any concerns before starting work.
+
+    ## Your Job
+
+    Once you're clear on requirements:
+    1. Implement exactly what the task specifies
+    2. Write tests (following TDD if task says to)
+    3. Verify implementation works
+    4. Commit your work
+    5. Self-review (see below)
+    6. Report back
+
+    Work from: [directory]
+
+    **While you work:** If you encounter something unexpected or unclear, **ask questions**.
+    It's always OK to pause and clarify. Don't guess or make assumptions.
+
+    ## Before Reporting Back: Self-Review
+
+    Review your work with fresh eyes. Ask yourself:
+
+    **Completeness:**
+    - Did I fully implement everything in the spec?
+    - Did I miss any requirements?
+    - Are there edge cases I didn't handle?
+
+    **Quality:**
+    - Is this my best work?
+    - Are names clear and accurate (match what things do, not how they work)?
+    - Is the code clean and maintainable?
+
+    **Discipline:**
+    - Did I avoid overbuilding (YAGNI)?
+    - Did I only build what was requested?
+    - Did I follow existing patterns in the codebase?
+
+    **Testing:**
+    - Do tests actually verify behavior (not just mock behavior)?
+    - Did I follow TDD if required?
+    - Are tests comprehensive?
+
+    If you find issues during self-review, fix them now before reporting.
+
+    ## Report Format
+
+    When done, report:
+    - What you implemented
+    - What you tested and test results
+    - Files changed
+    - Self-review findings (if any)
+    - Any issues or concerns
+```

package/assets/.agent/skills/subagent-driven-development/spec-reviewer-prompt.md

@@ -0,0 +1,61 @@
+# Spec Compliance Reviewer Prompt Template
+
+Use this template when dispatching a spec compliance reviewer subagent.
+
+**Purpose:** Verify implementer built what was requested (nothing more, nothing less)
+
+```
+Task tool (general-purpose):
+  description: "Review spec compliance for Task N"
+  prompt: |
+    You are reviewing whether an implementation matches its specification.
+
+    ## What Was Requested
+
+    [FULL TEXT of task requirements]
+
+    ## What Implementer Claims They Built
+
+    [From implementer's report]
+
+    ## CRITICAL: Do Not Trust the Report
+
+    The implementer finished suspiciously quickly. Their report may be incomplete,
+    inaccurate, or optimistic. You MUST verify everything independently.
+
+    **DO NOT:**
+    - Take their word for what they implemented
+    - Trust their claims about completeness
+    - Accept their interpretation of requirements
+
+    **DO:**
+    - Read the actual code they wrote
+    - Compare actual implementation to requirements line by line
+    - Check for missing pieces they claimed to implement
+    - Look for extra features they didn't mention
+
+    ## Your Job
+
+    Read the implementation code and verify:
+
+    **Missing requirements:**
+    - Did they implement everything that was requested?
+    - Are there requirements they skipped or missed?
+    - Did they claim something works but didn't actually implement it?
+
+    **Extra/unneeded work:**
+    - Did they build things that weren't requested?
+    - Did they over-engineer or add unnecessary features?
+    - Did they add "nice to haves" that weren't in spec?
+
+    **Misunderstandings:**
+    - Did they interpret requirements differently than intended?
+    - Did they solve the wrong problem?
+    - Did they implement the right feature but wrong way?
+
+    **Verify by reading code, not by trusting report.**
+
+    Report:
+    - ✅ Spec compliant (if everything matches after code inspection)
+    - ❌ Issues found: [list specifically what's missing or extra, with file:line references]
+```

package/assets/.agent/skills/sync-docs/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: sync-docs
+description: Update feature documentation after code changes. Keep docs in sync with implementation.
+---
+
+# Sync Docs Skill
+
+Update `docs/features/` after major code changes.
+
+## When to Use
+- After completing a feature or fix
+- When documentation is mentioned as outdated
+- After significant refactoring
+- When user asks to "update docs"
+
+## Prerequisites
+- You have just completed a code change
+- You know which files were modified
+
+## Process
+
+### 1. Identify Changed Components
+Focus on:
+- `src/main/` (backend logic)
+- `src/renderer/` (UI components)
+- `src/shared/` (types, constants)
+- `src/features/` (feature modules)
+
+### 2. List Existing Docs
+```bash
+ls docs/features/
+head -20 docs/features/*.md
+```
+
+### 3. Determine Action
+For each changed component:
+- **UPDATE**: Feature already has documentation
+- **CREATE**: New feature, needs new doc
+- **SKIP**: Minor change, already covered
+
+### 4. Documentation Template
+
+```markdown
+# Feature Name
+
+## Overview
+One paragraph explaining what this feature does.
+
+## Architecture
+- **Service/File:** `src/main/path/to/file.ts`
+- **Dependencies:** List key dependencies
+
+## Key Components
+
+### Component 1
+Explanation...
+
+### Component 2
+Explanation...
+
+## Data Flow (optional)
+```mermaid
+flowchart LR
+    A --> B --> C
+```
+
+## Configuration (if applicable)
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| ...     | ...  | ...     | ...         |
+
+## Hotfixes / Changelog (optional)
+### Hotfix YYYY-MM-DD: Brief Title
+- **Problem:** What was broken
+- **Solution:** How it was fixed
+```
+
+### 5. Write Updates
+- **UPDATE**: Use `view_file` → `replace_file_content`
+- **CREATE**: Use `write_to_file` with template
+
+### 6. Verify Links
+Ensure file paths in docs are correct (use backticks).
+
+### 7. Summary
+Report what was done:
+- Updated: `docs/features/foo.md` (added XYZ section)
+- Created: `docs/features/bar.md` (new feature doc)

package/assets/.agent/skills/twitter-automation/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: twitter-automation
+description: |
+  Automate Twitter/X with posting, engagement, and user management via inference.sh CLI.
+  Apps: x/post-tweet, x/post-create (with media), x/post-like, x/post-retweet, x/dm-send, x/user-follow.
+  Capabilities: post tweets, schedule content, like posts, retweet, send DMs, follow users, get profiles.
+  Use for: social media automation, content scheduling, engagement bots, audience growth, X API.
+  Triggers: twitter api, x api, tweet automation, post to twitter, twitter bot,
+  social media automation, x automation, tweet scheduler, twitter integration,
+  post tweet, twitter post, x post, send tweet
+allowed-tools: Bash(infsh *)
+---
+
+# Twitter/X Automation
+
+Automate Twitter/X via [inference.sh](https://inference.sh) CLI.
+
+## Quick Start
+
+```bash
+# Install CLI
+curl -fsSL https://cli.inference.sh | sh && infsh login
+
+# Post a tweet
+infsh app run x/post-tweet --input '{"text": "Hello from inference.sh!"}'
+```
+
+## Available Apps
+
+| App | App ID | Description |
+|-----|--------|-------------|
+| Post Tweet | `x/post-tweet` | Post text tweets |
+| Create Post | `x/post-create` | Post with media |
+| Like Post | `x/post-like` | Like a tweet |
+| Retweet | `x/post-retweet` | Retweet a post |
+| Delete Post | `x/post-delete` | Delete a tweet |
+| Get Post | `x/post-get` | Get tweet by ID |
+| Send DM | `x/dm-send` | Send direct message |
+| Follow User | `x/user-follow` | Follow a user |
+| Get User | `x/user-get` | Get user profile |
+
+## Examples
+
+### Post a Tweet
+
+```bash
+infsh app run x/post-tweet --input '{"text": "Just shipped a new feature! 🚀"}'
+```
+
+### Post with Media
+
+```bash
+infsh app sample x/post-create --save input.json
+
+# Edit input.json:
+# {
+#   "text": "Check out this AI-generated image!",
+#   "media_url": "https://your-image-url.jpg"
+# }
+
+infsh app run x/post-create --input input.json
+```
+
+### Like a Tweet
+
+```bash
+infsh app run x/post-like --input '{"tweet_id": "1234567890"}'
+```
+
+### Retweet
+
+```bash
+infsh app run x/post-retweet --input '{"tweet_id": "1234567890"}'
+```
+
+### Send a DM
+
+```bash
+infsh app run x/dm-send --input '{
+  "recipient_id": "user_id_here",
+  "text": "Hey! Thanks for the follow."
+}'
+```
+
+### Follow a User
+
+```bash
+infsh app run x/user-follow --input '{"username": "elonmusk"}'
+```
+
+### Get User Profile
+
+```bash
+infsh app run x/user-get --input '{"username": "OpenAI"}'
+```
+
+### Get Tweet Details
+
+```bash
+infsh app run x/post-get --input '{"tweet_id": "1234567890"}'
+```
+
+### Delete a Tweet
+
+```bash
+infsh app run x/post-delete --input '{"tweet_id": "1234567890"}'
+```
+
+## Workflow: Generate AI Image and Post
+
+```bash
+# 1. Generate image
+infsh app run falai/flux-dev-lora --input '{"prompt": "sunset over mountains"}' > image.json
+
+# 2. Post to Twitter with the image URL
+infsh app run x/post-create --input '{
+  "text": "AI-generated art of a sunset 🌅",
+  "media_url": "<image-url-from-step-1>"
+}'
+```
+
+## Workflow: Generate and Post Video
+
+```bash
+# 1. Generate video
+infsh app run google/veo-3-1-fast --input '{"prompt": "waves on a beach"}' > video.json
+
+# 2. Post to Twitter
+infsh app run x/post-create --input '{
+  "text": "AI-generated video 🎬",
+  "media_url": "<video-url-from-step-1>"
+}'
+```
+
+## Related Skills
+
+```bash
+# Full platform skill (all 150+ apps)
+npx skills add inference-sh/skills@inference-sh
+
+# Image generation (create images to post)
+npx skills add inference-sh/skills@ai-image-generation
+
+# Video generation (create videos to post)
+npx skills add inference-sh/skills@ai-video-generation
+
+# AI avatars (create presenter videos)
+npx skills add inference-sh/skills@ai-avatar-video
+```
+
+Browse all apps: `infsh app list`
+
+## Documentation
+
+- [X.com Integration](https://inference.sh/docs/integrations/x) - Setting up Twitter/X integration
+- [X.com Integration Example](https://inference.sh/docs/examples/x-integration) - Complete Twitter workflow
+- [Apps Overview](https://inference.sh/docs/apps/overview) - Understanding the app ecosystem